src/if_legacy.c

   1 /*
   2  *  devman
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: DongGi Jang <dg0402.jang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20 */
  21
  22
  23 #include <vconf.h>
  24 #include <errno.h>
  25
  26 #include "devman_internal.h"
  27 #include "device_engine.h"
  28 #include "devlog.h"
  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 GAMMA_BIT                               2
  37 #define LED_BIT                                 4
  38
  39 static unsigned int disp_flag = 0x0;
  40
  41 API int device_get_battery_pct(void)
  42 {
  43         int val;
  44         if (device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_CAPACITY, &val) < 0)
  45                 return -1;
  46         if (val < 0 || val > 100) {
  47                 ERR("capacity value is wrong");
  48                 return -1;
  49         }
  50
  51         return val;
  52 }
  53
  54 API int device_is_battery_full(void)
  55 {
  56         int charge_full = 0;
  57         if (device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_CHARGE_FULL, &charge_full) < 0)
  58                 return -1;
  59
  60         if (charge_full != 0 && charge_full != 1) {
  61                 ERR("charge_full value is wrong");
  62                 return -1;
  63         }
  64
  65         return charge_full;
  66 }
  67
  68 API int device_get_battery_health(void)
  69 {
  70         int health = -1;
  71         if (device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_BATTERY_HEALTH, &health) < 0)
  72                 return -1;
  73         if (health < BAT_UNKNOWN || health > BAT_COLD) {
  74                 ERR("battery health value is wrong");
  75                 return -1;
  76         }
  77
  78         return health;
  79 }
  80
  81 API int device_get_battery_pct_raw(void)
  82 {
  83         int val;
  84         int ret = -1;
  85
  86         ret = device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_CAPACITY_RAW, &val);
  87         if (ret < 0)
  88                 return ret;
  89
  90         if (val > 10000)
  91                 return 10000;
  92         return val;
  93 }
  94
  95 API int device_get_display_brt(display_num_t lcdnum)
  96 {
  97         int val;
  98         int cmd;
  99
 100         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_BRIGHTNESS, lcdnum);
 101         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 102                 return -1;
 103
 104         return val;
 105 }
 106
 107 API int device_set_display_brt(display_num_t lcdnum, int val)
 108 {
 109         int bat_state = -1;
 110         int auto_brightness_state = -1;
 111         int ret = -1;
 112         int cmd;
 113
 114         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0 || bat_state >= VCONFKEY_SYSMAN_BAT_WARNING_LOW ) {
 115                 COMBINE_DISP_CMD(cmd, DISPLAY_PROP_BRIGHTNESS, lcdnum);
 116                 if (device_set_property(DEVTYPE_DISPLAY0, cmd, val) < 0)
 117                         return -1;
 118         } else {
 119                 ERR("can not set brightness for low battery");
 120                 return -1;
 121         }
 122
 123         if (vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_brightness_state) == 0) {
 124                 if (auto_brightness_state == SETTING_BRIGHTNESS_AUTOMATIC_ON) {
 125                         DBG("Auto brightness is paused");
 126                         vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_PAUSE);
 127                 }
 128         }
 129
 130         if (!disp_flag)
 131                 ret = display_register_postjob();
 132         if (ret == 0)
 133                 SET_FLAG(disp_flag, BRT_BIT);
 134         return 0;
 135 }
 136
 137 API int device_release_brt_ctrl(display_num_t lcdnum)
 138 {
 139         int setting_val=0;
 140         int bat_state=-1;
 141         int auto_brightness_state = -1;
 142         int cmd;
 143
 144         if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0 || bat_state >= VCONFKEY_SYSMAN_BAT_WARNING_LOW ) {
 145                 if(vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &setting_val) != 0) {
 146                         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_MAX_BRIGHTNESS, lcdnum);
 147                         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &setting_val) < 0)
 148                                 return -1;
 149                         setting_val = setting_val * 0.7;
 150                 }
 151
 152                 COMBINE_DISP_CMD(cmd, DISPLAY_PROP_BRIGHTNESS, lcdnum);
 153                 if (device_set_property(DEVTYPE_DISPLAY0, cmd, setting_val) < 0)
 154                         return -1;
 155         }
 156
 157         if (vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_brightness_state) == 0) {
 158                 if (auto_brightness_state == SETTING_BRIGHTNESS_AUTOMATIC_PAUSE) {
 159                         DBG("Auto brightness is enable");
 160                         vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_ON);
 161                 }
 162         }
 163
 164         UNSET_FLAG(disp_flag, BRT_BIT);
 165         if (!disp_flag)
 166                 display_cancel_postjob();
 167         return 0;
 168 }
 169
 170 API int device_get_min_brt(display_num_t lcdnum)
 171 {
 172         int val = -1;
 173         int cmd;
 174
 175         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_MIN_BRIGHTNESS, lcdnum);
 176         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 177                 return -1;
 178
 179         return val;
 180 }
 181
 182 API int device_get_max_brt(display_num_t lcdnum)
 183 {
 184         int val = -1;
 185         int cmd;
 186
 187         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_MAX_BRIGHTNESS, lcdnum);
 188         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 189                 return -1;
 190
 191         return val;
 192 }
 193
 194 API int device_get_display_gamma(display_num_t lcdnum)
 195 {
 196         int val = -1;
 197         int cmd;
 198
 199         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_GAMMA, lcdnum);
 200         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 201                 return -1;
 202
 203         return val;
 204 }
 205
 206 API int device_set_display_gamma(display_num_t lcdnum, display_gamma_t val)
 207 {
 208         int ret = -1;
 209         int cmd;
 210
 211         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_GAMMA, lcdnum);
 212         if (device_set_property(DEVTYPE_DISPLAY0, cmd, val) < 0)
 213                 return -1;
 214
 215         if (!disp_flag)
 216                 ret = display_register_postjob();
 217         if (ret == 0)
 218                 SET_FLAG(disp_flag, GAMMA_BIT);
 219
 220         return 0;
 221 }
 222
 223 API int device_release_gamma_ctrl(display_num_t lcdnum, display_gamma_t org_val)
 224 {
 225         int cmd;
 226
 227         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_GAMMA, lcdnum);
 228         if (device_set_property(DEVTYPE_DISPLAY0, cmd, org_val) < 0)
 229                 return -1;
 230
 231         UNSET_FLAG(disp_flag, GAMMA_BIT);
 232         if (!disp_flag)
 233                 display_cancel_postjob();
 234
 235         return 0;
 236 }
 237
 238 API int device_get_display_count(void)
 239 {
 240         int val = -1;
 241
 242         if (device_get_property
 243             (DEVTYPE_DISPLAY0, DISPLAY_PROP_DISPLAY_COUNT, &val) < 0)
 244                 return -1;
 245
 246         return val;
 247 }
 248
 249 API int device_get_image_enhance_mode(void)
 250 {
 251         int val = -1;
 252
 253         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_MODE, &val) < 0)
 254                 return -1;
 255
 256         return val;
 257 }
 258
 259 API int device_set_image_enhance_mode(int val)
 260 {
 261         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_MODE, val) < 0)
 262                 return -1;
 263
 264         return 0;
 265 }
 266
 267 API int device_get_image_enhance_scenario(void)
 268 {
 269         int val = -1;
 270
 271         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_SCENARIO, &val) < 0)
 272                 return -1;
 273
 274         return val;
 275 }
 276
 277 API int device_set_image_enhance_scenario(int val)
 278 {
 279         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_SCENARIO, val) < 0)
 280                 return -1;
 281
 282         return 0;
 283 }
 284
 285 API int device_get_image_enhance_tone(void)
 286 {
 287         int val = -1;
 288
 289         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_TONE, &val) < 0)
 290                 return -1;
 291
 292         return val;
 293 }
 294
 295 API int device_set_image_enhance_tone(int val)
 296 {
 297         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_TONE, val) < 0)
 298                 return -1;
 299
 300         return 0;
 301 }
 302
 303 API int device_get_image_enhance_outdoor(void)
 304 {
 305         int val = -1;
 306
 307         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_OUTDOOR, &val) < 0)
 308                 return -1;
 309
 310         return val;
 311 }
 312
 313 API int device_set_image_enhance_outdoor(int val)
 314 {
 315         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_OUTDOOR, val) < 0)
 316                 return -1;
 317
 318         return 0;
 319 }
 320
 321 API int device_get_image_enhance_info(void)
 322 {
 323         int val = -1;
 324
 325         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_INFO, &val) < 0)
 326                 return -1;
 327
 328         return val;
 329 }
 330
 331 API int device_power_suspend(void)
 332 {
 333         if (device_set_property(DEVTYPE_POWER, POWER_PROP_STATE, 0) < 0)
 334                 return -1;
 335
 336         return 0;
 337 }
 338
 339 API int device_get_led_brt(void)
 340 {
 341         int val;
 342         int ret = -1;
 343
 344         ret = device_get_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, &val);
 345         if (ret < 0)
 346                 return ret;
 347
 348         return val;
 349 }
 350
 351 API int device_set_led_brt(int val)
 352 {
 353         int ret = -1;
 354
 355         ret = device_set_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, val);
 356         if (ret < 0)
 357                 return ret;
 358
 359         if (val == 0) {
 360                 UNSET_FLAG(disp_flag, LED_BIT);
 361                 if (!disp_flag)
 362                         display_cancel_postjob();
 363         } else {
 364                 if (!disp_flag)
 365                         ret = display_register_postjob();
 366                 if (ret == 0)
 367                         SET_FLAG(disp_flag, LED_BIT);
 368         }
 369         return 0;
 370 }
 371
 372 API int device_get_max_led(void)
 373 {
 374         int val = -1;
 375         int ret = -1;
 376
 377         ret = device_get_property(DEVTYPE_LED, LED_PROP_MAX_BRIGHTNESS, &val);
 378         if (ret < 0)
 379                 return ret;
 380
 381         return val;
 382 }
 383
 384 API int device_get_acl_control_status(display_num_t num)
 385 {
 386         int val = -1;
 387         int cmd;
 388
 389         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_ACL_CONTROL, num);
 390         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 391                 return -1;
 392
 393         return val;
 394 }
 395
 396 API int device_set_acl_control_status(display_num_t num, int val)
 397 {
 398         int cmd;
 399
 400         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_ACL_CONTROL, num);
 401         if (device_set_property(DEVTYPE_DISPLAY0, cmd, val) < 0)
 402                 return -1;
 403
 404         return 0;
 405 }