src/if_legacy.c

   1 /*
   2  * devman
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19 #include <vconf.h>
  20 #include <errno.h>
  21 #include <device-node.h>
  22
  23 #include "devman.h"
  24 #include "devman_internal.h"
  25 #include "devlog.h"
  26
  27 #define DISPLAY_MAX_BRIGHTNESS  100
  28 #define DISPLAY_MIN_BRIGHTNESS  0
  29
  30 #define DISP_INDEX_BIT                      4
  31 #define COMBINE_DISP_CMD(cmd, prop, index)  (cmd = (prop | (index << DISP_INDEX_BIT)))
  32
  33 #define SET_FLAG(var, bit)              (var |= (1<<bit))
  34 #define UNSET_FLAG(var, bit)            (var &= (~(1<<bit)))
  35 #define BRT_BIT                 1
  36 #define LED_BIT                 4
  37
  38 static unsigned int disp_flag = 0x0;
  39
  40 API int device_get_battery_pct(void)
  41 {
  42         int val;
  43         int ret;
  44
  45         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY, &val);
  46         if (ret < 0)
  47                 return ret;
  48
  49         if (val < 0 || val > 100) {
  50                 DEVERR("capacity value is wrong");
  51                 return DEVMAN_ERROR_OPERATION_FAILED;
  52         }
  53
  54         return val;
  55 }
  56
  57 API int device_is_battery_full(void)
  58 {
  59         int val;
  60         int ret;
  61
  62         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_FULL, &val);
  63         if (ret < 0)
  64                 return ret;
  65
  66         if (val != 0 && val != 1) {
  67                 DEVERR("charge_full value is wrong");
  68                 return DEVMAN_ERROR_OPERATION_FAILED;
  69         }
  70
  71         return val;
  72 }
  73
  74 API int device_get_battery_health(void)
  75 {
  76         int val;
  77         int ret;
  78
  79         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_HEALTH, &val);
  80         if (ret < 0)
  81                 return ret;
  82
  83         if (val < BAT_UNKNOWN || val > BAT_COLD) {
  84                 DEVERR("battery health value is wrong");
  85                 return DEVMAN_ERROR_OPERATION_FAILED;
  86         }
  87
  88         return val;
  89 }
  90
  91 API int device_get_battery_pct_raw(void)
  92 {
  93         int val;
  94         int ret;
  95
  96         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY_RAW, &val);
  97         if (ret < 0)
  98                 return ret;
  99
 100         if (val > 10000)
 101                 return 10000;
 102
 103         return val;
 104 }
 105
 106 API int device_get_display_brt(display_num_t lcdnum)
 107 {
 108         int val;
 109         int cmd;
 110         int ret;
 111
 112         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_BRIGHTNESS, lcdnum);
 113         ret = device_get_property(DEVICE_TYPE_DISPLAY, cmd, &val);
 114         if (ret < 0)
 115                 return ret;
 116
 117         return val;
 118 }
 119
 120 API int device_set_display_brt_with_settings(display_num_t lcdnum, int val)
 121 {
 122         int bat_state;
 123         int auto_brt_state;
 124         int cmd;
 125         int ret;
 126
 127         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0) {
 128                 DEVERR("Failed to get VCONFKEY_SYSMAN_BATTERY_STATUS_LOW value");
 129                 return DEVMAN_ERROR_OPERATION_FAILED;
 130         }
 131
 132         if (bat_state < VCONFKEY_SYSMAN_BAT_WARNING_LOW) {
 133                 DEVLOG("can not set brightness for low battery");
 134                 return DEVMAN_ERROR_NONE;
 135         }
 136
 137         if (vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_brt_state) != 0) {
 138                 DEVERR("Failed to get VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT value");
 139                 return DEVMAN_ERROR_OPERATION_FAILED;
 140         }
 141
 142         if (auto_brt_state == SETTING_BRIGHTNESS_AUTOMATIC_ON) {
 143                 DEVLOG("auto_brightness state is ON, can not change the brightness value");
 144                 return DEVMAN_ERROR_NONE;
 145         }
 146
 147         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_BRIGHTNESS, lcdnum);
 148         ret = device_set_property(DEVICE_TYPE_DISPLAY, cmd, val);
 149         if (ret < 0)
 150                 return ret;
 151
 152         if (vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, val) != 0) {
 153                 DEVERR("Failed to set VCONFKEY_SETAPPL_LCD_BRIGHTNESS value");
 154         }
 155
 156         if (vconf_set_int(VCONFKEY_PM_CURRENT_BRIGHTNESS, val) != 0) {
 157                 DEVERR("Failed to set VCONFKEY_PM_CURRENT_BRIGHTNESS value");
 158         }
 159
 160         return DEVMAN_ERROR_NONE;
 161 }
 162
 163 API int device_set_display_brt(display_num_t lcdnum, int val)
 164 {
 165         int bat_state;
 166         int auto_brt_state;
 167         int cmd;
 168         int ret;
 169
 170         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0) {
 171                 DEVERR("Failed to get VCONFKEY_SYSMAN_BATTERY_STATUS_LOW value");
 172                 return DEVMAN_ERROR_OPERATION_FAILED;
 173         }
 174
 175         vconf_set_int(VCONFKEY_PM_CUSTOM_BRIGHTNESS_STATUS, VCONFKEY_PM_CUSTOM_BRIGHTNESS_ON);
 176         if (bat_state < VCONFKEY_SYSMAN_BAT_WARNING_LOW) {
 177                 DEVLOG("can not set brightness for low battery");
 178                 return DEVMAN_ERROR_NONE;
 179         }
 180
 181         if (vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_brt_state) != 0) {
 182                 DEVERR("Failed to get VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT value");
 183                 return DEVMAN_ERROR_OPERATION_FAILED;
 184         }
 185
 186         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_BRIGHTNESS, lcdnum);
 187         ret = device_set_property(DEVICE_TYPE_DISPLAY, cmd, val);
 188         if (ret < 0)
 189                 return ret;
 190
 191         if (auto_brt_state == SETTING_BRIGHTNESS_AUTOMATIC_ON) {
 192                 DEVLOG("Auto brightness will be paused");
 193                 vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_PAUSE);
 194         }
 195
 196         if (vconf_set_int(VCONFKEY_PM_CURRENT_BRIGHTNESS, val) != 0) {
 197                 DEVERR("Failed to set VCONFKEY_PM_CURRENT_BRIGHTNESS value");
 198         }
 199
 200         if (!disp_flag)
 201                 ret = display_register_postjob();
 202         if (ret == 0)
 203                 SET_FLAG(disp_flag, BRT_BIT);
 204         return DEVMAN_ERROR_NONE;
 205 }
 206
 207 API int device_release_brt_ctrl(display_num_t lcdnum)
 208 {
 209         int bat_state;
 210         int setting_val;
 211         int auto_brt_state;
 212         int charger_state;
 213         int brt_changed_state;
 214         int cmd;
 215         int ret;
 216
 217         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0) {
 218                 DEVERR("Failed to get VCONFKEY_SYSMAN_BATTERY_STATUS_LOW value");
 219                 return DEVMAN_ERROR_OPERATION_FAILED;
 220         }
 221
 222         if (vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &charger_state) != 0) {
 223                 DEVERR("Failed to get VCONFKEY_SYSMAN_CHARGER_STATUS value");
 224                 return DEVMAN_ERROR_OPERATION_FAILED;
 225         }
 226
 227         if (vconf_get_bool(VCONFKEY_PM_BRIGHTNESS_CHANGED_IN_LPM, &brt_changed_state) != 0) {
 228                 DEVERR("Failed to get VCONFKEY_PM_BRIGHTNESS_CHANGED_IN_LPM value");
 229                 return DEVMAN_ERROR_OPERATION_FAILED;
 230         }
 231
 232         vconf_set_int(VCONFKEY_PM_CUSTOM_BRIGHTNESS_STATUS, VCONFKEY_PM_CUSTOM_BRIGHTNESS_OFF);
 233         if (bat_state < VCONFKEY_SYSMAN_BAT_WARNING_LOW) {
 234                 DEVLOG("can not set brightness for low battery");
 235                 return DEVMAN_ERROR_NONE;
 236         }
 237
 238         if (vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &setting_val) != 0) {
 239                 DEVERR("Failed to get VCONFKEY_SETAPPL_LCD_BRIGHTNESS value");
 240                 return DEVMAN_ERROR_OPERATION_FAILED;
 241         }
 242
 243         if (vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_brt_state) != 0) {
 244                 DEVERR("Failed to get VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT value");
 245                 return DEVMAN_ERROR_OPERATION_FAILED;
 246         }
 247
 248         // check dim state
 249         if (bat_state == VCONFKEY_SYSMAN_BAT_WARNING_LOW &&
 250                 charger_state == VCONFKEY_SYSMAN_CHARGER_DISCONNECTED && !brt_changed_state) {
 251                 DEVLOG("batt warning low : brightness is not changed!");
 252                 COMBINE_DISP_CMD(cmd, PROP_DISPLAY_BRIGHTNESS, lcdnum);
 253                 device_set_property(DEVICE_TYPE_DISPLAY, cmd, 0);
 254                 return DEVMAN_ERROR_NONE;
 255         }
 256
 257         if (auto_brt_state == SETTING_BRIGHTNESS_AUTOMATIC_OFF) {
 258                 COMBINE_DISP_CMD(cmd, PROP_DISPLAY_BRIGHTNESS, lcdnum);
 259                 device_set_property(DEVICE_TYPE_DISPLAY, cmd, setting_val);
 260         } else if (auto_brt_state == SETTING_BRIGHTNESS_AUTOMATIC_PAUSE) {
 261                 DEVLOG("Auto brightness will be enable");
 262                 vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_ON);
 263         }
 264
 265         UNSET_FLAG(disp_flag, BRT_BIT);
 266         if (!disp_flag)
 267                 display_cancel_postjob();
 268         return DEVMAN_ERROR_NONE;
 269 }
 270
 271 API int device_get_max_brt(display_num_t lcdnum)
 272 {
 273         return DISPLAY_MAX_BRIGHTNESS;
 274 }
 275
 276 API int device_get_min_brt(display_num_t lcdnum)
 277 {
 278         return DISPLAY_MIN_BRIGHTNESS;
 279 }
 280
 281 API int device_get_display_gamma(display_num_t lcdnum)
 282 {
 283         DEVERR("Not support this api");
 284         return DEVMAN_ERROR_NOT_SUPPORTED;
 285 }
 286
 287 API int device_set_display_gamma(display_num_t lcdnum, display_gamma_t val)
 288 {
 289         DEVERR("Not support this api");
 290         return DEVMAN_ERROR_NOT_SUPPORTED;
 291 }
 292
 293 API int device_release_gamma_ctrl(display_num_t lcdnum, display_gamma_t org_val)
 294 {
 295         DEVERR("Not support this api");
 296         return DEVMAN_ERROR_NOT_SUPPORTED;
 297 }
 298
 299 API int device_get_display_count(void)
 300 {
 301         int val;
 302         int ret;
 303
 304         ret = device_get_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_DISPLAY_COUNT, &val);
 305         if (ret < 0)
 306                 return ret;
 307
 308         return val;
 309 }
 310
 311 API int device_get_image_enhance_mode(void)
 312 {
 313         int val;
 314         int ret;
 315
 316         ret = device_get_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_MODE, &val);
 317         if (ret < 0)
 318                 return ret;
 319
 320         return val;
 321 }
 322
 323 API int device_set_image_enhance_mode(int val)
 324 {
 325         int ret;
 326
 327         ret = device_set_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_MODE, val);
 328         if (ret < 0)
 329                 return ret;
 330
 331         return DEVMAN_ERROR_NONE;
 332 }
 333
 334 API int device_get_image_enhance_scenario(void)
 335 {
 336         int val;
 337         int ret;
 338
 339         ret = device_get_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_SCENARIO, &val);
 340         if (ret < 0)
 341                 return ret;
 342
 343         return val;
 344 }
 345
 346 API int device_set_image_enhance_scenario(int val)
 347 {
 348         int ret;
 349
 350         ret = device_set_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_SCENARIO, val);
 351         if (ret < 0)
 352                 return ret;
 353
 354         return DEVMAN_ERROR_NONE;
 355 }
 356
 357 API int device_get_image_enhance_tone(void)
 358 {
 359         int val;
 360         int ret;
 361
 362         ret = device_get_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_TONE, &val);
 363         if (ret < 0)
 364                 return ret;
 365
 366         return val;
 367 }
 368
 369 API int device_set_image_enhance_tone(int val)
 370 {
 371         int ret;
 372
 373         ret = device_set_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_TONE, val);
 374         if (ret < 0)
 375                 return ret;
 376
 377         return DEVMAN_ERROR_NONE;
 378 }
 379
 380 API int device_get_image_enhance_outdoor(void)
 381 {
 382         int val;
 383         int ret;
 384
 385         ret = device_get_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_OUTDOOR, &val);
 386         if (ret < 0)
 387                 return ret;
 388
 389         return val;
 390 }
 391
 392 API int device_set_image_enhance_outdoor(int val)
 393 {
 394         int ret;
 395
 396         ret = device_set_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_OUTDOOR, val);
 397         if (ret < 0)
 398                 return ret;
 399
 400         return DEVMAN_ERROR_NONE;
 401 }
 402
 403 API int device_get_image_enhance_info(void)
 404 {
 405         int val;
 406         int ret;
 407
 408         ret = device_get_property(DEVICE_TYPE_DISPLAY, PROP_DISPLAY_IMAGE_ENHANCE_INFO, &val);
 409         if (ret < 0)
 410                 return ret;
 411
 412         return val;
 413 }
 414
 415 API int device_get_led_brt(void)
 416 {
 417         int val;
 418         int ret;
 419
 420         ret = device_get_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, &val);
 421         if (ret < 0)
 422                 return ret;
 423
 424         return val;
 425 }
 426
 427 API int device_set_led_brt(int val)
 428 {
 429         int ret = -1;
 430
 431         ret = device_set_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, val);
 432         if (ret < 0)
 433                 return ret;
 434
 435         if (val == 0) {
 436                 UNSET_FLAG(disp_flag, LED_BIT);
 437                 if (!disp_flag)
 438                         display_cancel_postjob();
 439         } else {
 440                 if (!disp_flag)
 441                         ret = display_register_postjob();
 442                 if (ret == 0)
 443                         SET_FLAG(disp_flag, LED_BIT);
 444         }
 445
 446         return DEVMAN_ERROR_NONE;
 447 }
 448
 449 API int device_set_led_brt_without_noti(int val)
 450 {
 451         int ret;
 452
 453         ret = device_set_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, val);
 454         if (ret < 0)
 455                 return ret;
 456
 457         return DEVMAN_ERROR_NONE;
 458 }
 459
 460 API int device_get_max_led(void)
 461 {
 462         int val;
 463         int ret;
 464
 465         ret = device_get_property(DEVTYPE_LED, LED_PROP_MAX_BRIGHTNESS, &val);
 466         if (ret < 0)
 467                 return ret;
 468
 469         return val;
 470 }
 471
 472 API int device_get_acl_control_status(display_num_t num)
 473 {
 474         int val;
 475         int cmd;
 476         int ret;
 477
 478         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_ACL_CONTROL, num);
 479         ret = device_get_property(DEVICE_TYPE_DISPLAY, cmd, &val);
 480         if (ret < 0)
 481                 return ret;
 482
 483         return val;
 484 }
 485
 486 API int device_set_acl_control_status(display_num_t num, int val)
 487 {
 488         int cmd;
 489         int ret;
 490
 491         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_ACL_CONTROL, num);
 492         ret = device_set_property(DEVICE_TYPE_DISPLAY, cmd, val);
 493         if (ret < 0)
 494                 return ret;
 495
 496         return DEVMAN_ERROR_NONE;
 497 }