src/device_manager_plugin_emul.c

   1 /*
   2  * Copyright (C) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact:
   5  * Jinhyung Choi <jinhyung2.choi@samsung.com>
   6  * JiHye Kim <jihye1128.kim@samsung.com>
   7  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <stdio.h>
  26 #include <dirent.h>
  27 #include <devman_plugin_intf.h>
  28
  29 #include "devman_define_node_path.h"
  30
  31 #define EXPORT_API  __attribute__((visibility("default")))
  32
  33 #define BUFF_MAX        255
  34 #define MAX_NAME 255
  35
  36 #if 0
  37 #define GENERATE_ACCESSORS_CHAR_RW(_suffix, _item)      \
  38 char *OEM_sys_get_##_suffix(char* str)                  \
  39 {                                               \
  40         return sys_get_str(_item, str); \
  41 }                                               \
  42                                                 \
  43 int OEM_sys_set_##_suffix(char *str)                    \
  44 {                                               \
  45         return sys_set_str(_item, value);       \
  46 }
  47
  48 #define GENERATE_ACCESSORS_CHAR_R(_suffix, _item)       \
  49 char *OEM_sys_get_##_suffix(char* str)                  \
  50 {                                               \
  51         return sys_get_str(_item, str); \
  52 }
  53
  54 #define GENERATE_ACCESSORS_CHAR_W(_suffix, _item)       \
  55 int OEM_sys_set_##_suffix(char *str)                    \
  56 {                                               \
  57         return sys_set_str(_item, str);         \
  58 }
  59 #endif
  60
  61 /* TODO: Add APIs has (char *) params */
  62
  63 #define GENERATE_ACCESSORS_INT_RW(_suffix, _item)       \
  64 int OEM_sys_get_##_suffix(int *value)                   \
  65 {                                               \
  66         return sys_get_int(_item, value);       \
  67 }                                               \
  68                                                 \
  69 int OEM_sys_set_##_suffix(int value)    \
  70 {                                               \
  71         return sys_set_int(_item, value);       \
  72 }
  73
  74 #define GENERATE_ACCESSORS_INT_R(_suffix, _item)        \
  75 int OEM_sys_get_##_suffix(int *value)                   \
  76 {                                               \
  77         return sys_get_int(_item, value);       \
  78 }
  79
  80 #define GENERATE_ACCESSORS_INT_W(_suffix, _item)        \
  81 int OEM_sys_set_##_suffix(int value)                    \
  82 {                                               \
  83         return sys_set_int(_item, value);       \
  84 }
  85
  86 /*
  87 GENERATE_ACCESSORS_INT_R(backlight_max_brightness, BACKLIGHT_MAX_BRIGHTNESS_PATH)
  88 GENERATE_ACCESSORS_INT_RW(backlight_brightness, BACKLIGHT_BRIGHTNESS_PATH)
  89 GENERATE_ACCESSORS_INT_RW(backlight_acl_control, LCD_ACL_CONTROL_PATH)
  90 GENERATE_ACCESSORS_INT_RW(lcd_power, LCD_POWER_PATH)
  91 */
  92
  93 #define DEVMGR_LOG
  94 #if defined(DEVMGR_LOG)
  95 #define LOG_TAG     "DEVICE_PLUGIN"
  96 #include <dlog/dlog.h>
  97 #define devmgr_log(fmt, args...)        SLOGD(fmt, ##args)
  98 #else
  99 #define devmgr_log(fmt, args...)
 100 #endif
 101
 102 enum display_type
 103 {
 104         DISP_MAIN = 0,
 105         DISP_SUB,
 106         DISP_MAX
 107 };
 108
 109 enum lux_status {
 110         decrement,
 111         no_change,
 112         increment,
 113 };
 114
 115 struct display_info
 116 {
 117         enum display_type etype; /* FIXME:!! Main LCD or Sub LCD node */
 118         char bl_name[MAX_NAME]; /* backlight name */
 119         char lcd_name[MAX_NAME]; /* lcd name */
 120 };
 121
 122 #define MAX_CANDELA_CRITERION   300
 123 #define PWR_SAVING_CANDELA_CRITERION    20
 124
 125 /* FIXME:!! change to global_ctx */
 126 int lcd_index;
 127 struct display_info disp_info[DISP_MAX];
 128
 129 /*
 130 int OEM_sys_get_backlight_brightness_by_lux(unsigned int lux, enum lux_status status)
 131 {
 132         static int brightness = -1;
 133
 134         if (status == no_change) {
 135                 if (brightness == -1)
 136                         status = increment;
 137                 else
 138                         return brightness;
 139         }
 140         if (status == decrement) {
 141                 switch (lux) {
 142                 case 10000 ... 0xffffffff:
 143                         brightness =  100;
 144                         break;
 145                 case 1000 ... 9999:
 146                         brightness =  80;
 147                         break;
 148                 case 75 ... 999:
 149                         brightness =  60;
 150                         break;
 151                 case 7 ... 74:
 152                         brightness =  40;
 153                         break;
 154                 case 0 ... 6:
 155                         brightness =  1;
 156                         break;
 157                 default:
 158                         return -1;
 159                 }
 160         } else if (status == increment) {
 161                 switch (lux) {
 162                 case 15001 ... 0xffffffff:
 163                         brightness =  100;
 164                         break;
 165                 case 1501 ... 15000:
 166                         brightness =  80;
 167                         break;
 168                 case 151 ...  1500:
 169                         brightness =  60;
 170                         break;
 171                 case 16 ... 150:
 172                         brightness =  40;
 173                         break;
 174                 case 0 ... 15:
 175                         brightness =  1;
 176                         break;
 177                 default:
 178                         return -1;
 179                 }
 180         } else
 181                 return -1;
 182
 183         return brightness;
 184 }
 185 */
 186 int OEM_sys_get_brightness(unsigned int lux)
 187 {
 188         const unsigned int Nr_Table[] = {
 189                 0, 5, 5, 6, 6, 7, 8, 8, 9, 9,
 190                 10, 11, 12, 13, 13, 14, 15, 16, 18, 19,
 191                 20, 22, 23, 25, 29, 32, 36, 39, 43, 46,
 192                 50, 54, 57, 61, 64, 68, 71, 75, 79, 82,
 193                 86, 89, 93, 96, 100, 119, 138, 157, 176, 195,
 194                 214, 233, 252, 271, 290, 310, 329, 348, 367, 386,
 195                 405, 424, 443, 462, 481, 500, 571, 643, 714, 786,
 196                 857, 929, 1000, 1100, 1200, 1300, 1400, 1500, 1667, 1833,
 197                 2000, 2250, 2500, 2750, 3000, 3333, 3667, 4000, 4083, 4167,
 198                 4250, 4333, 4417, 4500, 4583, 4667, 4750, 4833, 4917, 5000,
 199         };
 200         int brightness;
 201
 202         for (brightness=0; (lux > Nr_Table[brightness]) && (brightness < 99); brightness++);
 203
 204         return brightness;
 205 }
 206
 207 int OEM_sys_get_backlight_brightness_by_lux(int lux, int *value)
 208 {
 209         const unsigned int Max_Table[] = {
 210                 15, 15, 15, 15, 16, 17, 18, 20, 21, 23,
 211                 26, 28, 31, 33, 35, 38, 40, 44, 48, 51,
 212                 55, 60, 65, 70, 81, 92, 103, 114, 125, 136,
 213                 147, 158, 169, 180, 190, 201, 212, 223, 234, 245,
 214                 256, 267, 278, 289, 300, 357, 414, 471, 529, 586,
 215                 643, 700, 757, 814, 871, 929, 986, 1043, 1100, 1157,
 216                 1214, 1271, 1329, 1386, 1443, 1500, 1678, 1855, 2033, 2211,
 217                 2389, 2566, 2744, 2977, 3209, 3442, 3674, 3907, 4274, 4642,
 218                 5009, 5215, 5422, 5628, 5834, 6057, 6279, 6502, 6585, 6669,
 219                 6752, 6835, 6919, 7002, 7085, 7169, 7252, 7335, 7419, 7502,
 220         };
 221         const unsigned int Min_Table[] = {
 222                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 223                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 224                 1, 1, 1, 1, 1, 1, 1, 2, 2, 3,
 225                 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
 226                 8, 9, 9, 10, 10, 12, 14, 16, 17, 19,
 227                 21, 23, 25, 27, 29, 30, 32, 34, 36, 38,
 228                 40, 42, 43, 45, 47, 49, 60, 70, 81, 91,
 229                 102, 112, 123, 140, 157, 174, 191, 208, 240, 271,
 230                 303, 356, 409, 461, 514, 592, 670, 748, 769, 790,
 231                 811, 832, 853, 874, 895, 916, 937, 958, 979, 1000,
 232         };
 233         static int brightness = -1;
 234
 235         if (brightness == -1) {
 236                 brightness = OEM_sys_get_brightness(lux);
 237                 devmgr_log("lux: %d, brightness: %d.\n", lux, brightness+1);
 238         } else if ((lux > Max_Table[brightness]) || (lux < Min_Table[brightness])) {
 239                 brightness = OEM_sys_get_brightness(lux);
 240                 devmgr_log("lux: %d, brightness: %d.\n", lux, brightness+1);
 241         }
 242         *value = brightness+1;
 243         return 0;
 244 }
 245
 246 static int OEM_sys_display_info(struct display_info *disp_info)
 247 {
 248         struct dirent *dent;
 249         DIR *dirp;
 250         int i, index;
 251         const char * bl_path = BACKLIGHT_PATH;
 252         const char * lcd_path = LCD_PATH;
 253
 254         /* Backlight */
 255         index = 0;
 256         dirp = opendir(bl_path);
 257         if (dirp) {
 258                 while ((dent = readdir(dirp)) != NULL) {
 259                         if (index >= DISP_MAX) {
 260                                 devmgr_log("supports %d display node", DISP_MAX);
 261                                 break;
 262                         }
 263
 264                         if (!strncmp(".", dent->d_name, sizeof(".")) || !strncmp("..", dent->d_name, sizeof("..")))
 265                                 continue;
 266                         else {
 267                                 memcpy(disp_info[index].bl_name, dent->d_name, sizeof(disp_info[index].bl_name) - 1);
 268                                 index++;
 269                         }
 270                 }
 271                 closedir(dirp);
 272         }
 273
 274         for (i = 0; i < index; i++)
 275                 devmgr_log("bl_name[%s]", disp_info[i].bl_name);
 276
 277         /* LCD */
 278         index = 0;
 279         dirp = opendir(lcd_path);
 280         if (dirp) {
 281                 while ((dent = readdir(dirp)) != NULL) {
 282                         if (index >= DISP_MAX) {
 283                                 devmgr_log("supports %d display node", DISP_MAX);
 284                                 break;
 285                         }
 286
 287                         if (!strncmp(".", dent->d_name, sizeof(".")) || !strncmp("..", dent->d_name, sizeof("..")))
 288                                 continue;
 289                         else {
 290                                 memcpy(disp_info[index].lcd_name, dent->d_name, sizeof(disp_info[index].lcd_name) - 1);
 291                                 index++;
 292                         }
 293                 }
 294                 closedir(dirp);
 295         }
 296
 297         for (i = 0; i < index; i++)
 298                 devmgr_log("lcd_name[%s]", disp_info[i].lcd_name);
 299
 300         lcd_index = index;
 301
 302         return 0;
 303 }
 304
 305 int OEM_sys_get_display_count(int *value)
 306 {
 307         int ret = -1;
 308
 309         /* TODO: We should implement to find out current number of display */
 310         *value = lcd_index;
 311         ret = 0;
 312         /* ********************* */
 313
 314         devmgr_log("value[%d]", *value);
 315
 316         return ret;
 317 }
 318
 319 int OEM_sys_get_backlight_max_brightness(int index, int *value)
 320 {
 321         int ret = -1;
 322         char path[MAX_NAME+1] = {0,};
 323
 324         if (index >= DISP_MAX) {
 325                 devmgr_log("supports %d display node", DISP_MAX);
 326                 return ret;
 327         }
 328
 329         snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 330         ret = sys_get_int(path, value);
 331         devmgr_log("path[%s]value[%d]", path, *value);
 332
 333         return ret;
 334 }
 335
 336 int OEM_sys_get_backlight_min_brightness(int index, int *value)
 337 {
 338     int ret = -1;
 339     char path[MAX_NAME+1] = {0,};
 340
 341     if (index >= DISP_MAX) {
 342         devmgr_log("supports %d display node", DISP_MAX);
 343         return ret;
 344     }
 345
 346     snprintf(path, MAX_NAME, BACKLIGHT_MIN_BRIGHTNESS_PATH, disp_info[index].bl_name);
 347     ret = sys_get_int(path, value);
 348     devmgr_log("path[%s]value[%d]", path, *value);
 349
 350     return ret;
 351 }
 352
 353 int OEM_sys_get_backlight_brightness(int index, int *value, int power_saving)
 354 {
 355         int ret = -1;
 356         char path[MAX_NAME+1] = {0,};
 357         int max_brightness;
 358         int pwr_saving_offset;
 359
 360         if (index >= DISP_MAX) {
 361                 devmgr_log("supports %d display node", DISP_MAX);
 362                 return ret;
 363         }
 364
 365         snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name);
 366         ret = sys_get_int(path, value);
 367         devmgr_log("path[%s]value[%d]power_saving[%d]", path, *value, power_saving);
 368
 369         if (power_saving){
 370                 snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 371                 ret = sys_get_int(path, &max_brightness);
 372                 if (ret)
 373                 {
 374                         devmgr_log("Can't read max_brightness node[%s]", path);
 375                         return ret;
 376                 }
 377                 pwr_saving_offset = (int)((PWR_SAVING_CANDELA_CRITERION * (float)max_brightness / MAX_CANDELA_CRITERION) + 0.5);
 378
 379                 if (*value > max_brightness - pwr_saving_offset)
 380                         *value = max_brightness;
 381                 else
 382                         *value = *value + pwr_saving_offset;
 383
 384                 devmgr_log("power_saving result[%d]", *value);
 385         }
 386
 387         return ret;
 388 }
 389
 390 static int OEM_sys_set_backlight_brightness(int index, int value, int power_saving)
 391 {
 392         int ret = -1;
 393         char path[MAX_NAME+1] = {0,};
 394         int max_brightness;
 395         int pwr_saving_offset;
 396
 397         if (index >= DISP_MAX) {
 398                 devmgr_log("supports %d display node", DISP_MAX);
 399                 return ret;
 400         }
 401
 402         devmgr_log("path[%s]value[%d]power_saving[%d]", path, value, power_saving);
 403
 404         if (power_saving){
 405                 snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 406                 ret = sys_get_int(path, &max_brightness);
 407                 if (ret)
 408                 {
 409                         devmgr_log("Can't read max_brightness node[%s]", path);
 410                         return ret;
 411                 }
 412                 pwr_saving_offset = (int)((PWR_SAVING_CANDELA_CRITERION * (float)max_brightness / MAX_CANDELA_CRITERION) + 0.5);
 413
 414                 if (value < pwr_saving_offset)
 415                         value = 0;
 416                 else
 417                         value = value - pwr_saving_offset;
 418
 419                 devmgr_log("power_saving result[%d]", value);
 420         }
 421
 422         snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name);
 423         ret = sys_set_int(path, value);
 424
 425         return ret;
 426 }
 427
 428 int OEM_sys_set_backlight_dimming(int index, int value)
 429 {
 430     /*
 431     int ret = -1;
 432     char path[MAX_NAME+1];
 433
 434     if (index >= DISP_MAX) {
 435         devmgr_log("supports %d display node", DISP_MAX);
 436         return ret;
 437     }
 438
 439     snprintf(path, MAX_NAME, BACKLIGHT_DIMMING_PATH, disp_info[index].lcd_name);
 440     devmgr_log("path[%s]value[%d]", path, value);
 441     ret = sys_set_int(path, value);
 442     return ret;
 443     */
 444
 445     // TODO : value is only 1
 446     return OEM_sys_set_backlight_brightness(index, 1, 0/*power_saving*/);
 447
 448 }
 449
 450 int OEM_sys_get_backlight_acl_control(int index, int *value)
 451 {
 452         int ret = -1;
 453         char path[MAX_NAME+1] = {0,};
 454
 455         if (index >= DISP_MAX) {
 456                 devmgr_log("supports %d display node", DISP_MAX);
 457                 return ret;
 458         }
 459
 460         snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 461         ret = sys_get_int(path, value);
 462         devmgr_log("path[%s]value[%d]", path, *value);
 463
 464         return ret;
 465 }
 466
 467 int OEM_sys_set_backlight_acl_control(int index, int value)
 468 {
 469         int ret = -1;
 470         char path[MAX_NAME+1] = {0,};
 471
 472         if (index >= DISP_MAX) {
 473                 devmgr_log("supports %d display node", DISP_MAX);
 474                 return ret;
 475         }
 476
 477         snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 478         devmgr_log("path[%s]value[%d]", path, value);
 479         ret = sys_set_int(path, value);
 480
 481         return ret;
 482 }
 483
 484 int OEM_sys_get_lcd_power(int index, int *value)
 485 {
 486         int ret = -1;
 487         char path[MAX_NAME+1] = {0,};
 488
 489         if (index >= DISP_MAX) {
 490                 devmgr_log("supports %d display node", DISP_MAX);
 491                 return ret;
 492         }
 493
 494         snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name);
 495         ret = sys_get_int(path, value);
 496         devmgr_log("path[%s]value[%d]", path, *value);
 497
 498         return ret;
 499 }
 500
 501 int OEM_sys_set_lcd_power(int index, int value)
 502 {
 503         int ret = -1;
 504         char path[MAX_NAME+1] = {0,};
 505
 506         if (index >= DISP_MAX) {
 507                 devmgr_log("supports %d display node", DISP_MAX);
 508                 return ret;
 509         }
 510
 511         snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name);
 512         devmgr_log("path[%s]value[%d]", path, value);
 513         ret = sys_set_int(path, value);
 514
 515         return ret;
 516 }
 517
 518 /* image_enhance */
 519 int OEM_sys_get_image_enhance_save(void *image_enhance)
 520 {
 521         int ret = -1;
 522         return ret;
 523 }
 524
 525 int OEM_sys_set_image_enhance_restore(void *image_enhance)
 526 {
 527         int ret = -1;
 528         return ret;
 529 }
 530
 531 int OEM_sys_get_image_enhance_mode(int *value)
 532 {
 533         int ret = -1;
 534         return ret;
 535 }
 536
 537 int OEM_sys_set_image_enhance_mode(int value)
 538 {
 539         int ret = -1;
 540         return ret;
 541 }
 542
 543 int OEM_sys_get_image_enhance_scenario(int *value)
 544 {
 545         int ret = -1;
 546         return ret;
 547 }
 548
 549 int OEM_sys_set_image_enhance_scenario(int value)
 550 {
 551         int ret = -1;
 552         return ret;
 553 }
 554
 555 int OEM_sys_get_image_enhance_tone(int *value)
 556 {
 557         int ret = -1;
 558         return ret;
 559 }
 560
 561 int OEM_sys_set_image_enhance_tone(int value)
 562 {
 563         int ret = -1;
 564         return ret;
 565 }
 566
 567 int OEM_sys_get_image_enhance_outdoor(int *value)
 568 {
 569         int ret = -1;
 570         return ret;
 571 }
 572
 573 int OEM_sys_set_image_enhance_outdoor(int value)
 574 {
 575         int ret = -1;
 576         return ret;
 577 }
 578
 579 int OEM_sys_get_image_enhance_tune(int *value)
 580 {
 581         int ret = -1;
 582         return ret;
 583 }
 584
 585 int OEM_sys_set_image_enhance_tune(int value)
 586 {
 587         int ret = -1;
 588         return ret;
 589 }
 590
 591 int OEM_sys_image_enhance_info(int *value)
 592 {
 593         return 0;
 594 }
 595
 596 int OEM_sys_set_display_frame_rate(int value)
 597 {
 598 /*
 599         if(value){
 600                 devmgr_log("Display frame rate limited to 40Hz");
 601                 return sys_set_str(DISPLAY_FRAME_RATE_PATH, "40");
 602         }else{
 603                 devmgr_log("Display frame rate change 40Hz and 60Hz");
 604                 return sys_set_str(DISPLAY_FRAME_RATE_PATH, "60");
 605         }
 606 */
 607         return -1;
 608 }
 609
 610 GENERATE_ACCESSORS_INT_RW(haptic_vibetones_level, HAPTIC_VIBETONES_LEVEL_PATH)
 611 GENERATE_ACCESSORS_INT_R(haptic_vibetones_level_max, HAPTIC_VIBETONES_LEVEL_MAX_PATH)
 612 GENERATE_ACCESSORS_INT_W(haptic_vibetones_enable, HAPTIC_VIBETONES_ENABLE_PATH)
 613 GENERATE_ACCESSORS_INT_W(haptic_vibetones_oneshot, HAPTIC_VIBETONES_ONESHOT_PATH)
 614
 615 GENERATE_ACCESSORS_INT_R(battery_capacity, BATTERY_CAPACITY_PATH)
 616 GENERATE_ACCESSORS_INT_R(battery_charge_full, BATTERY_CHARGE_FULL_PATH)
 617 GENERATE_ACCESSORS_INT_R(battery_charge_now, BATTERY_CHARGE_NOW_PATH)
 618 GENERATE_ACCESSORS_INT_R(battery_present, BATTERY_PRESENT_PATH)
 619
 620 int OEM_sys_get_battery_capacity_raw(int *value)
 621 {
 622         return 0;
 623 }
 624
 625 static char *health_text[] = {
 626         "Unknown", "Good", "Overheat", "Dead", "Over voltage",
 627         "Unspecified failure", "Cold",
 628 };
 629
 630 int OEM_sys_get_battery_health(int *value)
 631 {
 632         char buf[BUFF_MAX] = {0};
 633         int ret = 0;
 634         int i   = 0;
 635
 636         ret = sys_get_str(BATTERY_HEALTH_PATH, buf);
 637         if (ret != 0) {
 638                 return -1;
 639         }
 640
 641         for (i = 0; i < BATTERY_HEALTH_MAX; i++) {
 642                 if (strncmp(buf, health_text[i], strlen(health_text[i])) == 0) {
 643                         *value = i;
 644                         return 0;
 645                 }
 646         }
 647
 648         return -1;
 649 }
 650
 651 int OEM_sys_get_battery_polling_required(int *value)
 652 {
 653         *value = 1;
 654
 655         return 0;
 656 }
 657
 658 int OEM_sys_get_battery_support_insuspend_charging(int *value)
 659 {
 660         *value = 1;
 661
 662         return 0;
 663 }
 664
 665 static char uart_node_path[MAX_NAME];
 666 static char usb_node_path[MAX_NAME];
 667
 668 /* find uart/usb node path */
 669 static int OEM_sys_muic_node_path_info()
 670 {
 671         int err = -1;
 672
 673         err = sys_check_node(UART_PATH);
 674         if (!err)
 675                 sys_get_node(UART_PATH, uart_node_path);
 676         else {
 677                 err = sys_check_node(UART_PATH_TRATS);
 678                 if (err) {
 679                         devmgr_log("uart path node not found");
 680                         return -1;
 681                 }
 682                 sys_get_node(UART_PATH_TRATS, uart_node_path);
 683         }
 684
 685         err = sys_check_node(USB_PATH);
 686         if (!err)
 687                 sys_get_node(USB_PATH, usb_node_path);
 688         else {
 689                 err = sys_check_node(USB_PATH_TRATS);
 690                 if (err) {
 691                         devmgr_log("usb path node not found");
 692                         return -1;
 693                 }
 694                 sys_get_node(USB_PATH_TRATS, usb_node_path);
 695         }
 696         return 0;
 697 }
 698
 699 int OEM_sys_get_uart_path(int *value)
 700 {
 701         char buf[BUFF_MAX] = {0};
 702         int ret = 0;
 703
 704         ret = sys_get_str(uart_node_path, buf);
 705         if (ret != 0) {
 706                 return -1;
 707         }
 708
 709         if (strncmp(buf, "CP", 2) == 0) {
 710                 *value = PATH_CP;
 711                 return 0;
 712         } else if (strncmp(buf, "AP", 2) == 0) {
 713                 *value = PATH_AP;
 714                 return 0;
 715         }
 716
 717         return -1;
 718 }
 719
 720 int OEM_sys_set_uart_path(int value)
 721 {
 722         switch (value) {
 723         case PATH_CP:
 724                 return sys_set_str(uart_node_path, "CP");
 725         case PATH_AP:
 726                 return sys_set_str(uart_node_path, "AP");
 727         }
 728
 729         return -1;
 730 }
 731
 732
 733 int OEM_sys_get_usb_path(int *value)
 734 {
 735         char buf[BUFF_MAX] = {0};
 736         int ret = 0;
 737
 738         ret = sys_get_str(usb_node_path, buf);
 739         if (ret != 0) {
 740                 return -1;
 741         }
 742
 743         if (strncmp(buf, "PDA", 3) == 0) {
 744                 *value = PATH_AP;
 745                 return 0;
 746         } else if (strncmp(buf, "MODEM", 5) == 0) {
 747                 *value = PATH_CP;
 748                 return 0;
 749         }
 750
 751         return -1;
 752 }
 753
 754 int OEM_sys_set_usb_path(int value)
 755 {
 756         switch (value) {
 757         case PATH_CP:
 758                 return sys_set_str(usb_node_path, "MODEM");
 759         case PATH_AP:
 760                 return sys_set_str(usb_node_path, "PDA");
 761         }
 762
 763         return -1;
 764 }
 765
 766 GENERATE_ACCESSORS_INT_R(jack_charger_online, JACK_CHARGER_ONLINE_PATH)
 767 GENERATE_ACCESSORS_INT_R(jack_earjack_online, JACK_EARJACK_ONLINE_PATH)
 768 GENERATE_ACCESSORS_INT_R(jack_earkey_online, JACK_EARKEY_ONLINE_PATH)
 769 GENERATE_ACCESSORS_INT_R(jack_hdmi_online, JACK_HDMI_ONLINE_PATH)
 770 GENERATE_ACCESSORS_INT_R(jack_usb_online, JACK_USB_ONLINE_PATH)
 771 GENERATE_ACCESSORS_INT_R(jack_cradle_online, JACK_CRADLE_ONLINE_PATH)
 772 GENERATE_ACCESSORS_INT_R(jack_tvout_online, JACK_TVOUT_ONLINE_PATH)
 773
 774 int OEM_sys_get_jack_keyboard_online(int *value)
 775 {
 776         /* Currently, We don't provide SLP Based platform with keyboard I/F */
 777         int ret = -1;
 778         /*return sys_get_int(JACK_KEYBOARD_ONLINE_PATH, value);*/
 779         return ret;
 780 }
 781
 782 int OEM_sys_get_hdmi_support(int *value)
 783 {
 784         *value = 1;
 785
 786         return 0;
 787 }
 788
 789 GENERATE_ACCESSORS_INT_R(leds_torch_max_brightness, LEDS_TORCH_MAX_BRIGHTNESS_PATH)
 790 GENERATE_ACCESSORS_INT_RW(leds_torch_brightness, LEDS_TORCH_BRIGHTNESS_PATH)
 791
 792 int OEM_sys_set_power_state(int value)
 793 {
 794         switch (value) {
 795         case POWER_STATE_SUSPEND:
 796                 return sys_set_str(POWER_STATE_PATH, "mem");
 797         case POWER_STATE_PRE_SUSPEND:
 798                 return sys_set_str(POWER_STATE_PATH, "pre_suspend");
 799         case POWER_STATE_POST_RESUME:
 800                 return sys_set_str(POWER_STATE_PATH, "post_resume");
 801         }
 802
 803         return -1;
 804 }
 805
 806 GENERATE_ACCESSORS_INT_RW(power_wakeup_count, POWER_WAKEUP_COUNT_PATH)
 807
 808 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv1, MEMNOTIFY_THRESHOLD_LV1_PATH)
 809 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv2, MEMNOTIFY_THRESHOLD_LV2_PATH)
 810
 811 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_max_freq, CPUFREQ_CPUINFO_MAX_FREQ_PATH)
 812 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_min_freq, CPUFREQ_CPUINFO_MIN_FREQ_PATH)
 813 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_max_freq, CPUFREQ_SCALING_MAX_FREQ_PATH)
 814 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_min_freq, CPUFREQ_SCALING_MIN_FREQ_PATH)
 815
 816 #define GENERATE_ACCESSORS_INT_R_NO_CONVERT(_suffix, _item)     \
 817 int OEM_sys_get_##_suffix(int *value)                   \
 818 {                                               \
 819         return sys_get_int_wo_convert(_item, value);    \
 820 }
 821
 822 #define GENERATE_ACCESSORS_INT_W_NO_CONVERT(_suffix, _item)     \
 823 int OEM_sys_set_##_suffix(int value)                    \
 824 {                                               \
 825         return sys_set_int_wo_convert(_item, value);    \
 826 }
 827
 828 GENERATE_ACCESSORS_INT_R_NO_CONVERT(memnotify_victim_task, MEMNOTIFY_VICTIM_TASK_PATH)
 829 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_pnp, PROCESS_MONITOR_MP_PNP_PATH)
 830 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_vip, PROCESS_MONITOR_MP_VIP_PATH)
 831
 832 #define GENERATE_ACCESSORS_GET_NODE_PATH(_suffix, _item)        \
 833 int OEM_sys_get_##_suffix(char *node)                   \
 834 {                                               \
 835         return sys_get_node(_item, node);       \
 836 }
 837
 838 GENERATE_ACCESSORS_GET_NODE_PATH(touch_event, TOUCH_EVENT_NODE)
 839 GENERATE_ACCESSORS_GET_NODE_PATH(memnotify_node, MEMNOTIFY_NODE)
 840 GENERATE_ACCESSORS_GET_NODE_PATH(process_monitor_node, PROCESS_MONITOR_NODE)
 841
 842 #if 0
 843 int get_uart_path(char *value, int val) {
 844 {
 845         char *tmp_buff;
 846
 847         tmp_buff = sys_get_str(UART_PATH);
 848         if (tmp_buff == NULL)
 849                 return -1;
 850
 851         if (strncmp(tmp_buff, "AP", 2) == 0) {
 852                 *val = PATH_TO_PDA;
 853         } else if (strncmp(tmp_buff, "CP", 2) == 0) {
 854                 *val = PATH_TO_MODEM;
 855         } else {
 856                 free(tmp_buff);
 857                 return -1;
 858         }
 859         free(tmp_buff);
 860
 861         return 0;
 862 }
 863
 864 static int set_uart_path(char *value, int val)
 865 {
 866         int ret = -1;
 867
 868         if (val < PATH_TO_MODEM || val > PATH_TO_PDA) {
 869                 return -1;
 870         }
 871         ret =
 872             sys_set_str(UART_PATH, (val == PATH_TO_MODEM) ? "CP" : "AP");
 873         if(ret == 0) {
 874                 if (val == PATH_TO_MODEM) {
 875                         system("/usr/bin/save_blenv uartpath CP");
 876                 } else {
 877                         system("/usr/bin/save_blenv uartpath AP");
 878                 }
 879         }
 880         return ret;
 881 }
 882
 883 int get_usb_path(char *prop, int *val) {
 884 {
 885         char *tmp_buff = NULL;
 886         switch (prop) {
 887         case JACK_PROP_USB_ONLINE:
 888         case JACK_PROP_TA_ONLINE:
 889                 return generic_jack_interface_get(NULL, prop, val);
 890
 891         case JACK_PROP_HDMI_ONLINE:
 892                 tmp_buff =
 893                     sys_get_str("/sys/class/i2c-adapter/i2c-5/5-0072/status");
 894                 if (tmp_buff && (strstr(tmp_buff, "MHL connected:yes") != 0)) {
 895                         free(tmp_buff);
 896                         *val = 1;
 897                 } else {
 898                         if(tmp_buff)
 899                                 free(tmp_buff);
 900                         *val = 0;
 901                 }
 902                 return 0;
 903         case JACK_PROP_USB_PATH:
 904                 tmp_buff = sys_get_str(USB_PATH);
 905                 if (tmp_buff == NULL)
 906                         return -1;
 907                 if (strncmp(tmp_buff, usb_path_string[PATH_TO_MODEM], 2) == 0)
 908                         *val = PATH_TO_MODEM;
 909                 else
 910                         *val = PATH_TO_PDA;
 911
 912                 free(tmp_buff);
 913                 return 0;
 914         }
 915
 916         free(tmp_buff);
 917         return -1;
 918 }
 919
 920 int set_usb_path(char *prop, int val);
 921 {
 922         char *cur_path;
 923         int conn;
 924
 925         switch (prop) {
 926         case JACK_PROP_USB_PATH:
 927                 break;
 928         default:
 929                 return -1;
 930         }
 931         cur_path = sys_get_str(USB_PATH);
 932         if (cur_path == NULL)
 933                 return -1;
 934
 935         switch (val) {
 936         case PATH_TO_MODEM:
 937         case PATH_TO_PDA:
 938                 if (strncmp(cur_path, usb_path_string[val], 2) == 0) {
 939                         free(cur_path);
 940                         return 0;
 941                 }
 942                 free(cur_path);
 943                 if (generic_jack_interface_get
 944                     (NULL, JACK_USB_ONLINE_PATH, &conn) != 0) {
 945                         /*failed to get the connection status */
 946                         return -1;
 947                 }
 948                 if (sys_set_str(USB_PATH, (char *)usb_path_string[val]) !=
 949                     0)
 950                         return -1;
 951                 if (val == PATH_TO_MODEM) {
 952                         system("/usr/bin/save_blenv usbpath CP");
 953                 } else {
 954                         system("/usr/bin/save_blenv usbpath AP");
 955                 }
 956                 break;
 957
 958         default:
 959                 free(cur_path);
 960                 return -1;
 961         }
 962
 963         return 0;
 964 }
 965 #endif
 966
 967 static OEM_sys_devman_plugin_interface devman_plugin_interface_emul;
 968
 969 EXPORT_API const OEM_sys_devman_plugin_interface *OEM_sys_get_devman_plugin_interface()
 970 {
 971         devman_plugin_interface_emul.OEM_sys_get_display_count = &OEM_sys_get_display_count;
 972         devman_plugin_interface_emul.OEM_sys_get_backlight_min_brightness = &OEM_sys_get_backlight_min_brightness;
 973         devman_plugin_interface_emul.OEM_sys_get_backlight_max_brightness = &OEM_sys_get_backlight_max_brightness;
 974         devman_plugin_interface_emul.OEM_sys_get_backlight_brightness = &OEM_sys_get_backlight_brightness;
 975         devman_plugin_interface_emul.OEM_sys_set_backlight_brightness = &OEM_sys_set_backlight_brightness;
 976         devman_plugin_interface_emul.OEM_sys_set_backlight_dimming = &OEM_sys_set_backlight_dimming;
 977         devman_plugin_interface_emul.OEM_sys_get_backlight_acl_control = &OEM_sys_get_backlight_acl_control;
 978         devman_plugin_interface_emul.OEM_sys_set_backlight_acl_control = &OEM_sys_set_backlight_acl_control;
 979
 980         devman_plugin_interface_emul.OEM_sys_get_lcd_power = &OEM_sys_get_lcd_power;
 981         devman_plugin_interface_emul.OEM_sys_set_lcd_power = &OEM_sys_set_lcd_power;
 982
 983         devman_plugin_interface_emul.OEM_sys_get_image_enhance_mode = &OEM_sys_get_image_enhance_mode;
 984         devman_plugin_interface_emul.OEM_sys_set_image_enhance_mode = &OEM_sys_set_image_enhance_mode;
 985         devman_plugin_interface_emul.OEM_sys_get_image_enhance_scenario = &OEM_sys_get_image_enhance_scenario;
 986         devman_plugin_interface_emul.OEM_sys_set_image_enhance_scenario = &OEM_sys_set_image_enhance_scenario;
 987         devman_plugin_interface_emul.OEM_sys_get_image_enhance_tone = &OEM_sys_get_image_enhance_tone;
 988         devman_plugin_interface_emul.OEM_sys_set_image_enhance_tone = &OEM_sys_set_image_enhance_tone;
 989         devman_plugin_interface_emul.OEM_sys_get_image_enhance_outdoor = &OEM_sys_get_image_enhance_outdoor;
 990         devman_plugin_interface_emul.OEM_sys_set_image_enhance_outdoor = &OEM_sys_set_image_enhance_outdoor;
 991
 992         devman_plugin_interface_emul.OEM_sys_get_image_enhance_tune = &OEM_sys_get_image_enhance_tune;
 993         devman_plugin_interface_emul.OEM_sys_set_image_enhance_tune = &OEM_sys_set_image_enhance_tune;
 994
 995         devman_plugin_interface_emul.OEM_sys_image_enhance_info = &OEM_sys_image_enhance_info;
 996
 997         devman_plugin_interface_emul.OEM_sys_set_display_frame_rate = &OEM_sys_set_display_frame_rate;
 998
 999         devman_plugin_interface_emul.OEM_sys_get_uart_path = &OEM_sys_get_uart_path;
1000         devman_plugin_interface_emul.OEM_sys_set_uart_path = &OEM_sys_set_uart_path;
1001
1002         devman_plugin_interface_emul.OEM_sys_get_usb_path = &OEM_sys_get_usb_path;
1003         devman_plugin_interface_emul.OEM_sys_set_usb_path = &OEM_sys_set_usb_path;
1004
1005         devman_plugin_interface_emul.OEM_sys_get_battery_capacity = &OEM_sys_get_battery_capacity;
1006         devman_plugin_interface_emul.OEM_sys_get_battery_capacity_raw = &OEM_sys_get_battery_capacity_raw;
1007         devman_plugin_interface_emul.OEM_sys_get_battery_charge_full = &OEM_sys_get_battery_charge_full;
1008         devman_plugin_interface_emul.OEM_sys_get_battery_charge_now = &OEM_sys_get_battery_charge_now;
1009         devman_plugin_interface_emul.OEM_sys_get_battery_present = &OEM_sys_get_battery_present;
1010         devman_plugin_interface_emul.OEM_sys_get_battery_health = &OEM_sys_get_battery_health;
1011         devman_plugin_interface_emul.OEM_sys_get_battery_polling_required = &OEM_sys_get_battery_polling_required;
1012         devman_plugin_interface_emul.OEM_sys_get_battery_support_insuspend_charging = &OEM_sys_get_battery_support_insuspend_charging;
1013
1014         devman_plugin_interface_emul.OEM_sys_get_jack_charger_online = &OEM_sys_get_jack_charger_online;
1015         devman_plugin_interface_emul.OEM_sys_get_jack_earjack_online = &OEM_sys_get_jack_earjack_online;
1016         devman_plugin_interface_emul.OEM_sys_get_jack_earkey_online = &OEM_sys_get_jack_earkey_online;
1017         devman_plugin_interface_emul.OEM_sys_get_jack_hdmi_online = &OEM_sys_get_jack_hdmi_online;
1018         devman_plugin_interface_emul.OEM_sys_get_jack_usb_online = &OEM_sys_get_jack_usb_online;
1019         devman_plugin_interface_emul.OEM_sys_get_jack_cradle_online = &OEM_sys_get_jack_cradle_online;
1020         devman_plugin_interface_emul.OEM_sys_get_jack_tvout_online = &OEM_sys_get_jack_tvout_online;
1021         devman_plugin_interface_emul.OEM_sys_get_jack_keyboard_online = &OEM_sys_get_jack_keyboard_online;
1022
1023         devman_plugin_interface_emul.OEM_sys_get_hdmi_support = &OEM_sys_get_hdmi_support;
1024
1025         devman_plugin_interface_emul.OEM_sys_get_leds_torch_max_brightness = &OEM_sys_get_leds_torch_max_brightness;
1026         devman_plugin_interface_emul.OEM_sys_get_leds_torch_brightness = &OEM_sys_get_leds_torch_brightness;
1027         devman_plugin_interface_emul.OEM_sys_set_leds_torch_brightness = &OEM_sys_set_leds_torch_brightness;
1028
1029         devman_plugin_interface_emul.OEM_sys_set_power_state = &OEM_sys_set_power_state;
1030
1031         /* TODO: Should determine enum values of wakeup_count nodes */
1032         devman_plugin_interface_emul.OEM_sys_get_power_wakeup_count = &OEM_sys_get_power_wakeup_count;
1033         devman_plugin_interface_emul.OEM_sys_set_power_wakeup_count = &OEM_sys_set_power_wakeup_count;
1034
1035         devman_plugin_interface_emul.OEM_sys_get_backlight_brightness_by_lux = &OEM_sys_get_backlight_brightness_by_lux;
1036         OEM_sys_display_info(disp_info);
1037         OEM_sys_muic_node_path_info();
1038
1039         return &devman_plugin_interface_emul;
1040 }