src/test_devices.c

   1 /*
   2  * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17
  18 #include <string.h>
  19 #include <sys/types.h>
  20 #include <stdio.h>
  21 #include <dirent.h>
  22 #include <errno.h>
  23 /* #include <devman_plugin_intf.h> */
  24 #include <device-oal.h>
  25
  26 #include "devman_define_node_path.h"
  27 #include "device_manager_siop.h"
  28 #include "device_manager_io.h"
  29
  30 #define EXPORT_API  __attribute__((visibility("default")))
  31
  32 #define BUFF_MAX        255
  33 #define MAX_NAME 255
  34
  35
  36
  37 /* TODO: Add APIs has (char *) params */
  38
  39 #define GENERATE_ACCESSORS_INT_RW(_suffix, _item)       \
  40 int OEM_sys_get_##_suffix(int *value)                   \
  41 {                                               \
  42         return sys_get_int(_item, value);       \
  43 }                                               \
  44                                                 \
  45 int OEM_sys_set_##_suffix(int value)    \
  46 {                                               \
  47         return sys_set_int(_item, value);       \
  48 }
  49
  50 #define GENERATE_ACCESSORS_INT_R(_suffix, _item)        \
  51 int OEM_sys_get_##_suffix(int *value)                   \
  52 {                                               \
  53         return sys_get_int(_item, value);       \
  54 }
  55
  56 #define GENERATE_ACCESSORS_INT_W(_suffix, _item)        \
  57 int OEM_sys_set_##_suffix(int value)                    \
  58 {                                               \
  59         return sys_set_int(_item, value);       \
  60 }
  61
  62 /*
  63 GENERATE_ACCESSORS_INT_R(backlight_max_brightness, BACKLIGHT_MAX_BRIGHTNESS_PATH)
  64 GENERATE_ACCESSORS_INT_RW(backlight_brightness, BACKLIGHT_BRIGHTNESS_PATH)
  65 GENERATE_ACCESSORS_INT_RW(backlight_acl_control, LCD_ACL_CONTROL_PATH)
  66 GENERATE_ACCESSORS_INT_RW(lcd_power, LCD_POWER_PATH)
  67 */
  68 #define DEVMGR_LOG
  69 #if defined(DEVMGR_LOG)
  70 #define LOG_TAG     "DEVICE_PLUGIN"
  71 #include <dlog/dlog.h>
  72 #define devmgr_log(fmt, args...)        SLOGD(fmt, ##args)
  73 #else
  74 #define devmgr_log(fmt, args...)
  75 #endif
  76
  77 enum display_type {
  78         DISP_MAIN = 0,
  79         DISP_SUB,
  80         DISP_MAX
  81 };
  82
  83 enum lux_status {
  84         decrement,
  85         increment,
  86 };
  87
  88 enum CABC_MODE {
  89         CABC_OFF = 0,
  90         CABC_USER_INTERFACE,
  91         CABC_STILL_PICTURE,
  92         CABC_MOVING_IMAGE,
  93         CABC_MAX,
  94 };
  95
  96 struct display_info {
  97         enum display_type etype; /* FIXME:!! Main LCD or Sub LCD node */
  98         char bl_name[MAX_NAME+1]; /* backlight name */
  99         char lcd_name[MAX_NAME+1]; /* lcd name */
 100 };
 101
 102 #define MAX_CANDELA_CRITERION   300
 103 #define PWR_SAVING_CANDELA_CRITERION    20
 104
 105 /* FIXME:!! change to global_ctx */
 106 int lcd_index;
 107 struct display_info disp_info[DISP_MAX];
 108
 109 int current_brightness = -1;
 110 extern int current_level;
 111 extern int current_mode;
 112 extern device_siop_table current_table;
 113
 114 int OEM_sys_get_hardkey_backlight(int *value)
 115 {
 116         int ret = -1;
 117         char path[MAX_NAME+1];
 118
 119         snprintf(path, MAX_NAME, TOUCHKEY_LED_PATH);
 120         ret = sys_get_int(path, value);
 121         devmgr_log("path[%s]value[%d]", path, *value);
 122
 123         return ret;
 124 }
 125
 126 int OEM_sys_set_hardkey_backlight(int value)
 127 {
 128         int ret = -1;
 129         char path[MAX_NAME+1];
 130
 131         snprintf(path, MAX_NAME, TOUCHKEY_LED_PATH);
 132         ret = sys_set_int(path, value);
 133         devmgr_log("path[%s]value[%d]", path, value);
 134
 135         return ret;
 136 }
 137
 138 int OEM_sys_get_hall_status(int *value)
 139 {
 140         char path[MAX_NAME+1];
 141         int ret = -1;
 142
 143         snprintf(path, MAX_NAME, COVER_STATUS_PATH);
 144         ret = sys_get_int(path, value);
 145
 146         if (ret != 0)
 147                 devmgr_log("fail to get cover_status\n");
 148         else
 149                 devmgr_log("path[%s]value[%d]", path, *value);
 150
 151         return ret;
 152 }
 153
 154 int OEM_sys_get_whitemagic_mode(int index, int *value)
 155 {
 156         int ret = -1;
 157         char path[MAX_NAME+1];
 158
 159         if (index >= DISP_MAX) {
 160                 devmgr_log("supports %d display node", DISP_MAX);
 161                 return ret;
 162         }
 163
 164         snprintf(path, MAX_NAME, LCD_WM_CONTROL_PATH, disp_info[index].lcd_name);
 165         ret = sys_get_int(path, value);
 166         devmgr_log("path[%s]value[%d]", path, *value);
 167
 168         return ret;
 169 }
 170
 171 int OEM_sys_set_whitemagic_mode(int index, int value)
 172 {
 173         int ret = -1;
 174         char path[MAX_NAME+1];
 175
 176         if (index >= DISP_MAX) {
 177                 devmgr_log("supports %d display node", DISP_MAX);
 178                 return ret;
 179         }
 180
 181         snprintf(path, MAX_NAME, LCD_WM_CONTROL_PATH, disp_info[index].lcd_name);
 182         ret = sys_set_int(path, value);
 183
 184         return ret;
 185 }
 186
 187 int OEM_sys_get_brightness(unsigned int lux)
 188 {
 189         const unsigned int Nr_Table[] = {
 190                 0, 5, 5, 6, 6, 7, 8, 8, 9, 9,
 191                 10, 11, 12, 13, 13, 14, 15, 16, 18, 19,
 192                 20, 22, 23, 25, 29, 32, 36, 39, 43, 46,
 193                 50, 54, 57, 61, 64, 68, 71, 75, 79, 82,
 194                 86, 89, 93, 96, 100, 119, 138, 157, 176, 195,
 195                 214, 233, 252, 271, 290, 310, 329, 348, 367, 386,
 196                 405, 424, 443, 462, 481, 500, 571, 643, 714, 786,
 197                 857, 929, 1000, 1100, 1200, 1300, 1400, 1500, 1667, 1833,
 198                 2000, 2250, 2500, 2750, 3000, 3333, 3667, 4000, 4083, 4167,
 199                 4250, 4333, 4417, 4500, 4583, 4667, 4750, 4833, 4917, 5000,
 200         };
 201         int brightness;
 202
 203         for (brightness = 0; (lux > Nr_Table[brightness]) && (brightness < 99); brightness++);
 204
 205         return brightness;
 206 }
 207
 208 int OEM_sys_get_backlight_brightness_by_lux(unsigned int lux, int *value)
 209 {
 210         const unsigned int Max_Table[] = {
 211                 15, 15, 15, 15, 16, 17, 18, 20, 21, 23,
 212                 26, 28, 31, 33, 35, 38, 40, 44, 48, 51,
 213                 55, 60, 65, 70, 81, 92, 103, 114, 125, 136,
 214                 147, 158, 169, 180, 190, 201, 212, 223, 234, 245,
 215                 256, 267, 278, 289, 300, 357, 414, 471, 529, 586,
 216                 643, 700, 757, 814, 871, 929, 986, 1043, 1100, 1157,
 217                 1214, 1271, 1329, 1386, 1443, 1500, 1678, 1855, 2033, 2211,
 218                 2389, 2566, 2744, 2977, 3209, 3442, 3674, 3907, 4274, 4642,
 219                 5009, 5215, 5422, 5628, 5834, 6057, 6279, 6502, 6585, 6669,
 220                 6752, 6835, 6919, 7002, 7085, 7169, 7252, 7335, 7419, 7502,
 221         };
 222         const unsigned int Min_Table[] = {
 223                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 224                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 225                 1, 1, 1, 1, 1, 1, 1, 2, 2, 3,
 226                 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
 227                 8, 9, 9, 10, 10, 12, 14, 16, 17, 19,
 228                 21, 23, 25, 27, 29, 30, 32, 34, 36, 38,
 229                 40, 42, 43, 45, 47, 49, 60, 70, 81, 91,
 230                 102, 112, 123, 140, 157, 174, 191, 208, 240, 271,
 231                 303, 356, 409, 461, 514, 592, 670, 748, 769, 790,
 232                 811, 832, 853, 874, 895, 916, 937, 958, 979, 1000,
 233         };
 234         static int brightness = -1;
 235
 236         if (brightness == -1) {
 237                 brightness = OEM_sys_get_brightness(lux);
 238                 devmgr_log("lux: %d, brightness: %d.\n", lux, brightness+1);
 239         } else
 240                 if ((lux > Max_Table[brightness]) || (lux < Min_Table[brightness])) {
 241                         brightness = OEM_sys_get_brightness(lux);
 242                         devmgr_log("lux: %d, brightness: %d.\n", lux, brightness+1);
 243                 }
 244
 245         *value = brightness+1;
 246
 247         return 0;
 248 }
 249
 250 static int OEM_sys_display_info(struct display_info *disp_info)
 251 {
 252         struct dirent *dent;
 253         DIR *dirp;
 254         int i, index;
 255         const char * bl_path = BACKLIGHT_PATH;
 256         const char * lcd_path = LCD_PATH;
 257
 258         /* Backlight */
 259         index = 0;
 260         dirp = opendir(bl_path);
 261         if (dirp) {
 262                 while (dent = readdir(dirp)) {
 263                         if (index >= DISP_MAX) {
 264                                 devmgr_log("supports %d display node", DISP_MAX);
 265                                 break;
 266                         }
 267
 268                         if (!strcmp(".", dent->d_name) || !strcmp("..", dent->d_name))
 269                                 continue;
 270                         else {
 271                                 strcpy(disp_info[index].bl_name, dent->d_name);
 272                                 index++;
 273                         }
 274                 }
 275                 closedir(dirp);
 276         }
 277
 278         /*for (i = 0; i < index; i++)*/
 279                 /*devmgr_log("bl_name[%s]", disp_info[i].bl_name);*/
 280
 281         /* LCD */
 282         index = 0;
 283         dirp = opendir(lcd_path);
 284         if (dirp) {
 285                 while (dent = readdir(dirp)) {
 286                         if (index >= DISP_MAX) {
 287                                 devmgr_log("supports %d display node", DISP_MAX);
 288                                 break;
 289                         }
 290
 291                         if (!strcmp(".", dent->d_name) || !strcmp("..", dent->d_name))
 292                                 continue;
 293                         else {
 294                                 strcpy(disp_info[index].lcd_name, dent->d_name);
 295                                 index++;
 296                         }
 297                 }
 298                 closedir(dirp);
 299         }
 300
 301         /*for (i = 0; i < index; i++)*/
 302                 /*devmgr_log("lcd_name[%s]", disp_info[i].lcd_name);*/
 303
 304         lcd_index = index;
 305
 306         return 0;
 307 }
 308
 309 int OEM_sys_get_display_count(int *value)
 310 {
 311         int ret = -1;
 312
 313         /* TODO: We should implement to find out current number of display */
 314         *value = lcd_index;
 315         ret = 0;
 316         /* ********************* */
 317
 318         /*devmgr_log("value[%d]", *value);*/
 319
 320         return ret;
 321 }
 322
 323 int OEM_sys_get_backlight_max_brightness(int index, int *value)
 324 {
 325         int ret = -1;
 326         char path[MAX_NAME+1];
 327
 328         if (index >= DISP_MAX) {
 329                 devmgr_log("supports %d display node", DISP_MAX);
 330                 return ret;
 331         }
 332
 333         snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 334         ret = sys_get_int(path, value);
 335         devmgr_log("path[%s]value[%d]", path, *value);
 336
 337         return ret;
 338 }
 339
 340 int OEM_sys_get_backlight_min_brightness(int index, int *value)
 341 {
 342         int ret = -1;
 343         char path[MAX_NAME+1];
 344
 345         if (index >= DISP_MAX) {
 346                 devmgr_log("supports %d display node", DISP_MAX);
 347                 return ret;
 348         }
 349
 350         snprintf(path, MAX_NAME, BACKLIGHT_MIN_BRIGHTNESS_PATH, disp_info[index].bl_name);
 351         ret = sys_get_int(path, value);
 352         devmgr_log("path[%s]value[%d]", path, *value);
 353
 354         return ret;
 355 }
 356
 357
 358 int OEM_sys_get_backlight_brightness(int index, int *value, int power_saving)
 359 {
 360         int ret = -1;
 361         char path[MAX_NAME+1];
 362         int max_brightness;
 363         int pwr_saving_offset;
 364
 365         if (index >= DISP_MAX) {
 366                 devmgr_log("supports %d display node", DISP_MAX);
 367                 return ret;
 368         }
 369
 370         snprintf(path, MAX_NAME, MDNIE_BACKLIGHT_BRIGHTNESS_PATH);
 371         if (!sys_check_node((char *)path)) {
 372                 ret = sys_get_int(path, value);
 373                 printf("[%s:%d]:path is %s\n", __FUNCTION__, __LINE__, path);
 374         } else {
 375                 snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name);
 376                 ret = sys_get_int(path, value);
 377                 printf("[%s:%d]:path is %s\n", __FUNCTION__, __LINE__, path);
 378         }
 379
 380         /*devmgr_log("path[%s]value[%d]power_saving[%d]", path, *value, power_saving);*/
 381
 382         if (power_saving) {
 383                 snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 384                 printf("[%s:%d]:path is %s\n", __FUNCTION__, __LINE__, path);
 385                 ret = sys_get_int(path, &max_brightness);
 386                 if (ret) {
 387                         devmgr_log("Can't read max_brightness node[%s]", path);
 388                         return ret;
 389                 }
 390                 pwr_saving_offset = (PWR_SAVING_CANDELA_CRITERION * max_brightness / MAX_CANDELA_CRITERION) + 0.5;
 391
 392                 if (*value > max_brightness - pwr_saving_offset)
 393                         *value = max_brightness;
 394                 else
 395                         *value = *value + pwr_saving_offset;
 396
 397                 devmgr_log("power_saving result[%d]", *value);
 398         }
 399
 400         return ret;
 401 }
 402
 403 int OEM_sys_set_backlight_dimming(int index, int value)
 404 {
 405         int ret = -1;
 406         char path[MAX_NAME+1];
 407
 408         devmgr_log("index is %d, value is %d",  index, value);
 409         if (index >= DISP_MAX) {
 410                 devmgr_log("supports %d display node", DISP_MAX);
 411                 return ret;
 412         }
 413
 414         snprintf(path, MAX_NAME, BACKLIGHT_DIMMING_PATH, disp_info[index].bl_name);
 415         devmgr_log("path[%s]value[%d]", path, value);
 416         ret = sys_set_int(path, value);
 417
 418         return ret;
 419 }
 420
 421 int set_backlight_brightness(int index, int value)
 422 {
 423         int ret = -1;
 424         char path[MAX_NAME+1];
 425
 426         if (index >= DISP_MAX) {
 427                 devmgr_log("supports %d display node", DISP_MAX);
 428                 return ret;
 429         }
 430
 431         snprintf(path, MAX_NAME, MDNIE_BACKLIGHT_BRIGHTNESS_PATH);
 432         if (!sys_check_node((char *)path)) {
 433                 ret = sys_set_int(path, value);
 434         } else {
 435                 snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name);
 436                 ret = sys_set_int(path, value);
 437         }
 438
 439         return ret;
 440 }
 441
 442 int OEM_sys_set_backlight_brightness(int index, int value, int power_saving)
 443 {
 444         int ret = -1;
 445         char path[MAX_NAME+1];
 446         int max_brightness;
 447         int pwr_saving_offset;
 448
 449         if (index >= DISP_MAX) {
 450                 devmgr_log("supports %d display node", DISP_MAX);
 451                 return ret;
 452         }
 453
 454         devmgr_log("path[%s]value[%d]power_saving[%d]", path, value, power_saving);
 455
 456         if (power_saving) {
 457                 snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name);
 458                 ret = sys_get_int(path, &max_brightness);
 459                 if (ret) {
 460                         devmgr_log("Can't read max_brightness node[%s]", path);
 461                         return ret;
 462                 }
 463                 pwr_saving_offset = (int)((PWR_SAVING_CANDELA_CRITERION * max_brightness / MAX_CANDELA_CRITERION) + 0.5);
 464
 465                 if (value < pwr_saving_offset)
 466                         value = 0;
 467                 else
 468                         value = value - pwr_saving_offset;
 469
 470                 devmgr_log("power_saving result[%d]", value);
 471         }
 472
 473         current_brightness = value;
 474
 475         if ((current_level != -1) && (current_mode != -1)) {
 476                 if (value > current_table.backlight)
 477                         value = current_table.backlight;
 478         }
 479
 480         ret = set_backlight_brightness(index, value);
 481         if (ret) {
 482                 devmgr_log("Can't set backlight brightness");
 483                 return ret;
 484         }
 485
 486         return ret;
 487 }
 488
 489 int OEM_sys_get_backlight_acl_control(int index, int *value)
 490 {
 491         int ret = -1;
 492         char path[MAX_NAME+1];
 493
 494         if (index >= DISP_MAX) {
 495                 devmgr_log("supports %d display node", DISP_MAX);
 496                 return ret;
 497         }
 498
 499         snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 500         ret = sys_get_int(path, value);
 501         devmgr_log("path[%s]value[%d]", path, *value);
 502
 503         return ret;
 504 }
 505
 506 int OEM_sys_set_backlight_acl_control(int index, int value)
 507 {
 508         int ret = -1;
 509         char path[MAX_NAME+1];
 510
 511         if (index >= DISP_MAX) {
 512                 devmgr_log("supports %d display node", DISP_MAX);
 513                 return ret;
 514         }
 515
 516         snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 517         devmgr_log("path[%s]value[%d]", path, value);
 518         ret = sys_set_int(path, value);
 519
 520         return ret;
 521 }
 522
 523 int OEM_sys_get_lcd_power(int index, int *value)
 524 {
 525         int ret = -1;
 526         char path[MAX_NAME+1];
 527
 528         if (index >= DISP_MAX) {
 529                 devmgr_log("supports %d display node", DISP_MAX);
 530                 return ret;
 531         }
 532
 533         snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name);
 534         ret = sys_get_int(path, value);
 535         /*devmgr_log("path[%s]value[%d]", path, *value);*/
 536
 537         return ret;
 538 }
 539
 540 int OEM_sys_set_lcd_power(int index, int value)
 541 {
 542         int ret = -1;
 543         char path[MAX_NAME+1];
 544
 545         if (index >= DISP_MAX) {
 546                 devmgr_log("supports %d display node", DISP_MAX);
 547                 return ret;
 548         }
 549
 550         snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name);
 551         devmgr_log("path[%s]value[%d]", path, value);
 552         ret = sys_set_int(path, value);
 553
 554         return ret;
 555 }
 556
 557 /* image_enhance */
 558 /* mode - dynamic, standard, natural, movie */
 559 enum image_enhance_mode {
 560         MODE_DYNAMIC = 0,
 561         MODE_STANDARD,
 562         MODE_NATURAL,
 563         MODE_MOVIE,
 564 };
 565
 566 /* scenario - ui, gallery, video, vtcall, camera, browser, negative, bypass */
 567 enum image_enhance_scenario {
 568         SCENARIO_UI = 0,
 569         SCENARIO_GALLERY,
 570         SCENARIO_VIDEO,
 571         SCENARIO_VTCALL,
 572         SCENARIO_CAMERA,
 573         SCENARIO_BROWSER,
 574         SCENARIO_NEGATIVE,
 575         SCENARIO_BYPASS,
 576 };
 577
 578 /* tone - normal, warm, cold */
 579 enum image_enhance_tone {
 580         TONE_NORMAL = 0,
 581         TONE_WARM,
 582         TONE_COLD,
 583 };
 584
 585 /* tone browser - tone1, tone2, tone3 */
 586 enum image_enhance_tone_br {
 587         TONE_1 = 0,
 588         TONE_2,
 589         TONE_3,
 590 };
 591
 592 /* outdoor - off, on */
 593 enum image_enhance_outdoor {
 594         OUTDOOR_OFF = 0,
 595         OUTDOOR_ON,
 596 };
 597
 598 /* index - mode, scenario, tone, outdoor, tune */
 599 enum image_enhance_index {
 600         INDEX_MODE,
 601         INDEX_SCENARIO,
 602         INDEX_TONE,
 603         INDEX_OUTDOOR,
 604         INDEX_TUNE,
 605         INDEX_COLOR_BLIND,
 606         INDEX_CABC,
 607         INDEX_MAX,
 608 };
 609
 610 const char *image_enhance_str[INDEX_MAX] = {
 611         "mode",
 612         "scenario",
 613         "tone",
 614         "outdoor",
 615         "tune",
 616         "accessibility",
 617         "cabc",
 618 };
 619
 620 struct image_enhance_info {
 621         enum image_enhance_mode mode;
 622         enum image_enhance_scenario scenario;
 623         enum image_enhance_tone tone;
 624         enum image_enhance_outdoor outdoor;
 625 };
 626
 627 int OEM_sys_get_lcd_cabc(int index, int *value)
 628 {
 629         char lcd_cabc_path[MAX_NAME+1];
 630         char mdnie_cabc_path[MAX_NAME+1];
 631         int ret = -1;
 632
 633         if (index >= DISP_MAX) {
 634                 devmgr_log("supports %d display node", DISP_MAX);
 635                 return ret;
 636         }
 637
 638         snprintf(lcd_cabc_path, MAX_NAME, LCD_CABC_CONTROL_PATH, disp_info[index].lcd_name);
 639         snprintf(mdnie_cabc_path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_CABC]);
 640
 641         if (!sys_check_node((char *)mdnie_cabc_path)) {
 642                 ret = sys_get_int((char *)mdnie_cabc_path, value);
 643                 devmgr_log("path[%s]value[%d]", mdnie_cabc_path, *value);
 644         } else if (!sys_check_node((char *)lcd_cabc_path)) {
 645                 ret = sys_get_int((char *)lcd_cabc_path, value);
 646                 devmgr_log("path[%s]value[%d]", lcd_cabc_path, *value);
 647         } else {
 648                 devmgr_log("fail to get cabc mode.");
 649                 ret = -1;
 650         }
 651
 652         return ret;
 653 }
 654
 655 int OEM_sys_set_lcd_cabc(int index, int value)
 656 {
 657         char lcd_cabc_path[MAX_NAME+1];
 658         char mdnie_cabc_path[MAX_NAME+1];
 659         int ret = -1;
 660
 661         if (index >= DISP_MAX) {
 662                 devmgr_log("supports %d display node", DISP_MAX);
 663                 return ret;
 664         }
 665
 666         snprintf(lcd_cabc_path, MAX_NAME, LCD_CABC_CONTROL_PATH, disp_info[index].lcd_name);
 667         snprintf(mdnie_cabc_path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_CABC]);
 668
 669         if (!sys_check_node((char *)mdnie_cabc_path)) {
 670                 ret = sys_set_int((char *)mdnie_cabc_path, value);
 671                 devmgr_log("path[%s]value[%d]", mdnie_cabc_path, value);
 672         } else if (!sys_check_node((char *)lcd_cabc_path)) {
 673                 ret = sys_set_int((char *)lcd_cabc_path, value);
 674                 devmgr_log("path[%s]value[%d]", lcd_cabc_path, value);
 675         } else {
 676                 devmgr_log("fail to set cabc mode.");
 677                 ret = -1;
 678         }
 679
 680         return ret;
 681 }
 682
 683 int OEM_sys_get_auto_screen_tone(int index, int *value)
 684 {
 685         char acl_path[MAX_NAME+1];
 686         char lcd_cabc_path[MAX_NAME+1];
 687         char mdnie_cabc_path[MAX_NAME+1];
 688         int ret = -1;
 689
 690         if (index >= DISP_MAX) {
 691                 devmgr_log("supports %d display node", DISP_MAX);
 692                 return ret;
 693         }
 694
 695         snprintf(acl_path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 696         snprintf(lcd_cabc_path, MAX_NAME, LCD_CABC_CONTROL_PATH, disp_info[index].lcd_name);
 697         snprintf(mdnie_cabc_path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_CABC]);
 698
 699         if (!sys_check_node((char *)acl_path)) {
 700                         ret = sys_get_int((char *)acl_path, value);
 701                         devmgr_log("path[%s]value[%d]", acl_path, *value);
 702         } else {
 703                 if (!sys_check_node((char *)mdnie_cabc_path)) {
 704                         ret = sys_get_int((char *)mdnie_cabc_path, value);
 705                         devmgr_log("path[%s]value[%d]", mdnie_cabc_path, *value);
 706                 } else if (!sys_check_node((char *)lcd_cabc_path)) {
 707                         ret = sys_get_int((char *)lcd_cabc_path, value);
 708                         devmgr_log("path[%s]value[%d]", lcd_cabc_path, *value);
 709                 } else {
 710                         devmgr_log("fail to get auto screen tone.");
 711                         ret = -1;
 712                 }
 713         }
 714         return ret;
 715 }
 716
 717 int OEM_sys_set_auto_screen_tone(int index, int value)
 718 {
 719         char acl_path[MAX_NAME+1];
 720         char lcd_cabc_path[MAX_NAME+1];
 721         char mdnie_cabc_path[MAX_NAME+1];
 722         int ret = -1;
 723
 724         if (index >= DISP_MAX) {
 725                 devmgr_log("supports %d display node", DISP_MAX);
 726                 return ret;
 727         }
 728
 729         snprintf(acl_path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name);
 730         snprintf(lcd_cabc_path, MAX_NAME, LCD_CABC_CONTROL_PATH, disp_info[index].lcd_name);
 731         snprintf(mdnie_cabc_path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_CABC]);
 732
 733         if (!sys_check_node((char *)acl_path)) {
 734                         ret = sys_set_int((char *)acl_path, value);
 735                         devmgr_log("path[%s]value[%d]", acl_path, value);
 736         } else {
 737                 if (!sys_check_node((char *)mdnie_cabc_path)) {
 738                         if (value > CABC_OFF)
 739                                 value = CABC_USER_INTERFACE;
 740                         ret = sys_set_int((char *)mdnie_cabc_path, value);
 741                         devmgr_log("path[%s]value[%d]", mdnie_cabc_path, value);
 742                 } else if (!sys_check_node((char *)lcd_cabc_path)) {
 743                         if (value > CABC_OFF)
 744                                 value = CABC_OFF;
 745                         ret = sys_set_int((char *)lcd_cabc_path, value);
 746                         devmgr_log("path[%s]value[%d]", lcd_cabc_path, value);
 747                 } else {
 748                         devmgr_log("fail to set auto screen tone.");
 749                         ret = -1;
 750                 }
 751         }
 752         return ret;
 753 }
 754
 755 int OEM_sys_get_image_enhance_color_blind(int *value)
 756 {
 757         char path[MAX_NAME+1];
 758         int ret = -1;
 759
 760         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_COLOR_BLIND]);
 761         ret = sys_get_int(path, value);
 762         devmgr_log("path[%s] value[%d]", path, *value);
 763
 764         return ret;
 765 }
 766
 767 int OEM_sys_set_image_enhance_color_blind(void *value)
 768 {
 769         struct color_blind_info *color_blind_value = (struct color_blind_info *)value;
 770         char value_string[MAX_NAME+1];
 771         char path[MAX_NAME+1];
 772         int ret = -1;
 773
 774         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_COLOR_BLIND]);
 775         sprintf(value_string, "%d 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",\
 776                 color_blind_value->mode,\
 777                 color_blind_value->RrCr, color_blind_value->RgCg, color_blind_value->RbCb,\
 778                 color_blind_value->GrMr, color_blind_value->GgMg, color_blind_value->GbMb,\
 779                 color_blind_value->BrYr, color_blind_value->BgYg, color_blind_value->BbYb);
 780
 781         ret = sys_set_str(path, value_string);
 782
 783         devmgr_log("path[%s] value[%s]", path, value_string);
 784
 785         return ret;
 786 }
 787
 788 int OEM_sys_get_image_enhance_save(void *image_enhance)
 789 {
 790         int ret = -1;
 791         char path[MAX_NAME+1];
 792         struct image_enhance_info *image_enhance_save = (struct image_enhance_info *)image_enhance;
 793
 794         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]);
 795         ret = sys_get_int(path, &image_enhance_save->mode);
 796         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]);
 797         ret = sys_get_int(path, &image_enhance_save->scenario);
 798         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]);
 799         ret = sys_get_int(path, &image_enhance_save->tone);
 800         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]);
 801         ret = sys_get_int(path, &image_enhance_save->outdoor);
 802         devmgr_log("path[%s]mode[%d]scenario[%d]tone[%d]outdoor[%d]", path, image_enhance_save->mode,
 803                 image_enhance_save->scenario, image_enhance_save->tone, image_enhance_save->outdoor);
 804
 805         return ret;
 806 }
 807
 808 int OEM_sys_set_image_enhance_restore(void *image_enhance)
 809 {
 810         int ret = -1;
 811         char path[MAX_NAME+1];
 812         struct image_enhance_info *image_enhance_restore = (struct image_enhance_info *)image_enhance;
 813
 814         devmgr_log("path[%s]mode[%d]scenario[%d]tone[%d]outdoor[%d]", path, image_enhance_restore->mode,
 815                 image_enhance_restore->scenario, image_enhance_restore->tone, image_enhance_restore->outdoor);
 816         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]);
 817         ret = sys_set_int(path, image_enhance_restore->mode);
 818         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]);
 819         ret = sys_set_int(path, image_enhance_restore->scenario);
 820         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]);
 821         ret = sys_set_int(path, image_enhance_restore->tone);
 822         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]);
 823         ret = sys_set_int(path, image_enhance_restore->outdoor);
 824
 825         return ret;
 826 }
 827
 828 int OEM_sys_get_image_enhance_mode(int *value)
 829 {
 830         int ret = -1;
 831         char path[MAX_NAME+1];
 832
 833         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]);
 834         ret = sys_get_int(path, value);
 835         devmgr_log("path[%s]value[%d]", path, *value);
 836
 837         return ret;
 838 }
 839
 840 int OEM_sys_set_image_enhance_mode(int value)
 841 {
 842         int ret = -1;
 843         char path[MAX_NAME+1];
 844
 845         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]);
 846         devmgr_log("path[%s]value[%d]", path, value);
 847         ret = sys_set_int(path, value);
 848
 849         return ret;
 850 }
 851
 852 int OEM_sys_get_image_enhance_scenario(int *value)
 853 {
 854         int ret = -1;
 855         char path[MAX_NAME+1];
 856
 857         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]);
 858         ret = sys_get_int(path, value);
 859         devmgr_log("path[%s]value[%d]", path, *value);
 860
 861         return ret;
 862 }
 863
 864 int OEM_sys_set_image_enhance_scenario(int value)
 865 {
 866         int ret = -1;
 867         int screen_tone = 0;
 868         char path[MAX_NAME+1];
 869
 870         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]);
 871         devmgr_log("path[%s]value[%d]", path, value);
 872         ret = sys_set_int(path, value);
 873
 874         return ret;
 875 }
 876
 877 int OEM_sys_get_image_enhance_tone(int *value)
 878 {
 879         int ret = -1;
 880         char path[MAX_NAME+1];
 881
 882         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]);
 883         ret = sys_get_int(path, value);
 884         devmgr_log("path[%s]value[%d]", path, *value);
 885
 886         return ret;
 887 }
 888
 889 int OEM_sys_set_image_enhance_tone(int value)
 890 {
 891         int ret = -1;
 892         char path[MAX_NAME+1];
 893
 894         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]);
 895         devmgr_log("path[%s]value[%d]", path, value);
 896         ret = sys_set_int(path, value);
 897
 898         return ret;
 899 }
 900
 901 int OEM_sys_get_image_enhance_outdoor(int *value)
 902 {
 903         int ret = -1;
 904         char path[MAX_NAME+1];
 905
 906         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]);
 907         ret = sys_get_int(path, value);
 908         devmgr_log("path[%s]value[%d]", path, *value);
 909
 910         return ret;
 911 }
 912
 913 int OEM_sys_set_image_enhance_outdoor(int value)
 914 {
 915         int ret = -1;
 916         char path[MAX_NAME+1];
 917
 918         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]);
 919         devmgr_log("path[%s]value[%d]", path, value);
 920         ret = sys_set_int(path, value);
 921
 922         return ret;
 923 }
 924
 925 int OEM_sys_get_image_enhance_tune(int *value)
 926 {
 927         int ret = -1;
 928         char path[MAX_NAME+1];
 929
 930         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TUNE]);
 931         ret = sys_get_int(path, value);
 932         devmgr_log("path[%s]value[%d]", path, *value);
 933
 934         return ret;
 935 }
 936
 937 int OEM_sys_set_image_enhance_tune(int value)
 938 {
 939         int ret = -1;
 940         char path[MAX_NAME+1];
 941
 942         snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TUNE]);
 943         devmgr_log("path[%s]value[%d]", path, value);
 944         ret = sys_set_int(path, value);
 945
 946         return ret;
 947 }
 948
 949 int OEM_sys_image_enhance_info(int *value)
 950 {
 951         DIR *dir_info;
 952         struct dirent *dir_entry;
 953         int ret = -1;
 954         const char * image_enhance_path_info = IMAGE_ENHANCE_PATH_INFO;
 955
 956         dir_info = opendir(image_enhance_path_info);
 957
 958         if (NULL != dir_info) {
 959                 *value = 1;
 960                 ret = 0;
 961         } else {
 962                 *value = 0;
 963                 ret = -ENOENT;
 964         }
 965
 966         if (NULL != dir_info)
 967                 closedir(dir_info);
 968
 969         return ret;
 970 }
 971
 972 int OEM_sys_set_display_frame_rate(int value)
 973 {
 974         int ret = -1;
 975         char path[MAX_NAME+1];
 976
 977         snprintf(path, MAX_NAME, DISPLAY_FRAME_RATE_PATH);
 978         devmgr_log("path[%s]value[%d]", path, value);
 979         ret = sys_set_int(path, value);
 980
 981         return ret;
 982 }
 983
 984 GENERATE_ACCESSORS_INT_RW(haptic_motor_level, HAPTIC_MOTOR_LEVEL_PATH)
 985 GENERATE_ACCESSORS_INT_R(haptic_motor_level_max, HAPTIC_MOTOR_LEVEL_MAX_PATH)
 986 GENERATE_ACCESSORS_INT_W(haptic_motor_enable, HAPTIC_MOTOR_ENABLE_PATH)
 987 GENERATE_ACCESSORS_INT_W(haptic_motor_oneshot, HAPTIC_MOTOR_ONESHOT_PATH)
 988
 989 GENERATE_ACCESSORS_INT_R(battery_capacity, BATTERY_CAPACITY_PATH)
 990 GENERATE_ACCESSORS_INT_R(battery_charge_full, BATTERY_CHARGE_FULL_PATH)
 991 GENERATE_ACCESSORS_INT_R(battery_charge_now, BATTERY_CHARGE_NOW_PATH)
 992 GENERATE_ACCESSORS_INT_R(battery_present, BATTERY_PRESENT_PATH)
 993
 994 int OEM_sys_get_battery_capacity_raw(int *value)
 995 {
 996         int ret;
 997
 998         ret = sys_get_int(BATTERY_CAPACITY_RAW_PATH, value);
 999         if (ret == -1) {
1000                 return -ENODEV;
1001         }
1002
1003         return ret;
1004 }
1005
1006 static char *health_text[] = {
1007         "Unknown", "Good", "Overheat", "Dead", "Over voltage",
1008         "Unspecified failure", "Cold",
1009 };
1010
1011 int OEM_sys_get_battery_health(int *value)
1012 {
1013         char buf[BUFF_MAX] = {0};
1014         int ret = 0;
1015         int i = 0;
1016
1017         ret = sys_get_str(BATTERY_HEALTH_PATH, buf);
1018         if (ret == -1)
1019                 return -1;
1020
1021         for (i = 0; i < BATTERY_HEALTH_MAX; i++) {
1022                 if (strncmp(buf, health_text[i], strlen(health_text[i])) == 0) {
1023                         *value = i;
1024                         return 0;
1025                 }
1026         }
1027
1028         return -1;
1029 }
1030
1031 int OEM_sys_get_battery_polling_required(int *value)
1032 {
1033         *value = 0;
1034
1035         return 0;
1036 }
1037
1038 int OEM_sys_get_battery_support_insuspend_charging(int *value)
1039 {
1040         *value = 1;
1041
1042         return 0;
1043 }
1044
1045 static char uart_node_path[MAX_NAME];
1046 static char usb_node_path[MAX_NAME];
1047
1048 /* find uart/usb node path */
1049 static int OEM_sys_muic_node_path_info()
1050 {
1051         int err = -1;
1052
1053         err = sys_check_node(UART_PATH);
1054         if (!err)
1055                 sys_get_node(UART_PATH, uart_node_path);
1056         else {
1057                 err = sys_check_node(UART_PATH_TRATS);
1058                 if (err) {
1059                         devmgr_log("uart path node not found");
1060                         printf("uart path node not found\n");
1061                         return -1;
1062                 }
1063                 sys_get_node(UART_PATH_TRATS, uart_node_path);
1064         }
1065
1066         err = sys_check_node(USB_PATH);
1067         if (!err)
1068                 sys_get_node(USB_PATH, usb_node_path);
1069         else {
1070                 err = sys_check_node(USB_PATH_TRATS);
1071                 if (err) {
1072                         devmgr_log("usb path node not found");
1073                         printf("usb path node not found");
1074                         return -1;
1075                 }
1076                 sys_get_node(USB_PATH_TRATS, usb_node_path);
1077         }
1078         return 0;
1079 }
1080
1081 int OEM_sys_get_uart_path(int *value)
1082 {
1083         char buf[BUFF_MAX] = {0};
1084         int ret = 0;
1085
1086         ret = sys_get_str(uart_node_path, buf);
1087         if (ret == -1)
1088                 return -1;
1089
1090         if (strncmp(buf, "CP", 2) == 0) {
1091                 *value = PATH_CP;
1092                 return 0;
1093         } else if (strncmp(buf, "AP", 2) == 0) {
1094                 *value = PATH_AP;
1095                 return 0;
1096         }
1097
1098         return -1;
1099 }
1100
1101 int OEM_sys_set_uart_path(int value)
1102 {
1103         switch (value) {
1104         case PATH_CP:
1105                 return sys_set_str(uart_node_path, "CP");
1106         case PATH_AP:
1107                 return sys_set_str(uart_node_path, "AP");
1108         }
1109
1110         return -1;
1111 }
1112
1113
1114 int OEM_sys_get_usb_path(int *value)
1115 {
1116         char buf[BUFF_MAX] = {0};
1117         int ret = 0;
1118
1119         ret = sys_get_str(usb_node_path, buf);
1120         if (ret == -1)
1121                 return -1;
1122
1123         if (strncmp(buf, "PDA", 3) == 0) {
1124                 *value = PATH_AP;
1125                 return 0;
1126         } else if (strncmp(buf, "MODEM", 5) == 0) {
1127                 *value = PATH_CP;
1128                 return 0;
1129         }
1130
1131         return -1;
1132 }
1133
1134 int OEM_sys_set_usb_path(int value)
1135 {
1136         switch (value) {
1137         case PATH_CP:
1138                 return sys_set_str(usb_node_path, "MODEM");
1139         case PATH_AP:
1140                 return sys_set_str(usb_node_path, "PDA");
1141         }
1142
1143         return -1;
1144 }
1145
1146 GENERATE_ACCESSORS_INT_R(jack_charger_online, JACK_CHARGER_ONLINE_PATH)
1147 GENERATE_ACCESSORS_INT_R(jack_earjack_online, JACK_EARJACK_ONLINE_PATH)
1148 GENERATE_ACCESSORS_INT_R(jack_earkey_online, JACK_EARKEY_ONLINE_PATH)
1149 GENERATE_ACCESSORS_INT_R(jack_hdmi_online, JACK_HDMI_ONLINE_PATH)
1150 GENERATE_ACCESSORS_INT_R(jack_usb_online, JACK_USB_ONLINE_PATH)
1151 GENERATE_ACCESSORS_INT_R(jack_cradle_online, JACK_CRADLE_ONLINE_PATH)
1152 GENERATE_ACCESSORS_INT_R(jack_tvout_online, JACK_TVOUT_ONLINE_PATH)
1153
1154 int OEM_sys_get_jack_keyboard_online(int *value)
1155 {
1156         /* Currently, We don't provide SLP Based platform with keyboard I/F */
1157         int ret = -1;
1158         /*return sys_get_int(JACK_KEYBOARD_ONLINE_PATH, value);*/
1159         return ret;
1160 }
1161
1162 int OEM_sys_get_hdmi_support(int *value)
1163 {
1164         //TODO: remove for SC7727?
1165         *value = 1;
1166
1167         return 0;
1168 }
1169
1170 int OEM_sys_set_irled_control(char *value)
1171 {
1172         sys_set_str(IRLED_CONTROL_PATH, value);
1173
1174         return 0;
1175 }
1176
1177
1178 GENERATE_ACCESSORS_INT_R(leds_torch_max_brightness, LEDS_TORCH_MAX_BRIGHTNESS_PATH)
1179 GENERATE_ACCESSORS_INT_RW(leds_torch_brightness, LEDS_TORCH_BRIGHTNESS_PATH)
1180
1181 int OEM_sys_set_power_state(int value)
1182 {
1183         switch (value) {
1184         case POWER_STATE_SUSPEND:
1185                 return sys_set_str(POWER_STATE_PATH, "mem");
1186 #if 1
1187         case POWER_STATE_PRE_SUSPEND:
1188                 return sys_set_str(POWER_STATE_PATH, "pre_suspend");
1189 #else
1190         case POWER_STATE_PRE_SUSPEND:
1191                 return sys_set_str(POWER_AUTOSLEEP_PATH, "mem");
1192 #endif
1193         case POWER_STATE_POST_RESUME:
1194                 return sys_set_str(POWER_STATE_PATH, "post_resume");
1195         }
1196
1197         return -1;
1198 }
1199
1200 int OEM_sys_set_power_lock(int value)
1201 {
1202         static int power_lock_state = -1;
1203
1204         if (power_lock_state == value)
1205                 return -1;
1206         else
1207                 power_lock_state = value;
1208
1209         switch (value) {
1210         case POWER_UNLOCK:
1211                 return sys_set_str(POWER_UNLOCK_PATH, "mainlock");
1212         case POWER_LOCK:
1213                 return sys_set_str(POWER_LOCK_PATH, "mainlock");
1214         }
1215
1216         return 0;
1217 }
1218
1219 int OEM_sys_get_power_lock_support(int *value)
1220 {
1221         int err = -1;
1222
1223         err = sys_check_node(POWER_LOCK_PATH);
1224         if (err == -1) {
1225                 devmgr_log("power lock node not found");
1226                 *value = 0;
1227         } else
1228                 *value = 1;
1229
1230         return 0;
1231 }
1232
1233 int OEM_sys_set_resetkey_disable(int value)
1234 {
1235         int ret = -1;
1236
1237         if (value == 0)
1238                 value = 1;
1239         else
1240                 value = 0;
1241
1242         ret = sys_set_int(KEY_MANUAL_RESET_PMIC_PATH, value);
1243         ret = sys_set_int(KEY_MANUAL_RESET_SAFEOUT_PATH, value);
1244
1245         return ret;
1246 }
1247
1248 GENERATE_ACCESSORS_INT_RW(power_wakeup_count, POWER_WAKEUP_COUNT_PATH)
1249
1250 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv1, MEMNOTIFY_THRESHOLD_LV1_PATH)
1251 GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv2, MEMNOTIFY_THRESHOLD_LV2_PATH)
1252
1253 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_max_freq, CPUFREQ_CPUINFO_MAX_FREQ_PATH)
1254 GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_min_freq, CPUFREQ_CPUINFO_MIN_FREQ_PATH)
1255 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_max_freq, CPUFREQ_SCALING_MAX_FREQ_PATH)
1256 GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_min_freq, CPUFREQ_SCALING_MIN_FREQ_PATH)
1257 GENERATE_ACCESSORS_INT_RW(cpufreq_power_max_freq, CPUFREQ_POWER_MAX_FREQ_PATH)
1258 GENERATE_ACCESSORS_INT_RW(cpufreq_power_min_freq, CPUFREQ_POWER_MIN_FREQ_PATH)
1259 GENERATE_ACCESSORS_INT_R(cpu_enable_max_number, CPU_ENABLE_MAX_NUMBER_PATH)
1260 GENERATE_ACCESSORS_INT_W(cpu_enable_max_number, CPU_ENABLE_MAX_NUMBER_PATH)
1261
1262 #define GENERATE_ACCESSORS_INT_R_NO_CONVERT(_suffix, _item)     \
1263 int OEM_sys_get_##_suffix(int *value)                   \
1264 {                                               \
1265         return sys_get_int_wo_convert(_item, value);    \
1266 }
1267
1268 #define GENERATE_ACCESSORS_INT_W_NO_CONVERT(_suffix, _item)     \
1269 int OEM_sys_set_##_suffix(int value)                    \
1270 {                                               \
1271         return sys_set_int_wo_convert(_item, value);    \
1272 }
1273
1274 GENERATE_ACCESSORS_INT_R_NO_CONVERT(memnotify_victim_task, MEMNOTIFY_VICTIM_TASK_PATH)
1275 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_pnp, PROCESS_MONITOR_MP_PNP_PATH)
1276 GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_vip, PROCESS_MONITOR_MP_VIP_PATH)
1277
1278 #define GENERATE_ACCESSORS_GET_NODE_PATH(_suffix, _item)        \
1279 int OEM_sys_get_##_suffix(char *node)                   \
1280 {                                               \
1281         return sys_get_node(_item, node);       \
1282 }
1283
1284 GENERATE_ACCESSORS_GET_NODE_PATH(touch_event, TOUCH_EVENT_NODE)
1285 GENERATE_ACCESSORS_GET_NODE_PATH(memnotify_node, MEMNOTIFY_NODE)
1286 GENERATE_ACCESSORS_GET_NODE_PATH(process_monitor_node, PROCESS_MONITOR_NODE)
1287
1288 GENERATE_ACCESSORS_INT_R(temperature_adc, TEMPERATURE_ADC_PATH)
1289 GENERATE_ACCESSORS_INT_R(temperature_value, TEMPERATURE_VALUE_PATH)
1290
1291 #define SVCLED_PATTERN_MASK     0xFF000000
1292 #define SVCLED_PATTERN_SHIFT            24
1293 #define SVCLED_RGB_MASK         0x00FFFFFF
1294
1295 int OEM_sys_set_svcled_color(int rgb, int led_on_ms, int led_off_ms)
1296 {
1297         int ret = -1;
1298         unsigned int svcled_pattern, svcled_rgb;
1299         char buf[BUFF_MAX];
1300
1301         devmgr_log("RGB: [%d], LED_On_ms: [%d], LED_Off_ms: [%d] ", rgb, led_on_ms, led_off_ms);
1302
1303         svcled_pattern = (rgb & SVCLED_PATTERN_MASK) >> SVCLED_PATTERN_SHIFT;
1304
1305         if (svcled_pattern)
1306                 ret = sys_set_int(SERVICE_LED_PATTERN_PATH, (int)svcled_pattern);
1307         else {
1308                 svcled_rgb = rgb & SVCLED_RGB_MASK;
1309                 snprintf(buf, sizeof(buf), "0x%x %d %d", svcled_rgb, led_on_ms, led_off_ms);
1310
1311                 ret = sys_set_str(SERVICE_LED_BLINK_PATH, buf);
1312                 if (ret != 0)
1313                         return ret;
1314         }
1315
1316         return ret;
1317 }
1318
1319 int OEM_sys_get_battery_technology(char *value)
1320 {
1321         int err = -1;
1322
1323         err = sys_get_str(BATTERY_TECHNOLOGY_PATH, value);
1324         if (err == 0)
1325                 return 0;
1326         else
1327                 return -1;
1328 }
1329
1330 int OEM_sys_get_battery_temperature(int *value)
1331 {
1332         int err = -1;
1333
1334         err = sys_get_int(BATTERY_TEMPERATURE_PATH, value);
1335
1336         if (err == 0)
1337                 return 0;
1338         else
1339                 return -1;
1340 }
1341
1342 int OEM_sys_get_battery_voltage(int *value)
1343 {
1344         int err = -1;
1345
1346         err = sys_get_int(BATTERY_VOLTAGE_PATH, value);
1347
1348         if (err == 0)
1349                 return 0;
1350         else
1351                 return -1;
1352 }
1353
1354
1355 static OEM_sys_devman_plugin_interface devman_plugin_interface_sc7727;
1356
1357 EXPORT_API const OEM_sys_devman_plugin_interface *OEM_sys_get_devman_plugin_interface()
1358 {
1359         /* Light interfaces */
1360         devman_plugin_interface_sc7727.OEM_sys_get_display_count = &OEM_sys_get_display_count;
1361         devman_plugin_interface_sc7727.OEM_sys_get_backlight_min_brightness = &OEM_sys_get_backlight_min_brightness;
1362         devman_plugin_interface_sc7727.OEM_sys_get_backlight_max_brightness = &OEM_sys_get_backlight_max_brightness;
1363         devman_plugin_interface_sc7727.OEM_sys_get_backlight_brightness = &OEM_sys_get_backlight_brightness;
1364         devman_plugin_interface_sc7727.OEM_sys_set_backlight_brightness = &OEM_sys_set_backlight_brightness;
1365         devman_plugin_interface_sc7727.OEM_sys_set_backlight_dimming = &OEM_sys_set_backlight_dimming;
1366         devman_plugin_interface_sc7727.OEM_sys_get_backlight_acl_control = &OEM_sys_get_backlight_acl_control;
1367         devman_plugin_interface_sc7727.OEM_sys_set_backlight_acl_control = &OEM_sys_set_backlight_acl_control;
1368
1369         devman_plugin_interface_sc7727.OEM_sys_get_lcd_power = &OEM_sys_get_lcd_power;
1370         devman_plugin_interface_sc7727.OEM_sys_set_lcd_power = &OEM_sys_set_lcd_power;
1371
1372         /* Image Ehnhace interfaces */
1373         devman_plugin_interface_sc7727.OEM_sys_get_image_enhance_mode = &OEM_sys_get_image_enhance_mode;
1374         devman_plugin_interface_sc7727.OEM_sys_set_image_enhance_mode = &OEM_sys_set_image_enhance_mode;
1375         devman_plugin_interface_sc7727.OEM_sys_get_image_enhance_scenario = &OEM_sys_get_image_enhance_scenario;
1376         devman_plugin_interface_sc7727.OEM_sys_set_image_enhance_scenario = &OEM_sys_set_image_enhance_scenario;
1377         devman_plugin_interface_sc7727.OEM_sys_get_image_enhance_tone = &OEM_sys_get_image_enhance_tone;
1378         devman_plugin_interface_sc7727.OEM_sys_set_image_enhance_tone = &OEM_sys_set_image_enhance_tone;
1379         devman_plugin_interface_sc7727.OEM_sys_get_image_enhance_outdoor = &OEM_sys_get_image_enhance_outdoor;
1380         devman_plugin_interface_sc7727.OEM_sys_set_image_enhance_outdoor = &OEM_sys_set_image_enhance_outdoor;
1381
1382         devman_plugin_interface_sc7727.OEM_sys_get_image_enhance_tune = &OEM_sys_get_image_enhance_tune;
1383         devman_plugin_interface_sc7727.OEM_sys_set_image_enhance_tune = &OEM_sys_set_image_enhance_tune;
1384
1385         devman_plugin_interface_sc7727.OEM_sys_image_enhance_info = &OEM_sys_image_enhance_info;
1386
1387         devman_plugin_interface_sc7727.OEM_sys_set_display_frame_rate = &OEM_sys_set_display_frame_rate;
1388
1389         devman_plugin_interface_sc7727.OEM_sys_set_auto_screen_tone = &OEM_sys_set_auto_screen_tone;
1390         devman_plugin_interface_sc7727.OEM_sys_get_auto_screen_tone = &OEM_sys_get_auto_screen_tone;
1391
1392         devman_plugin_interface_sc7727.OEM_sys_get_image_enhance_color_blind = &OEM_sys_get_image_enhance_color_blind;
1393         devman_plugin_interface_sc7727.OEM_sys_set_image_enhance_color_blind = &OEM_sys_set_image_enhance_color_blind;
1394
1395         /* UART path interfaces */
1396         devman_plugin_interface_sc7727.OEM_sys_get_uart_path = &OEM_sys_get_uart_path;
1397         devman_plugin_interface_sc7727.OEM_sys_set_uart_path = &OEM_sys_set_uart_path;
1398
1399         /* USB path interfaces */
1400         devman_plugin_interface_sc7727.OEM_sys_get_usb_path = &OEM_sys_get_usb_path;
1401         devman_plugin_interface_sc7727.OEM_sys_set_usb_path = &OEM_sys_set_usb_path;
1402
1403         /* Vibrator interfaces */
1404         devman_plugin_interface_sc7727.OEM_sys_get_haptic_vibetones_level_max = &OEM_sys_get_haptic_motor_level_max;
1405         devman_plugin_interface_sc7727.OEM_sys_get_haptic_vibetones_level = &OEM_sys_get_haptic_motor_level;
1406         devman_plugin_interface_sc7727.OEM_sys_set_haptic_vibetones_level = &OEM_sys_set_haptic_motor_level;
1407         devman_plugin_interface_sc7727.OEM_sys_set_haptic_vibetones_enable = &OEM_sys_set_haptic_motor_enable;
1408         devman_plugin_interface_sc7727.OEM_sys_set_haptic_vibetones_oneshot = &OEM_sys_set_haptic_motor_oneshot;
1409
1410         /* Battery interfaces */
1411         devman_plugin_interface_sc7727.OEM_sys_get_battery_capacity = &OEM_sys_get_battery_capacity;
1412         devman_plugin_interface_sc7727.OEM_sys_get_battery_capacity_raw = &OEM_sys_get_battery_capacity_raw;
1413         devman_plugin_interface_sc7727.OEM_sys_get_battery_charge_full = &OEM_sys_get_battery_charge_full;
1414         devman_plugin_interface_sc7727.OEM_sys_get_battery_charge_now = &OEM_sys_get_battery_charge_now;
1415         devman_plugin_interface_sc7727.OEM_sys_get_battery_present = &OEM_sys_get_battery_present;
1416         devman_plugin_interface_sc7727.OEM_sys_get_battery_health = &OEM_sys_get_battery_health;
1417         devman_plugin_interface_sc7727.OEM_sys_get_battery_polling_required = &OEM_sys_get_battery_polling_required;
1418         devman_plugin_interface_sc7727.OEM_sys_get_battery_support_insuspend_charging = &OEM_sys_get_battery_support_insuspend_charging;
1419
1420         /* Connection interfaces  */
1421         devman_plugin_interface_sc7727.OEM_sys_get_jack_charger_online = &OEM_sys_get_jack_charger_online;
1422         devman_plugin_interface_sc7727.OEM_sys_get_jack_earjack_online = &OEM_sys_get_jack_earjack_online;
1423         devman_plugin_interface_sc7727.OEM_sys_get_jack_earkey_online = &OEM_sys_get_jack_earkey_online;
1424         devman_plugin_interface_sc7727.OEM_sys_get_jack_hdmi_online = &OEM_sys_get_jack_hdmi_online;
1425         devman_plugin_interface_sc7727.OEM_sys_get_jack_usb_online = &OEM_sys_get_jack_usb_online;
1426         devman_plugin_interface_sc7727.OEM_sys_get_jack_cradle_online = &OEM_sys_get_jack_cradle_online;
1427         devman_plugin_interface_sc7727.OEM_sys_get_jack_tvout_online = &OEM_sys_get_jack_tvout_online;
1428         devman_plugin_interface_sc7727.OEM_sys_get_jack_keyboard_online = &OEM_sys_get_jack_keyboard_online;
1429
1430         devman_plugin_interface_sc7727.OEM_sys_get_hdmi_support = &OEM_sys_get_hdmi_support;
1431
1432         /* Torch interfaces */
1433         devman_plugin_interface_sc7727.OEM_sys_get_leds_torch_max_brightness = &OEM_sys_get_leds_torch_max_brightness;
1434         devman_plugin_interface_sc7727.OEM_sys_get_leds_torch_brightness = &OEM_sys_get_leds_torch_brightness;
1435         devman_plugin_interface_sc7727.OEM_sys_set_leds_torch_brightness = &OEM_sys_set_leds_torch_brightness;
1436
1437         /* Power management interfaces */
1438         devman_plugin_interface_sc7727.OEM_sys_set_power_state = &OEM_sys_set_power_state;
1439         devman_plugin_interface_sc7727.OEM_sys_set_power_lock = &OEM_sys_set_power_lock;
1440         devman_plugin_interface_sc7727.OEM_sys_get_power_lock_support = &OEM_sys_get_power_lock_support;
1441
1442         /* TODO: Should determine enum values of wakeup_count nodes */
1443         devman_plugin_interface_sc7727.OEM_sys_get_power_wakeup_count = &OEM_sys_get_power_wakeup_count;
1444         devman_plugin_interface_sc7727.OEM_sys_set_power_wakeup_count = &OEM_sys_set_power_wakeup_count;
1445
1446         /* OOM interfaces */
1447         devman_plugin_interface_sc7727.OEM_sys_get_memnotify_node = &OEM_sys_get_memnotify_node;
1448         devman_plugin_interface_sc7727.OEM_sys_get_memnotify_victim_task = &OEM_sys_get_memnotify_victim_task;
1449         devman_plugin_interface_sc7727.OEM_sys_set_memnotify_threshold_lv1 = &OEM_sys_set_memnotify_threshold_lv1;
1450         devman_plugin_interface_sc7727.OEM_sys_set_memnotify_threshold_lv2 = &OEM_sys_set_memnotify_threshold_lv2;
1451
1452         /* Process monitor interfaces */
1453         devman_plugin_interface_sc7727.OEM_sys_get_process_monitor_node = &OEM_sys_get_process_monitor_node;
1454         devman_plugin_interface_sc7727.OEM_sys_set_process_monitor_mp_pnp = &OEM_sys_set_process_monitor_mp_pnp;
1455         devman_plugin_interface_sc7727.OEM_sys_set_process_monitor_mp_vip = &OEM_sys_set_process_monitor_mp_vip;
1456
1457         /* UART path interfaces */
1458         devman_plugin_interface_sc7727.OEM_sys_get_cpufreq_cpuinfo_max_freq = &OEM_sys_get_cpufreq_cpuinfo_max_freq;
1459         devman_plugin_interface_sc7727.OEM_sys_get_cpufreq_cpuinfo_min_freq = &OEM_sys_get_cpufreq_cpuinfo_min_freq;
1460         devman_plugin_interface_sc7727.OEM_sys_get_cpufreq_scaling_max_freq = &OEM_sys_get_cpufreq_scaling_max_freq;
1461         devman_plugin_interface_sc7727.OEM_sys_set_cpufreq_scaling_max_freq = &OEM_sys_set_cpufreq_scaling_max_freq;
1462         devman_plugin_interface_sc7727.OEM_sys_get_cpufreq_scaling_min_freq = &OEM_sys_get_cpufreq_scaling_min_freq;
1463         devman_plugin_interface_sc7727.OEM_sys_set_cpufreq_scaling_min_freq = &OEM_sys_set_cpufreq_scaling_min_freq;
1464         devman_plugin_interface_sc7727.OEM_sys_get_cpufreq_power_max_freq = &OEM_sys_get_cpufreq_power_max_freq;
1465         devman_plugin_interface_sc7727.OEM_sys_set_cpufreq_power_max_freq = &OEM_sys_set_cpufreq_power_max_freq;
1466         devman_plugin_interface_sc7727.OEM_sys_get_cpufreq_power_min_freq = &OEM_sys_get_cpufreq_power_min_freq;
1467         devman_plugin_interface_sc7727.OEM_sys_set_cpufreq_power_min_freq = &OEM_sys_set_cpufreq_power_min_freq;
1468
1469         devman_plugin_interface_sc7727.OEM_sys_get_battery_siop_active = &OEM_sys_get_battery_siop_active;
1470         devman_plugin_interface_sc7727.OEM_sys_set_battery_siop_active = &OEM_sys_set_battery_siop_active;
1471
1472         devman_plugin_interface_sc7727.OEM_sys_get_cpu_enable_max_number = &OEM_sys_get_cpu_enable_max_number;
1473         devman_plugin_interface_sc7727.OEM_sys_set_cpu_enable_max_number = &OEM_sys_set_cpu_enable_max_number;
1474
1475         devman_plugin_interface_sc7727.OEM_sys_get_temperature_adc = &OEM_sys_get_temperature_adc;
1476         devman_plugin_interface_sc7727.OEM_sys_get_temperature_value = &OEM_sys_get_temperature_value;
1477
1478         devman_plugin_interface_sc7727.OEM_sys_get_backlight_overheating_control = &OEM_sys_get_backlight_overheating_control;
1479         devman_plugin_interface_sc7727.OEM_sys_set_backlight_overheating_control = &OEM_sys_set_backlight_overheating_control;
1480
1481         devman_plugin_interface_sc7727.OEM_sys_get_backlight_brightness_by_lux = &OEM_sys_get_backlight_brightness_by_lux;
1482
1483         devman_plugin_interface_sc7727.OEM_sys_get_whitemagic_mode = &OEM_sys_get_whitemagic_mode;
1484         devman_plugin_interface_sc7727.OEM_sys_set_whitemagic_mode = &OEM_sys_set_whitemagic_mode;
1485
1486         devman_plugin_interface_sc7727.OEM_sys_get_lcd_cabc = &OEM_sys_get_lcd_cabc;
1487         devman_plugin_interface_sc7727.OEM_sys_set_lcd_cabc = &OEM_sys_set_lcd_cabc;
1488
1489         devman_plugin_interface_sc7727.OEM_sys_set_irled_control = &OEM_sys_set_irled_control;
1490         devman_plugin_interface_sc7727.OEM_sys_set_svcled_color = &OEM_sys_set_svcled_color;
1491
1492         devman_plugin_interface_sc7727.OEM_sys_set_siop_control = &OEM_sys_set_siop_control;
1493
1494         devman_plugin_interface_sc7727.OEM_sys_get_hall_status = &OEM_sys_get_hall_status;
1495
1496         devman_plugin_interface_sc7727.OEM_sys_set_resetkey_disable = &OEM_sys_set_resetkey_disable;
1497
1498         devman_plugin_interface_sc7727.OEM_sys_get_hardkey_backlight = &OEM_sys_get_hardkey_backlight;
1499         devman_plugin_interface_sc7727.OEM_sys_set_hardkey_backlight = &OEM_sys_set_hardkey_backlight;
1500
1501         devman_plugin_interface_sc7727.OEM_sys_get_battery_technology = &OEM_sys_get_battery_technology;
1502         devman_plugin_interface_sc7727.OEM_sys_get_battery_temperature = &OEM_sys_get_battery_temperature;
1503         devman_plugin_interface_sc7727.OEM_sys_get_battery_voltage = &OEM_sys_get_battery_voltage;
1504
1505         OEM_sys_display_info(disp_info);
1506         OEM_sys_muic_node_path_info();
1507
1508         return &devman_plugin_interface_sc7727;
1509 }
1510
1511 #define ___TESTED__
1512
1513 int main(void){
1514
1515 #ifdef ___TESTED__
1516 int ret = 0 ;
1517         OEM_sys_devman_plugin_interface *devman_plugin;
1518         devman_plugin = OEM_sys_get_devman_plugin_interface();
1519         int brightness_value;
1520         int index = DISP_MAIN;
1521         int power_saving;
1522
1523         printf("Testing OEM_sys_get_backlight_brightness\n");
1524         power_saving = 0;
1525         brightness_value = -1;
1526         ret = devman_plugin->OEM_sys_get_backlight_brightness(index, &brightness_value, power_saving);
1527         printf("%d=OEM_sys_get_backlight_brightness(%d, %d, %d)\n", ret, index, brightness_value, power_saving);
1528         power_saving = 1;
1529         brightness_value = -1;
1530         ret = devman_plugin->OEM_sys_get_backlight_brightness(index, &brightness_value, power_saving);
1531         printf("%d=OEM_sys_get_backlight_brightness(%d, %d, %d)\n", ret, index, brightness_value, power_saving);
1532         printf("-------------------------\n\n");
1533         //need to check usage...of "lux"
1534         int value = -1;
1535
1536         //ret = devman_plugin->OEM_sys_get_backlight_brightness_by_lux(1, &value);
1537         //printf("%d=OEM_sys_get_backlight_brightness_by_lux(%d, %d)\n", ret, 1, value);
1538         printf("Testing OEM_sys_set_backlight_brightness\n");
1539
1540         index = DISP_MAIN;
1541         brightness_value = 98;
1542         power_saving = 0;
1543         ret = devman_plugin->OEM_sys_set_backlight_brightness(index, 98, 0);
1544         printf("%d=OEM_sys_set_backlight_brightness(%d, %d, %d)\n", ret, index, brightness_value, power_saving);
1545         printf("-------------------------\n\n");
1546
1547         printf("Testing OEM_sys_get_backlight_max_brightness\n");
1548         value = -1;
1549         ret = devman_plugin->OEM_sys_get_backlight_max_brightness(index, &value);
1550         printf("%d=OEM_sys_get_backlight_max_brightness(%d, %d)\n", ret, index, value);
1551         printf("-------------------------\n\n");
1552
1553         printf("Testing OEM_sys_get_display_count\n");
1554         value = -1;
1555         ret = devman_plugin->OEM_sys_get_display_count(&value);
1556         printf("%d=OEM_sys_get_display_count(%d)\n", ret, value);
1557         printf("-------------------------\n\n");
1558
1559         printf("Testing OEM_sys_get_battery_voltage\n");
1560         value = -1;
1561         ret = devman_plugin->OEM_sys_get_battery_voltage(&value);
1562         printf("%d=OEM_sys_get_battery_voltage(%d)\n", ret, value);
1563         printf("-------------------------\n\n");
1564
1565         printf("Testing OEM_sys_get_battery_temperature\n");
1566         value = -1;
1567         ret = devman_plugin->OEM_sys_get_battery_temperature(&value);
1568         printf("%d=OEM_sys_get_battery_temperature(%d)\n", ret, value);
1569         printf("-------------------------\n");
1570
1571
1572         printf("Testing OEM_sys_get_battery_health\n");
1573         value = -1;
1574         ret = devman_plugin->OEM_sys_get_battery_health(&value);
1575         printf("%d=OEM_sys_get_battery_health(%d)\n", ret, value);
1576         printf("-------------------------\n\n");
1577
1578
1579         printf("Testing OEM_sys_get_battery_technology\n");
1580         char char_value[1024] = {0,};
1581         ret = devman_plugin->OEM_sys_get_battery_technology(char_value);
1582         printf("%d=OEM_sys_get_battery_temperature(%s)\n", ret, char_value);
1583         printf("-------------------------\n\n");
1584
1585         printf("Testing OEM_sys_get_power_lock_support\n");
1586         value = -1;
1587         ret = devman_plugin->OEM_sys_get_power_lock_support(&value);
1588         printf("%d=OEM_sys_get_power_lock_support(%d)\n", ret, value);
1589         printf("-------------------------\n\n");
1590
1591         printf("Testing OEM_sys_set_power_state\n");
1592         value = POWER_STATE_PRE_SUSPEND;
1593         ret = devman_plugin->OEM_sys_set_power_state(value);
1594         printf("%d=OEM_sys_set_power_state(%d)\n", ret, value);
1595         printf("-------------------------\n\n");
1596
1597         printf("Testing OEM_sys_set_power_lock\n");
1598         value = 1;
1599         ret = devman_plugin->OEM_sys_set_power_lock(value);
1600         printf("%d=OEM_sys_set_power_lock(%d)\n", ret, value);
1601         printf("-------------------------\n\n");
1602
1603         printf("Testing OEM_sys_get_hdmi_support\n");
1604         value = -1;
1605         ret = devman_plugin->OEM_sys_get_hdmi_support(&value);
1606         printf("%d=OEM_sys_get_hdmi_support(%d)\n", ret, value);
1607         printf("-------------------------\n\n");
1608
1609         printf("Testing OEM_sys_get_jack_keyboard_online\n");
1610         value = -1;
1611         ret = devman_plugin->OEM_sys_get_jack_keyboard_online(&value);
1612         printf("%d=OEM_sys_get_jack_keyboard_online(%d)\n", ret, value);
1613         printf("-------------------------\n\n");
1614
1615         printf("Testing OEM_sys_set_usb_path\n");
1616         ret = devman_plugin->OEM_sys_set_usb_path(PATH_CP);
1617         printf("%d=OEM_sys_set_usb_path(%d)\n", ret, PATH_CP);
1618         ret = devman_plugin->OEM_sys_set_usb_path(PATH_AP);
1619         printf("%d=OEM_sys_set_usb_path(%d)\n", ret, PATH_AP);
1620         printf("-------------------------\n\n");
1621
1622         printf("Testing OEM_sys_set_uart_path\n");
1623         ret = devman_plugin->OEM_sys_set_uart_path(PATH_CP);
1624         printf("%d=OEM_sys_set_uart_path(%d)\n", ret, PATH_CP);
1625         ret = devman_plugin->OEM_sys_set_uart_path(PATH_AP);
1626         printf("%d=OEM_sys_set_uart_path(%d)\n", ret, PATH_AP);
1627         printf("-------------------------\n\n");
1628
1629
1630         printf("Testing OEM_sys_get_usb_path\n");
1631         value = -1;
1632         ret = devman_plugin->OEM_sys_get_usb_path(&value);
1633         printf("%d=OEM_sys_get_usb_path(%d)\n", ret, value);
1634         printf("-------------------------\n\n");
1635
1636         printf("Testing OEM_sys_get_uart_path\n");
1637         value = -1;
1638         ret = devman_plugin->OEM_sys_get_uart_path(&value);
1639         printf("%d=OEM_sys_get_uart_path(%d)\n", ret, value);
1640         printf("-------------------------\n\n");
1641
1642
1643 #else
1644         OEM_sys_set_whitemagic_mode(int index, int value);              //MISSING & not present in Redwood
1645         OEM_sys_get_whitemagic_mode(int index, int *value);     //MISSING & not present in Redwood
1646         OEM_sys_get_hall_status(int *value);                                    //MISSING & not present in Redwood
1647         OEM_sys_set_hardkey_backlight(int value);                               //MISSING & Present in Redwood
1648         OEM_sys_get_hardkey_backlight(int *value);                      //MISSING & Present in Redwood
1649
1650
1651         OEM_sys_set_auto_screen_tone(int index, int value);             //MISSING & Present in Redwood
1652         OEM_sys_get_auto_screen_tone(int index, int *value);    //MISSING & Present in Redwood
1653         OEM_sys_set_lcd_cabc(int index, int value);                             //MISSING & not present in Redwood
1654         OEM_sys_get_lcd_cabc(int index, int *value);                    //MISSING & not present in Redwood
1655         OEM_sys_set_lcd_power(int index, int value);                    //MISSING & Present in Redwood
1656         OEM_sys_get_lcd_power(int index, int *value);                   //MISSING & Present in Redwood
1657         OEM_sys_set_backlight_acl_control(int index, int value);        //MISSING & Present in Redwood
1658         OEM_sys_get_backlight_acl_control(int index, int *value);       //MISSING & Present in Redwood
1659
1660         OEM_sys_set_backlight_dimming(int index, int value);            //MISSING & not present in Redwood
1661
1662         OEM_sys_get_backlight_min_brightness(int index, int *value);    //MISSING & not present in Redwood
1663
1664         int OEM_sys_set_svcled_color(int rgb, int led_on_ms, int led_off_ms);   //MISSING  & .......
1665         int OEM_sys_set_resetkey_disable(int value);                                            //MISSING  & .......
1666
1667
1668         int OEM_sys_set_irled_control(char *value);                             //MISSING  & .......
1669
1670
1671         /* find uart/usb node path */
1672         OEM_sys_get_battery_capacity_raw(int *value);                   //MISSING
1673         OEM_sys_set_display_frame_rate(int value);                      //MISSING
1674         OEM_sys_image_enhance_info(int *value);                         //MISSING
1675         OEM_sys_set_image_enhance_tune(int value);                      //MISSING
1676         OEM_sys_get_image_enhance_tune(int *value);                     //MISSING
1677         OEM_sys_set_image_enhance_outdoor(int value);           //MISSING
1678         OEM_sys_get_image_enhance_outdoor(int *value);          //MISSING
1679         OEM_sys_set_image_enhance_tone(int value);                      //MISSING
1680         OEM_sys_get_image_enhance_tone(int *value);                     //MISSING
1681         OEM_sys_set_image_enhance_scenario(int value);          //MISSING
1682         OEM_sys_get_image_enhance_scenario(int *value);         //MISSING
1683         OEM_sys_set_image_enhance_mode(int value);                      //MISSING
1684         OEM_sys_get_image_enhance_mode(int *value);             //MISSING
1685         OEM_sys_set_image_enhance_restore(void *image_enhance);         //MISSING
1686         OEM_sys_get_image_enhance_save(void *image_enhance);            //MISSING
1687         OEM_sys_set_image_enhance_color_blind(void *value);                     //MISSING
1688         OEM_sys_get_image_enhance_color_blind(int *value);                      //MISSING
1689 #endif
1690
1691 }
1692
1693