src/device_manager_plugin_target.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://www.tizenopensource.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 #include <string.h>
  18 #include <sys/types.h>
  19 #include <stdio.h>
  20 #include <dirent.h>
  21 #include <devman_plugin_intf.h>
  22
  23 #include "devman_define_node_path.h"
  24
  25 #define EXPORT_API  __attribute__((visibility("default")))
  26
  27 #define BUFF_MAX        255
  28 #define MAX_NAME 255
  29
  30 #define GENERATE_ACCESSORS_CHAR_RW(_suffix, _item)      \
  31 char *OEM_sys_get_##_suffix()                   \
  32 {                                               \
  33         return sys_get_str(_item);      \
  34 }                                               \
  35                                                 \
  36 int OEM_sys_set_##_suffix(char *str)                    \
  37 {                                               \
  38         return sys_set_str(_item, value);       \
  39 }
  40
  41 #define GENERATE_ACCESSORS_CHAR_R(_suffix, _item)       \
  42 char *OEM_sys_get_##_suffix()                   \
  43 {                                               \
  44         return sys_get_str(_item);      \
  45 }
  46
  47 #define GENERATE_ACCESSORS_CHAR_W(_suffix, _item)       \
  48 int OEM_sys_set_##_suffix(char *str)                    \
  49 {                                               \
  50         return sys_set_str(_item, str);         \
  51 }
  52
  53 /* TODO: Add APIs has (char *) params */
  54
  55 #define GENERATE_ACCESSORS_INT_RW(_suffix, _item)       \
  56 int OEM_sys_get_##_suffix(int *value)                   \
  57 {                                               \
  58         return sys_get_int(_item, value);       \
  59 }                                               \
  60                                                 \
  61 int OEM_sys_set_##_suffix(int value)    \
  62 {                                               \
  63         return sys_set_int(_item, value);       \
  64 }
  65
  66 #define GENERATE_ACCESSORS_INT_R(_suffix, _item)        \
  67 int OEM_sys_get_##_suffix(int *value)                   \
  68 {                                               \
  69         return sys_get_int(_item, value);       \
  70 }
  71
  72 #define GENERATE_ACCESSORS_INT_W(_suffix, _item)        \
  73 int OEM_sys_set_##_suffix(int value)                    \
  74 {                                               \
  75         return sys_set_int(_item, value);       \
  76 }
  77
  78 /*
  79 GENERATE_ACCESSORS_INT_R(backlight_max_brightness, BACKLIGHT_MAX_BRIGHTNESS_PATH)
  80 GENERATE_ACCESSORS_INT_RW(backlight_brightness, BACKLIGHT_BRIGHTNESS_PATH)
  81 GENERATE_ACCESSORS_INT_RW(backlight_acl_control, LCD_ACL_CONTROL_PATH)
  82 GENERATE_ACCESSORS_INT_RW(lcd_power, LCD_POWER_PATH)
  83 */
  84 #if defined(DEVMGR_LOG)
  85 #define devmgr_log(fmt, args...) \
  86         do { \
  87                 printf("%s:"fmt"\n", __func__, ##args); \
  88         }while(0);
  89 #else
  90 #define devmgr_log(fmt, args...)
  91 #endif
  92
  93 enum display_type
  94 {
  95         DISP_MAIN = 0,
  96         DISP_SUB,
  97         DISP_MAX
  98 };
  99
 100 struct display_info
 101 {
 102         enum display_type etype; /* FIXME:!! Main LCD or Sub LCD node */
 103         char bl_name[MAX_NAME]; /* backlight name */
 104         char lcd_name[MAX_NAME]; /* lcd name */
 105 };
 106
 107 /* FIXME:!! change to global_ctx */
 108 int lcd_index;
 109 struct display_info disp_info[DISP_MAX];
 110
 111 static int OEM_sys_display_info(struct display_info *disp_info)
 112 {
 113         struct dirent *dent;
 114         DIR *dirp;
 115         int i, index;
 116         const char * bl_path = BACKLIGHT_PATH;
 117         const char * lcd_path = LCD_PATH;
 118
 119         /* Backlight */
 120         index = 0;
 121         dirp = opendir(bl_path);
 122         if (dirp) {
 123                 while(dent = readdir(dirp)) {
 124                         if (index >= DISP_MAX) {
 125                                 devmgr_log("supports %d display node", DISP_MAX);
 126                                 break;
 127                         }
 128
 129                         if (!strcmp(".", dent->d_name) || !strcmp("..", dent->d_name))
 130                                 continue;
 131                         else {
 132                                 strcpy(disp_info[index].bl_name, dent->d_name);
 133                                 index++;
 134                         }
 135                 }
 136                 closedir(dirp);
 137         }
 138
 139         for (i = 0; i < index; i++)
 140                 devmgr_log("bl_name[%s]", disp_info[i].bl_name);
 141
 142         /* LCD */
 143         index = 0;
 144         dirp = opendir(lcd_path);
 145         if (dirp) {
 146                 while(dent = readdir(dirp)) {
 147                         if (index >= DISP_MAX) {
 148                                 devmgr_log("supports %d display node", DISP_MAX);
 149                                 break;
 150                         }
 151
 152                         if (!strcmp(".", dent->d_name) || !strcmp("..", dent->d_name))
 153                                 continue;
 154                         else {
 155                                 strcpy(disp_info[index].lcd_name, dent->d_name);
 156                                 index++;
 157                         }
 158                 }
 159                 closedir(dirp);
 160         }
 161
 162         for (i = 0; i < index; i++)
 163                 devmgr_log("lcd_name[%s]", disp_info[i].lcd_name);
 164
 165         lcd_index = index;
 166 }
 167
 168 int OEM_sys_get_display_count(int *value)
 169 {
 170         int ret = -1;
 171
 172         /* TODO: We should implement to find out current number of display */
 173         *value = lcd_index;
 174         ret = 0;
 175         /* ********************* */
 176
 177         devmgr_log("value[%d]", *value);
 178
 179         return ret;
 180 }
 181
 182 int OEM_sys_get_backlight_max_brightness(int index, int *value)
 183 {
 184         int ret = -1;
 185         char path[MAX_NAME+1];
 186
 187         if (index >= DISP_MAX) {
 188                 devmgr_log("supports %d display node", DISP_MAX);
 189                 return ret;
 190         }
 191
 192         snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 193         ret = sys_get_int(path, value);
 194         devmgr_log("path[%s]value[%d]", path, *value);
 195
 196         return ret;
 197 }
 198
 199 int OEM_sys_get_backlight_brightness(int index, int *value)
 200 {
 201         int ret = -1;
 202         char path[MAX_NAME+1];
 203
 204         if (index >= DISP_MAX) {
 205                 devmgr_log("supports %d display node", DISP_MAX);
 206                 return ret;
 207         }
 208
 209         snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name);
 210         ret = sys_get_int(path, value);
 211         devmgr_log("path[%s]value[%d]", path, *value);
 212
 213         return ret;
 214 }
 215
 216 int OEM_sys_set_backlight_brightness(int index, int value)
 217 {
 218         int ret = -1;
 219         char path[MAX_NAME+1];
 220
 221         if (index >= DISP_MAX) {
 222                 devmgr_log("supports %d display node", DISP_MAX);
 223                 return ret;
 224         }
 225
 226         snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name);
 227         devmgr_log("path[%s]value[%d]", path, value);
 228         ret = sys_set_int(path, value);
 229
 230         return ret;
 231 }
 232
 233 int OEM_sys_get_backlight_acl_control(int index, int *value)
 234 {
 235         int ret = -1;
 236         char path[MAX_NAME+1];
 237
 238         if (index >= DISP_MAX) {
 239                 devmgr_log("supports %d display node", DISP_MAX);
 240                 return ret;
 241         }
 242
 243         snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 244         ret = sys_get_int(path, value);
 245         devmgr_log("path[%s]value[%d]", path, *value);
 246
 247         return ret;
 248 }
 249
 250 int OEM_sys_set_backlight_acl_control(int index, int value)
 251 {
 252         int ret = -1;
 253         char path[MAX_NAME+1];
 254
 255         if (index >= DISP_MAX) {
 256                 devmgr_log("supports %d display node", DISP_MAX);
 257                 return ret;
 258         }
 259
 260         snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 261         devmgr_log("path[%s]value[%d]", path, value);
 262         ret = sys_set_int(path, value);
 263
 264         return ret;
 265 }
 266
 267 int OEM_sys_get_lcd_power(int index, int *value)
 268 {
 269         int ret = -1;
 270         char path[MAX_NAME+1];
 271
 272         if (index >= DISP_MAX) {
 273                 devmgr_log("supports %d display node", DISP_MAX);
 274                 return ret;
 275         }
 276
 277         snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name);
 278         ret = sys_get_int(path, value);
 279         devmgr_log("path[%s]value[%d]", path, *value);
 280
 281         return ret;
 282 }
 283
 284 int OEM_sys_set_lcd_power(int index, int value)
 285 {
 286         int ret = -1;
 287         char path[MAX_NAME+1];
 288
 289         if (index >= DISP_MAX) {
 290                 devmgr_log("supports %d display node", DISP_MAX);
 291                 return ret;
 292         }
 293
 294         snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name);
 295         devmgr_log("path[%s]value[%d]", path, value);
 296         ret = sys_set_int(path, value);
 297
 298         return ret;
 299 }
 300
 301 /* image_enhance */
 302 int OEM_sys_get_image_enhance_save(void *image_enhance)
 303 {
 304         int ret = -1;
 305         return ret;
 306 }
 307
 308 int OEM_sys_set_image_enhance_restore(void *image_enhance)
 309 {
 310         int ret = -1;
 311         return ret;
 312 }
 313
 314 int OEM_sys_get_image_enhance_mode(int *value)
 315 {
 316         int ret = -1;
 317         return ret;
 318 }
 319
 320 int OEM_sys_set_image_enhance_mode(int value)
 321 {
 322         int ret = -1;
 323         return ret;
 324 }
 325
 326 int OEM_sys_get_image_enhance_scenario(int *value)
 327 {
 328         int ret = -1;
 329         return ret;
 330 }
 331
 332 int OEM_sys_set_image_enhance_scenario(int value)
 333 {
 334         int ret = -1;
 335         return ret;
 336 }
 337
 338 int OEM_sys_get_image_enhance_tone(int *value)
 339 {
 340         int ret = -1;
 341         return ret;
 342 }
 343
 344 int OEM_sys_set_image_enhance_tone(int value)
 345 {
 346         int ret = -1;
 347         return ret;
 348 }
 349
 350 int OEM_sys_get_image_enhance_outdoor(int *value)
 351 {
 352         int ret = -1;
 353         return ret;
 354 }
 355
 356 int OEM_sys_set_image_enhance_outdoor(int value)
 357 {
 358         int ret = -1;
 359         return ret;
 360 }
 361
 362 int OEM_sys_get_image_enhance_tune(int *value)
 363 {
 364         int ret = -1;
 365         return ret;
 366 }
 367
 368 int OEM_sys_set_image_enhance_tune(int value)
 369 {
 370         int ret = -1;
 371         return ret;
 372 }
 373
 374 GENERATE_ACCESSORS_INT_RW(haptic_vibetones_level, HAPTIC_VIBETONES_LEVEL_PATH)
 375 GENERATE_ACCESSORS_INT_R(haptic_vibetones_level_max, HAPTIC_VIBETONES_LEVEL_MAX_PATH)
 376 GENERATE_ACCESSORS_INT_W(haptic_vibetones_enable, HAPTIC_VIBETONES_ENABLE_PATH)
 377 GENERATE_ACCESSORS_INT_W(haptic_vibetones_oneshot, HAPTIC_VIBETONES_ONESHOT_PATH)
 378
 379 GENERATE_ACCESSORS_INT_R(battery_capacity, BATTERY_CAPACITY_PATH)
 380 GENERATE_ACCESSORS_INT_R(battery_charge_full, BATTERY_CHARGE_FULL_PATH)
 381 GENERATE_ACCESSORS_INT_R(battery_charge_now, BATTERY_CHARGE_NOW_PATH)
 382 GENERATE_ACCESSORS_INT_R(battery_present, BATTERY_PRESENT_PATH)
 383
 384 static char *health_text[] = {
 385         "Unknown", "Good", "Overheat", "Dead", "Over voltage",
 386         "Unspecified failure", "Cold",
 387 };
 388
 389 int OEM_sys_get_battery_health(int *value)
 390 {
 391         char *buf;
 392         int i = 0;
 393
 394         buf = sys_get_str(BATTERY_HEALTH_PATH);
 395         if (NULL == buf) {
 396                 return -1;
 397         }
 398
 399         for (i = 0; i < BATTERY_HEALTH_MAX; i++) {
 400                 if (strncmp(buf, health_text[i], strlen(health_text[i])) == 0) {
 401                         *value = i;
 402                         return 0;
 403                 }
 404         }
 405
 406         return -1;
 407 }
 408
 409 int OEM_sys_get_uart_path(int *value)
 410 {
 411         char *buf;
 412
 413         buf = sys_get_str(UART_PATH);
 414         if (NULL == buf) {
 415                 return -1;
 416         }
 417
 418         if (strncmp(buf, "CP", 2) == 0) {
 419                 *value = PATH_CP;
 420                 return 0;
 421         } else if (strncmp(buf, "AP", 2) == 0) {
 422                 *value = PATH_AP;
 423                 return 0;
 424         }
 425
 426         return -1;
 427 }
 428
 429 int OEM_sys_set_uart_path(int value)
 430 {
 431         switch (value) {
 432         case PATH_CP:
 433                 return sys_set_str(UART_PATH, "CP");
 434         case PATH_AP:
 435                 return sys_set_str(UART_PATH, "AP");
 436         }
 437
 438         return -1;
 439 }
 440
 441
 442 int OEM_sys_get_usb_path(int *value)
 443 {
 444         char *buf;
 445
 446         buf = sys_get_str(USB_PATH);
 447         if (NULL == buf) {
 448                 return -1;
 449         }
 450
 451         if (strncmp(buf, "AP", 2) == 0) {
 452                 *value = PATH_AP;
 453                 return 0;
 454         } else if (strncmp(buf, "CP", 2) == 0) {
 455                 *value = PATH_CP;
 456                 return 0;
 457         }
 458
 459         return -1;
 460 }
 461
 462 int OEM_sys_set_usb_path(int value)
 463 {
 464         switch (value) {
 465         case PATH_CP:
 466                 return sys_set_str(USB_PATH, "CP");
 467         case PATH_AP:
 468                 return sys_set_str(USB_PATH, "AP");
 469         }
 470
 471         return -1;
 472 }
 473
 474 GENERATE_ACCESSORS_INT_R(jack_charger_online, JACK_CHARGER_ONLINE_PATH)
 475 GENERATE_ACCESSORS_INT_R(jack_earjack_online, JACK_EARJACK_ONLINE_PATH)
 476 GENERATE_ACCESSORS_INT_R(jack_earkey_online, JACK_EARKEY_ONLINE_PATH)
 477 GENERATE_ACCESSORS_INT_R(jack_hdmi_online, JACK_HDMI_ONLINE_PATH)
 478 GENERATE_ACCESSORS_INT_R(jack_usb_online, JACK_USB_ONLINE_PATH)
 479 GENERATE_ACCESSORS_INT_R(jack_cradle_online, JACK_CRADLE_ONLINE_PATH)
 480 GENERATE_ACCESSORS_INT_R(jack_tvout_online, JACK_TVOUT_ONLINE_PATH)
 481
 482 int OEM_sys_get_jack_keyboard_online(int *value)
 483 {
 484         /* Currently, We don't provide SLP Based platform with keyboard I/F */
 485         int ret = -1;
 486         /*return sys_get_int(JACK_KEYBOARD_ONLINE_PATH, value);*/
 487         return ret;
 488 }
 489
 490 GENERATE_ACCESSORS_INT_R(leds_torch_max_brightness, LEDS_TORCH_MAX_BRIGHTNESS_PATH)
 491 GENERATE_ACCESSORS_INT_RW(leds_torch_brightness, LEDS_TORCH_BRIGHTNESS_PATH)
 492
 493 int OEM_sys_set_power_state(int value)
 494 {
 495         switch (value) {
 496         case POWER_STATE_SUSPEND:
 497                 return sys_set_str(POWER_STATE_PATH, "mem");
 498         }
 499
 500         return -1;
 501 }
 502
 503 GENERATE_ACCESSORS_INT_RW(power_wakeup_count, POWER_WAKEUP_COUNT_PATH)
 504
 505 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv1, MEMNOTIFY_THRESHOLD_LV1_PATH)
 506 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv2, MEMNOTIFY_THRESHOLD_LV2_PATH)
 507
 508 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_max_freq, CPUFREQ_CPUINFO_MAX_FREQ_PATH)
 509 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_min_freq, CPUFREQ_CPUINFO_MIN_FREQ_PATH)
 510 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_max_freq, CPUFREQ_SCALING_MAX_FREQ_PATH)
 511 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_min_freq, CPUFREQ_SCALING_MIN_FREQ_PATH)
 512
 513 #define GENERATE_ACCESSORS_INT_R_NO_CONVERT(_suffix, _item)     \
 514 int OEM_sys_get_##_suffix(int *value)                   \
 515 {                                               \
 516         return sys_get_int_wo_convert(_item, value);    \
 517 }
 518
 519 #define GENERATE_ACCESSORS_INT_W_NO_CONVERT(_suffix, _item)     \
 520 int OEM_sys_set_##_suffix(int value)                    \
 521 {                                               \
 522         return sys_set_int_wo_convert(_item, value);    \
 523 }
 524
 525 GENERATE_ACCESSORS_INT_R_NO_CONVERT(memnotify_victim_task, MEMNOTIFY_VICTIM_TASK_PATH)
 526 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_pnp, PROCESS_MONITOR_MP_PNP_PATH)
 527 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_vip, PROCESS_MONITOR_MP_VIP_PATH)
 528
 529 #define GENERATE_ACCESSORS_GET_NODE_PATH(_suffix, _item)        \
 530 int OEM_sys_get_##_suffix(char *node)                   \
 531 {                                               \
 532         return sys_get_node(_item, node);       \
 533 }
 534
 535 GENERATE_ACCESSORS_GET_NODE_PATH(touch_event, TOUCH_EVENT_NODE)
 536 GENERATE_ACCESSORS_GET_NODE_PATH(memnotify_node, MEMNOTIFY_NODE)
 537 GENERATE_ACCESSORS_GET_NODE_PATH(process_monitor_node, PROCESS_MONITOR_NODE)
 538
 539 #if 0
 540 int get_uart_path(char *value, int val) {
 541 {
 542         char *tmp_buff;
 543
 544         tmp_buff = sys_get_str(UART_PATH);
 545         if (tmp_buff == NULL)
 546                 return -1;
 547
 548         if (strncmp(tmp_buff, "AP", 2) == 0) {
 549                 *val = PATH_TO_PDA;
 550         } else if (strncmp(tmp_buff, "CP", 2) == 0) {
 551                 *val = PATH_TO_MODEM;
 552         } else {
 553                 free(tmp_buff);
 554                 return -1;
 555         }
 556         free(tmp_buff);
 557
 558         return 0;
 559 }
 560
 561 static int set_uart_path(char *value, int val)
 562 {
 563         int ret = -1;
 564
 565         if (val < PATH_TO_MODEM || val > PATH_TO_PDA) {
 566                 return -1;
 567         }
 568         ret =
 569             sys_set_str(UART_PATH, (val == PATH_TO_MODEM) ? "CP" : "AP");
 570         if(ret == 0) {
 571                 if (val == PATH_TO_MODEM) {
 572                         system("/usr/bin/save_blenv uartpath CP");
 573                 } else {
 574                         system("/usr/bin/save_blenv uartpath AP");
 575                 }
 576         }
 577         return ret;
 578 }
 579
 580 int get_usb_path(char *prop, int *val) {
 581 {
 582         char *tmp_buff = NULL;
 583         switch (prop) {
 584         case JACK_PROP_USB_ONLINE:
 585         case JACK_PROP_TA_ONLINE:
 586                 return generic_jack_interface_get(NULL, prop, val);
 587
 588         case JACK_PROP_HDMI_ONLINE:
 589                 tmp_buff =
 590                     sys_get_str("/sys/class/i2c-adapter/i2c-5/5-0072/status");
 591                 if (tmp_buff && (strstr(tmp_buff, "MHL connected:yes") != 0)) {
 592                         free(tmp_buff);
 593                         *val = 1;
 594                 } else {
 595                         if(tmp_buff)
 596                                 free(tmp_buff);
 597                         *val = 0;
 598                 }
 599                 return 0;
 600         case JACK_PROP_USB_PATH:
 601                 tmp_buff = sys_get_str(USB_PATH);
 602                 if (tmp_buff == NULL)
 603                         return -1;
 604                 if (strncmp(tmp_buff, usb_path_string[PATH_TO_MODEM], 2) == 0)
 605                         *val = PATH_TO_MODEM;
 606                 else
 607                         *val = PATH_TO_PDA;
 608
 609                 free(tmp_buff);
 610                 return 0;
 611         }
 612
 613         free(tmp_buff);
 614         return -1;
 615 }
 616
 617 int set_usb_path(char *prop, int val);
 618 {
 619         char *cur_path;
 620         int conn;
 621
 622         switch (prop) {
 623         case JACK_PROP_USB_PATH:
 624                 break;
 625         default:
 626                 return -1;
 627         }
 628         cur_path = sys_get_str(USB_PATH);
 629         if (cur_path == NULL)
 630                 return -1;
 631
 632         switch (val) {
 633         case PATH_TO_MODEM:
 634         case PATH_TO_PDA:
 635                 if (strncmp(cur_path, usb_path_string[val], 2) == 0) {
 636                         free(cur_path);
 637                         return 0;
 638                 }
 639                 free(cur_path);
 640                 if (generic_jack_interface_get
 641                     (NULL, JACK_USB_ONLINE_PATH, &conn) != 0) {
 642                         /*failed to get the connection status */
 643                         return -1;
 644                 }
 645                 if (sys_set_str(USB_PATH, (char *)usb_path_string[val]) !=
 646                     0)
 647                         return -1;
 648                 if (val == PATH_TO_MODEM) {
 649                         system("/usr/bin/save_blenv usbpath CP");
 650                 } else {
 651                         system("/usr/bin/save_blenv usbpath AP");
 652                 }
 653                 break;
 654
 655         default:
 656                 free(cur_path);
 657                 return -1;
 658         }
 659
 660         return 0;
 661 }
 662 #endif
 663
 664 static const OEM_sys_devman_plugin_interface devman_plugin_interface_target = {
 665         OEM_sys_get_display_count,
 666         OEM_sys_get_backlight_max_brightness,
 667         OEM_sys_get_backlight_brightness,
 668         OEM_sys_set_backlight_brightness,
 669         OEM_sys_get_backlight_acl_control,
 670         OEM_sys_set_backlight_acl_control,
 671
 672         OEM_sys_get_lcd_power,
 673         OEM_sys_set_lcd_power,
 674
 675         OEM_sys_get_image_enhance_mode,
 676         OEM_sys_set_image_enhance_mode,
 677         OEM_sys_get_image_enhance_scenario,
 678         OEM_sys_set_image_enhance_scenario,
 679         OEM_sys_get_image_enhance_tone,
 680         OEM_sys_set_image_enhance_tone,
 681         OEM_sys_get_image_enhance_outdoor,
 682         OEM_sys_set_image_enhance_outdoor,
 683
 684         OEM_sys_get_image_enhance_tune,
 685         OEM_sys_set_image_enhance_tune,
 686
 687         OEM_sys_get_uart_path,
 688         OEM_sys_set_uart_path,
 689
 690         OEM_sys_get_usb_path,
 691         OEM_sys_set_usb_path,
 692
 693         OEM_sys_get_haptic_vibetones_level_max,
 694         OEM_sys_get_haptic_vibetones_level,
 695         OEM_sys_set_haptic_vibetones_level,
 696         OEM_sys_set_haptic_vibetones_enable,
 697         OEM_sys_set_haptic_vibetones_oneshot,
 698
 699         OEM_sys_get_battery_capacity,
 700         OEM_sys_get_battery_charge_full,
 701         OEM_sys_get_battery_charge_now,
 702         OEM_sys_get_battery_present,
 703         OEM_sys_get_battery_health,
 704
 705         OEM_sys_get_jack_charger_online,
 706         OEM_sys_get_jack_earjack_online,
 707         OEM_sys_get_jack_earkey_online,
 708         OEM_sys_get_jack_hdmi_online,
 709         OEM_sys_get_jack_usb_online,
 710         OEM_sys_get_jack_cradle_online,
 711         OEM_sys_get_jack_tvout_online,
 712         OEM_sys_get_jack_keyboard_online,
 713
 714         OEM_sys_get_leds_torch_max_brightness,
 715         OEM_sys_get_leds_torch_brightness,
 716         OEM_sys_set_leds_torch_brightness,
 717
 718         OEM_sys_set_power_state,
 719
 720         /* TODO: Should determine enum values of wakeup_count nodes */
 721         OEM_sys_get_power_wakeup_count,
 722         OEM_sys_set_power_wakeup_count,
 723
 724         OEM_sys_get_memnotify_node,
 725         OEM_sys_get_memnotify_victim_task,
 726         OEM_sys_set_memnotify_threshold_lv1,
 727         OEM_sys_set_memnotify_threshold_lv2,
 728
 729         OEM_sys_get_process_monitor_node,
 730         OEM_sys_set_process_monitor_mp_pnp,
 731         OEM_sys_set_process_monitor_mp_vip,
 732
 733         OEM_sys_get_cpufreq_cpuinfo_max_freq,
 734         OEM_sys_get_cpufreq_cpuinfo_min_freq,
 735         OEM_sys_get_cpufreq_scaling_max_freq,
 736         OEM_sys_set_cpufreq_scaling_max_freq,
 737         OEM_sys_get_cpufreq_scaling_min_freq,
 738         OEM_sys_set_cpufreq_scaling_min_freq
 739 };
 740
 741 EXPORT_API const OEM_sys_devman_plugin_interface *OEM_sys_get_devman_plugin_interface()
 742 {
 743         OEM_sys_display_info(disp_info);
 744         return &devman_plugin_interface_target;
 745 }