src/device_manager_plugin_maru.c

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