src/device_manager_plugin_maru.c

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