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_uart_path(int *value)
 526 {
 527         char buf[BUFF_MAX] = {0};
 528         int ret = 0;
 529
 530         ret = sys_get_str(UART_PATH, buf);
 531         if (ret != 0) {
 532                 return -1;
 533         }
 534
 535         if (strncmp(buf, "CP", 2) == 0) {
 536                 *value = PATH_CP;
 537                 return 0;
 538         } else if (strncmp(buf, "AP", 2) == 0) {
 539                 *value = PATH_AP;
 540                 return 0;
 541         }
 542
 543         return -1;
 544 }
 545
 546 int OEM_sys_set_uart_path(int value)
 547 {
 548         switch (value) {
 549         case PATH_CP:
 550                 return sys_set_str(UART_PATH, "CP");
 551         case PATH_AP:
 552                 return sys_set_str(UART_PATH, "AP");
 553         }
 554
 555         return -1;
 556 }
 557
 558
 559 int OEM_sys_get_usb_path(int *value)
 560 {
 561         char buf[BUFF_MAX] = {0};
 562         int ret = 0;
 563
 564         ret = sys_get_str(USB_PATH, buf);
 565         if (ret != 0) {
 566                 return -1;
 567         }
 568
 569         if (strncmp(buf, "AP", 2) == 0) {
 570                 *value = PATH_AP;
 571                 return 0;
 572         } else if (strncmp(buf, "CP", 2) == 0) {
 573                 *value = PATH_CP;
 574                 return 0;
 575         }
 576
 577         return -1;
 578 }
 579
 580 int OEM_sys_set_usb_path(int value)
 581 {
 582         switch (value) {
 583         case PATH_CP:
 584                 return sys_set_str(USB_PATH, "CP");
 585         case PATH_AP:
 586                 return sys_set_str(USB_PATH, "AP");
 587         }
 588
 589         return -1;
 590 }
 591
 592 int OEM_sys_get_battery_capacity_raw(int *value)
 593 {
 594         return 0;
 595 }
 596
 597 int OEM_sys_image_enhance_info(int *value)
 598 {
 599         return 0;
 600 }
 601
 602 GENERATE_ACCESSORS_INT_R(jack_charger_online, JACK_CHARGER_ONLINE_PATH)
 603 GENERATE_ACCESSORS_INT_R(jack_earjack_online, JACK_EARJACK_ONLINE_PATH)
 604 GENERATE_ACCESSORS_INT_R(jack_earkey_online, JACK_EARKEY_ONLINE_PATH)
 605 GENERATE_ACCESSORS_INT_R(jack_hdmi_online, JACK_HDMI_ONLINE_PATH)
 606 GENERATE_ACCESSORS_INT_R(jack_usb_online, JACK_USB_ONLINE_PATH)
 607 GENERATE_ACCESSORS_INT_R(jack_cradle_online, JACK_CRADLE_ONLINE_PATH)
 608 GENERATE_ACCESSORS_INT_R(jack_tvout_online, JACK_TVOUT_ONLINE_PATH)
 609
 610 int OEM_sys_get_jack_keyboard_online(int *value)
 611 {
 612         /* Currently, We don't provide SLP Based platform with keyboard I/F */
 613         int ret = -1;
 614         /*return sys_get_int(JACK_KEYBOARD_ONLINE_PATH, value);*/
 615         return ret;
 616 }
 617
 618 GENERATE_ACCESSORS_INT_R(leds_torch_max_brightness, LEDS_TORCH_MAX_BRIGHTNESS_PATH)
 619 GENERATE_ACCESSORS_INT_RW(leds_torch_brightness, LEDS_TORCH_BRIGHTNESS_PATH)
 620
 621 int OEM_sys_set_power_state(int value)
 622 {
 623         switch (value) {
 624         case POWER_STATE_SUSPEND:
 625                 return sys_set_str(POWER_STATE_PATH, "mem");
 626         }
 627
 628         return -1;
 629 }
 630
 631 GENERATE_ACCESSORS_INT_RW(power_wakeup_count, POWER_WAKEUP_COUNT_PATH)
 632
 633 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv1, MEMNOTIFY_THRESHOLD_LV1_PATH)
 634 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv2, MEMNOTIFY_THRESHOLD_LV2_PATH)
 635
 636 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_max_freq, CPUFREQ_CPUINFO_MAX_FREQ_PATH)
 637 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_min_freq, CPUFREQ_CPUINFO_MIN_FREQ_PATH)
 638 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_max_freq, CPUFREQ_SCALING_MAX_FREQ_PATH)
 639 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_min_freq, CPUFREQ_SCALING_MIN_FREQ_PATH)
 640
 641 #define GENERATE_ACCESSORS_INT_R_NO_CONVERT(_suffix, _item)     \
 642 int OEM_sys_get_##_suffix(int *value)                   \
 643 {                                               \
 644         return sys_get_int_wo_convert(_item, value);    \
 645 }
 646
 647 #define GENERATE_ACCESSORS_INT_W_NO_CONVERT(_suffix, _item)     \
 648 int OEM_sys_set_##_suffix(int value)                    \
 649 {                                               \
 650         return sys_set_int_wo_convert(_item, value);    \
 651 }
 652
 653 GENERATE_ACCESSORS_INT_R_NO_CONVERT(memnotify_victim_task, MEMNOTIFY_VICTIM_TASK_PATH)
 654 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_pnp, PROCESS_MONITOR_MP_PNP_PATH)
 655 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_vip, PROCESS_MONITOR_MP_VIP_PATH)
 656
 657 #define GENERATE_ACCESSORS_GET_NODE_PATH(_suffix, _item)        \
 658 int OEM_sys_get_##_suffix(char *node)                   \
 659 {                                               \
 660         return sys_get_node(_item, node);       \
 661 }
 662
 663 GENERATE_ACCESSORS_GET_NODE_PATH(touch_event, TOUCH_EVENT_NODE)
 664 GENERATE_ACCESSORS_GET_NODE_PATH(memnotify_node, MEMNOTIFY_NODE)
 665 GENERATE_ACCESSORS_GET_NODE_PATH(process_monitor_node, PROCESS_MONITOR_NODE)
 666
 667 #if 0
 668 int get_uart_path(char *value, int val) {
 669 {
 670         char *tmp_buff;
 671
 672         tmp_buff = sys_get_str(UART_PATH);
 673         if (tmp_buff == NULL)
 674                 return -1;
 675
 676         if (strncmp(tmp_buff, "AP", 2) == 0) {
 677                 *val = PATH_TO_PDA;
 678         } else if (strncmp(tmp_buff, "CP", 2) == 0) {
 679                 *val = PATH_TO_MODEM;
 680         } else {
 681                 free(tmp_buff);
 682                 return -1;
 683         }
 684         free(tmp_buff);
 685
 686         return 0;
 687 }
 688
 689 static int set_uart_path(char *value, int val)
 690 {
 691         int ret = -1;
 692
 693         if (val < PATH_TO_MODEM || val > PATH_TO_PDA) {
 694                 return -1;
 695         }
 696         ret =
 697             sys_set_str(UART_PATH, (val == PATH_TO_MODEM) ? "CP" : "AP");
 698         if(ret == 0) {
 699                 if (val == PATH_TO_MODEM) {
 700                         system("/usr/bin/save_blenv uartpath CP");
 701                 } else {
 702                         system("/usr/bin/save_blenv uartpath AP");
 703                 }
 704         }
 705         return ret;
 706 }
 707
 708 int get_usb_path(char *prop, int *val) {
 709 {
 710         char *tmp_buff = NULL;
 711         switch (prop) {
 712         case JACK_PROP_USB_ONLINE:
 713         case JACK_PROP_TA_ONLINE:
 714                 return generic_jack_interface_get(NULL, prop, val);
 715
 716         case JACK_PROP_HDMI_ONLINE:
 717                 tmp_buff =
 718                     sys_get_str("/sys/class/i2c-adapter/i2c-5/5-0072/status");
 719                 if (tmp_buff && (strstr(tmp_buff, "MHL connected:yes") != 0)) {
 720                         free(tmp_buff);
 721                         *val = 1;
 722                 } else {
 723                         if(tmp_buff)
 724                                 free(tmp_buff);
 725                         *val = 0;
 726                 }
 727                 return 0;
 728         case JACK_PROP_USB_PATH:
 729                 tmp_buff = sys_get_str(USB_PATH);
 730                 if (tmp_buff == NULL)
 731                         return -1;
 732                 if (strncmp(tmp_buff, usb_path_string[PATH_TO_MODEM], 2) == 0)
 733                         *val = PATH_TO_MODEM;
 734                 else
 735                         *val = PATH_TO_PDA;
 736
 737                 free(tmp_buff);
 738                 return 0;
 739         }
 740
 741         free(tmp_buff);
 742         return -1;
 743 }
 744
 745 int set_usb_path(char *prop, int val);
 746 {
 747         char *cur_path;
 748         int conn;
 749
 750         switch (prop) {
 751         case JACK_PROP_USB_PATH:
 752                 break;
 753         default:
 754                 return -1;
 755         }
 756         cur_path = sys_get_str(USB_PATH);
 757         if (cur_path == NULL)
 758                 return -1;
 759
 760         switch (val) {
 761         case PATH_TO_MODEM:
 762         case PATH_TO_PDA:
 763                 if (strncmp(cur_path, usb_path_string[val], 2) == 0) {
 764                         free(cur_path);
 765                         return 0;
 766                 }
 767                 free(cur_path);
 768                 if (generic_jack_interface_get
 769                     (NULL, JACK_USB_ONLINE_PATH, &conn) != 0) {
 770                         /*failed to get the connection status */
 771                         return -1;
 772                 }
 773                 if (sys_set_str(USB_PATH, (char *)usb_path_string[val]) !=
 774                     0)
 775                         return -1;
 776                 if (val == PATH_TO_MODEM) {
 777                         system("/usr/bin/save_blenv usbpath CP");
 778                 } else {
 779                         system("/usr/bin/save_blenv usbpath AP");
 780                 }
 781                 break;
 782
 783         default:
 784                 free(cur_path);
 785                 return -1;
 786         }
 787
 788         return 0;
 789 }
 790 #endif
 791
 792 static OEM_sys_devman_plugin_interface devman_plugin_interface_emul;
 793
 794 #if 0
 795 static const OEM_sys_devman_plugin_interface devman_plugin_interface_emul = {
 796         OEM_sys_get_display_count,
 797         OEM_sys_get_backlight_min_brightness,
 798         OEM_sys_get_backlight_max_brightness,
 799         OEM_sys_get_backlight_brightness,
 800         OEM_sys_set_backlight_brightness,
 801         OEM_sys_set_backlight_dimming
 802         OEM_sys_get_backlight_acl_control,
 803         OEM_sys_set_backlight_acl_control,
 804
 805         OEM_sys_get_lcd_power,
 806         OEM_sys_set_lcd_power,
 807
 808         OEM_sys_get_image_enhance_mode,
 809         OEM_sys_set_image_enhance_mode,
 810         OEM_sys_get_image_enhance_scenario,
 811         OEM_sys_set_image_enhance_scenario,
 812         OEM_sys_get_image_enhance_tone,
 813         OEM_sys_set_image_enhance_tone,
 814         OEM_sys_get_image_enhance_outdoor,
 815         OEM_sys_set_image_enhance_outdoor,
 816
 817         OEM_sys_get_image_enhance_tune,
 818         OEM_sys_set_image_enhance_tune,
 819         OEM_sys_image_enhance_info,
 820
 821         OEM_sys_set_display_frame_rate,
 822
 823         OEM_sys_get_uart_path,
 824         OEM_sys_set_uart_path,
 825
 826         OEM_sys_get_usb_path,
 827         OEM_sys_set_usb_path,
 828
 829         OEM_sys_get_haptic_vibetones_level_max,
 830         OEM_sys_get_haptic_vibetones_level,
 831         OEM_sys_set_haptic_vibetones_level,
 832         OEM_sys_set_haptic_vibetones_enable,
 833         OEM_sys_set_haptic_vibetones_oneshot,
 834
 835         OEM_sys_get_battery_capacity,
 836         OEM_sys_get_battery_capacity_raw,
 837         OEM_sys_get_battery_charge_full,
 838         OEM_sys_get_battery_charge_now,
 839         OEM_sys_get_battery_present,
 840         OEM_sys_get_battery_health,
 841
 842         OEM_sys_get_jack_charger_online,
 843         OEM_sys_get_jack_earjack_online,
 844         OEM_sys_get_jack_earkey_online,
 845         OEM_sys_get_jack_hdmi_online,
 846         OEM_sys_get_jack_usb_online,
 847         OEM_sys_get_jack_cradle_online,
 848         OEM_sys_get_jack_tvout_online,
 849         OEM_sys_get_jack_keyboard_online,
 850
 851         OEM_sys_get_leds_torch_max_brightness,
 852         OEM_sys_get_leds_torch_brightness,
 853         OEM_sys_set_leds_torch_brightness,
 854
 855         OEM_sys_set_power_state,
 856
 857         /* TODO: Should determine enum values of wakeup_count nodes */
 858         OEM_sys_get_power_wakeup_count,
 859         OEM_sys_set_power_wakeup_count,
 860
 861         OEM_sys_get_memnotify_node,
 862         OEM_sys_get_memnotify_victim_task,
 863         OEM_sys_set_memnotify_threshold_lv1,
 864         OEM_sys_set_memnotify_threshold_lv2,
 865
 866         OEM_sys_get_process_monitor_node,
 867         OEM_sys_set_process_monitor_mp_pnp,
 868         OEM_sys_set_process_monitor_mp_vip,
 869
 870         OEM_sys_get_cpufreq_cpuinfo_max_freq,
 871         OEM_sys_get_cpufreq_cpuinfo_min_freq,
 872         OEM_sys_get_cpufreq_scaling_max_freq,
 873         OEM_sys_set_cpufreq_scaling_max_freq,
 874         OEM_sys_get_cpufreq_scaling_min_freq,
 875         OEM_sys_set_cpufreq_scaling_min_freq
 876 };
 877 #endif
 878
 879 EXPORT_API const OEM_sys_devman_plugin_interface *OEM_sys_get_devman_plugin_interface()
 880 {
 881         devman_plugin_interface_emul.OEM_sys_get_display_count = &OEM_sys_get_display_count;
 882         devman_plugin_interface_emul.OEM_sys_get_backlight_min_brightness = &OEM_sys_get_backlight_min_brightness;
 883         devman_plugin_interface_emul.OEM_sys_get_backlight_max_brightness = &OEM_sys_get_backlight_max_brightness;
 884         devman_plugin_interface_emul.OEM_sys_get_backlight_brightness = &OEM_sys_get_backlight_brightness;
 885         devman_plugin_interface_emul.OEM_sys_set_backlight_brightness = &OEM_sys_set_backlight_brightness;
 886         devman_plugin_interface_emul.OEM_sys_set_backlight_dimming = &OEM_sys_set_backlight_dimming;
 887         devman_plugin_interface_emul.OEM_sys_get_backlight_acl_control = &OEM_sys_get_backlight_acl_control;
 888         devman_plugin_interface_emul.OEM_sys_set_backlight_acl_control = &OEM_sys_set_backlight_acl_control;
 889
 890         devman_plugin_interface_emul.OEM_sys_get_lcd_power = &OEM_sys_get_lcd_power;
 891         devman_plugin_interface_emul.OEM_sys_set_lcd_power = &OEM_sys_set_lcd_power;
 892
 893         devman_plugin_interface_emul.OEM_sys_get_image_enhance_mode = &OEM_sys_get_image_enhance_mode;
 894         devman_plugin_interface_emul.OEM_sys_set_image_enhance_mode = &OEM_sys_set_image_enhance_mode;
 895         devman_plugin_interface_emul.OEM_sys_get_image_enhance_scenario = &OEM_sys_get_image_enhance_scenario;
 896         devman_plugin_interface_emul.OEM_sys_set_image_enhance_scenario = &OEM_sys_set_image_enhance_scenario;
 897         devman_plugin_interface_emul.OEM_sys_get_image_enhance_tone = &OEM_sys_get_image_enhance_tone;
 898         devman_plugin_interface_emul.OEM_sys_set_image_enhance_tone = &OEM_sys_set_image_enhance_tone;
 899         devman_plugin_interface_emul.OEM_sys_get_image_enhance_outdoor = &OEM_sys_get_image_enhance_outdoor;
 900         devman_plugin_interface_emul.OEM_sys_set_image_enhance_outdoor = &OEM_sys_set_image_enhance_outdoor;
 901
 902         devman_plugin_interface_emul.OEM_sys_get_image_enhance_tune = &OEM_sys_get_image_enhance_tune;
 903         devman_plugin_interface_emul.OEM_sys_set_image_enhance_tune = &OEM_sys_set_image_enhance_tune;
 904
 905         devman_plugin_interface_emul.OEM_sys_image_enhance_info = &OEM_sys_image_enhance_info;
 906
 907         devman_plugin_interface_emul.OEM_sys_set_display_frame_rate = &OEM_sys_set_display_frame_rate;
 908
 909         devman_plugin_interface_emul.OEM_sys_get_uart_path = &OEM_sys_get_uart_path;
 910         devman_plugin_interface_emul.OEM_sys_set_uart_path = &OEM_sys_set_uart_path;
 911
 912         devman_plugin_interface_emul.OEM_sys_get_usb_path = &OEM_sys_get_usb_path;
 913         devman_plugin_interface_emul.OEM_sys_set_usb_path = &OEM_sys_set_usb_path;
 914
 915         devman_plugin_interface_emul.OEM_sys_get_haptic_vibetones_level_max = &OEM_sys_get_haptic_vibetones_level_max;
 916         devman_plugin_interface_emul.OEM_sys_get_haptic_vibetones_level = &OEM_sys_get_haptic_vibetones_level;
 917         devman_plugin_interface_emul.OEM_sys_set_haptic_vibetones_level = &OEM_sys_set_haptic_vibetones_level;
 918         devman_plugin_interface_emul.OEM_sys_set_haptic_vibetones_enable = &OEM_sys_set_haptic_vibetones_enable;
 919         devman_plugin_interface_emul.OEM_sys_set_haptic_vibetones_oneshot = &OEM_sys_set_haptic_vibetones_oneshot;
 920
 921         devman_plugin_interface_emul.OEM_sys_get_battery_capacity = &OEM_sys_get_battery_capacity;
 922         devman_plugin_interface_emul.OEM_sys_get_battery_capacity_raw = &OEM_sys_get_battery_capacity_raw;
 923         devman_plugin_interface_emul.OEM_sys_get_battery_charge_full = &OEM_sys_get_battery_charge_full;
 924         devman_plugin_interface_emul.OEM_sys_get_battery_charge_now = &OEM_sys_get_battery_charge_now;
 925         devman_plugin_interface_emul.OEM_sys_get_battery_present = &OEM_sys_get_battery_present;
 926         devman_plugin_interface_emul.OEM_sys_get_battery_health = &OEM_sys_get_battery_health;
 927         devman_plugin_interface_emul.OEM_sys_get_battery_polling_required = &OEM_sys_get_battery_polling_required;
 928
 929         devman_plugin_interface_emul.OEM_sys_get_jack_charger_online = &OEM_sys_get_jack_charger_online;
 930         devman_plugin_interface_emul.OEM_sys_get_jack_earjack_online = &OEM_sys_get_jack_earjack_online;
 931         devman_plugin_interface_emul.OEM_sys_get_jack_earkey_online = &OEM_sys_get_jack_earkey_online;
 932         devman_plugin_interface_emul.OEM_sys_get_jack_hdmi_online = &OEM_sys_get_jack_hdmi_online;
 933         devman_plugin_interface_emul.OEM_sys_get_jack_usb_online = &OEM_sys_get_jack_usb_online;
 934         devman_plugin_interface_emul.OEM_sys_get_jack_cradle_online = &OEM_sys_get_jack_cradle_online;
 935         devman_plugin_interface_emul.OEM_sys_get_jack_tvout_online = &OEM_sys_get_jack_tvout_online;
 936         devman_plugin_interface_emul.OEM_sys_get_jack_keyboard_online = &OEM_sys_get_jack_keyboard_online;
 937
 938         devman_plugin_interface_emul.OEM_sys_get_leds_torch_max_brightness = &OEM_sys_get_leds_torch_max_brightness;
 939         devman_plugin_interface_emul.OEM_sys_get_leds_torch_brightness = &OEM_sys_get_leds_torch_brightness;
 940         devman_plugin_interface_emul.OEM_sys_set_leds_torch_brightness = &OEM_sys_set_leds_torch_brightness;
 941
 942         devman_plugin_interface_emul.OEM_sys_set_power_state = &OEM_sys_set_power_state;
 943
 944         /* TODO: Should determine enum values of wakeup_count nodes */
 945         devman_plugin_interface_emul.OEM_sys_get_power_wakeup_count = &OEM_sys_get_power_wakeup_count;
 946         devman_plugin_interface_emul.OEM_sys_set_power_wakeup_count = &OEM_sys_set_power_wakeup_count;
 947
 948         devman_plugin_interface_emul.OEM_sys_get_memnotify_node = &OEM_sys_get_memnotify_node;
 949         devman_plugin_interface_emul.OEM_sys_get_memnotify_victim_task = &OEM_sys_get_memnotify_victim_task;
 950         devman_plugin_interface_emul.OEM_sys_set_memnotify_threshold_lv1 = &OEM_sys_set_memnotify_threshold_lv1;
 951         devman_plugin_interface_emul.OEM_sys_set_memnotify_threshold_lv2 = &OEM_sys_set_memnotify_threshold_lv2;
 952
 953         devman_plugin_interface_emul.OEM_sys_get_process_monitor_node = &OEM_sys_get_process_monitor_node;
 954         devman_plugin_interface_emul.OEM_sys_set_process_monitor_mp_pnp = &OEM_sys_set_process_monitor_mp_pnp;
 955         devman_plugin_interface_emul.OEM_sys_set_process_monitor_mp_vip = &OEM_sys_set_process_monitor_mp_vip;
 956
 957         devman_plugin_interface_emul.OEM_sys_get_cpufreq_cpuinfo_max_freq = &OEM_sys_get_cpufreq_cpuinfo_max_freq;
 958         devman_plugin_interface_emul.OEM_sys_get_cpufreq_cpuinfo_min_freq = &OEM_sys_get_cpufreq_cpuinfo_min_freq;
 959         devman_plugin_interface_emul.OEM_sys_get_cpufreq_scaling_max_freq = &OEM_sys_get_cpufreq_scaling_max_freq;
 960         devman_plugin_interface_emul.OEM_sys_set_cpufreq_scaling_max_freq = &OEM_sys_set_cpufreq_scaling_max_freq;
 961         devman_plugin_interface_emul.OEM_sys_get_cpufreq_scaling_min_freq = &OEM_sys_get_cpufreq_scaling_min_freq;
 962         devman_plugin_interface_emul.OEM_sys_set_cpufreq_scaling_min_freq = &OEM_sys_set_cpufreq_scaling_min_freq;
 963
 964         OEM_sys_display_info(disp_info);
 965         return &devman_plugin_interface_emul;
 966 }