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
  25 #include "devman_internal.h"
  26 #include "device_engine.h"
  27 #include "devlog.h"
  28
  29 #define DISP_INDEX_BIT                          4
  30 #define COMBINE_DISP_CMD(cmd, prop, index)      (cmd = (prop | (index << DISP_INDEX_BIT)))
  31
  32 #define SET_FLAG(var, bit)              (var |= (1<<bit))
  33 #define UNSET_FLAG(var, bit)    (var &= (~(1<<bit)))
  34 #define BRT_BIT                 1
  35 #define GAMMA_BIT               2
  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         if (device_get_property
  44                         (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 capacity = 0, charge_state = 0;
  57         if(device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_CAPACITY, &capacity) < 0)
  58                 return -1;
  59
  60         /* If the capacity is 100 and charge state is 1, battery is not full */
  61         device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_CHARGE_NOW, &charge_state);
  62         if(capacity < 0 || capacity > 100) {
  63                 ERR("capacity value is wrong");
  64                 return -1;
  65         } else if(capacity == 100 && charge_state < 1) {
  66                 return 1;
  67         } else {
  68                 return 0;
  69         }
  70 }
  71
  72 API int device_get_battery_health(void)
  73 {
  74         int health = -1;
  75         if(device_get_property(DEVTYPE_POWERSUPPLY, POWER_SUPPLY_PROP_BATTERY_HEALTH, &health) < 0)
  76                 return -1;
  77         if(health < BAT_UNKNOWN || health > BAT_COLD) {
  78                 ERR("battery health value is wrong");
  79                 return -1;
  80         }
  81
  82         return health;
  83 }
  84
  85 API int device_get_display_brt(display_num_t lcdnum)
  86 {
  87         int val;
  88         int cmd;
  89
  90         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_BRIGHTNESS, lcdnum);
  91         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
  92                 return -1;
  93
  94         return val;
  95 }
  96
  97 API int device_set_display_brt(display_num_t lcdnum, int val)
  98 {
  99         int bat_state = -1;
 100         int ret = -1;
 101         int cmd;
 102
 103         if(vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0 || bat_state >= VCONFKEY_SYSMAN_BAT_WARNING_LOW ) {
 104                 COMBINE_DISP_CMD(cmd, DISPLAY_PROP_BRIGHTNESS, lcdnum);
 105                 if (device_set_property(DEVTYPE_DISPLAY0, cmd, val) < 0)
 106                         return -1;
 107         } else {
 108                 ERR("can not set brightness for low battery");
 109                 return -1;
 110         }
 111
 112         if (!disp_flag)
 113                 ret = display_register_postjob();
 114         if (ret == 0)
 115                 SET_FLAG(disp_flag, BRT_BIT);
 116         return 0;
 117 }
 118
 119 API int device_release_brt_ctrl(display_num_t lcdnum)
 120 {
 121         int setting_val=0;
 122         int bat_state=-1;
 123         int cmd;
 124
 125         if(vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state) != 0 || bat_state >= VCONFKEY_SYSMAN_BAT_WARNING_LOW ) {
 126                 if(vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &setting_val) != 0){
 127                         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_MAX_BRIGHTNESS, lcdnum);
 128                         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &setting_val) < 0)
 129                                 return -1;
 130                         setting_val=setting_val*0.7;
 131                 }
 132
 133                 COMBINE_DISP_CMD(cmd, DISPLAY_PROP_BRIGHTNESS, lcdnum);
 134                 if (device_set_property(DEVTYPE_DISPLAY0, cmd, setting_val) < 0)
 135                         return -1;
 136         } else {
 137                 ERR("can not set brightness for low battery");
 138                 return -1;
 139         }
 140
 141         UNSET_FLAG(disp_flag, BRT_BIT);
 142         if (!disp_flag)
 143                 display_cancel_postjob();
 144         return 0;
 145 }
 146
 147 API int device_get_max_brt(display_num_t lcdnum)
 148 {
 149         int val = -1;
 150         int cmd;
 151
 152         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_MAX_BRIGHTNESS, lcdnum);
 153         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 154                 return -1;
 155
 156         return val;
 157 }
 158
 159 API int device_get_display_gamma(display_num_t lcdnum)
 160 {
 161         int val = -1;
 162         int cmd;
 163
 164         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_GAMMA, lcdnum);
 165         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 166                 return -1;
 167
 168         return val;
 169 }
 170
 171 API int device_set_display_gamma(display_num_t lcdnum, display_gamma_t val)
 172 {
 173         int ret = -1;
 174         int cmd;
 175
 176         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_GAMMA, lcdnum);
 177         if (device_set_property(DEVTYPE_DISPLAY0, cmd, val) < 0)
 178                 return -1;
 179
 180         if (!disp_flag)
 181                 ret = display_register_postjob();
 182         if (ret == 0)
 183                 SET_FLAG(disp_flag, GAMMA_BIT);
 184
 185         return 0;
 186 }
 187
 188 API int device_release_gamma_ctrl(display_num_t lcdnum, display_gamma_t org_val)
 189 {
 190         int cmd;
 191
 192         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_GAMMA, lcdnum);
 193         if (device_set_property(DEVTYPE_DISPLAY0, cmd, org_val) < 0)
 194                 return -1;
 195
 196         UNSET_FLAG(disp_flag, GAMMA_BIT);
 197         if (!disp_flag)
 198                 display_cancel_postjob();
 199
 200         return 0;
 201 }
 202
 203 API int device_get_display_count(void)
 204 {
 205         int val = -1;
 206
 207         if (device_get_property
 208                         (DEVTYPE_DISPLAY0, DISPLAY_PROP_DISPLAY_COUNT, &val) < 0)
 209                 return -1;
 210
 211         return val;
 212 }
 213
 214 API int device_get_image_enhance_mode(void)
 215 {
 216         int val = -1;
 217
 218         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_MODE, &val) < 0)
 219                 return -1;
 220
 221         return val;
 222 }
 223
 224 API int device_set_image_enhance_mode(int val)
 225 {
 226         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_MODE, val) < 0)
 227                 return -1;
 228
 229         return 0;
 230 }
 231
 232 API int device_get_image_enhance_scenario(void)
 233 {
 234         int val = -1;
 235
 236         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_SCENARIO, &val) < 0)
 237                 return -1;
 238
 239         return val;
 240 }
 241
 242 API int device_set_image_enhance_scenario(int val)
 243 {
 244         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_SCENARIO, val) < 0)
 245                 return -1;
 246
 247         return 0;
 248 }
 249
 250 API int device_get_image_enhance_tone(void)
 251 {
 252         int val = -1;
 253
 254         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_TONE, &val) < 0)
 255                 return -1;
 256
 257         return val;
 258 }
 259
 260 API int device_set_image_enhance_tone(int val)
 261 {
 262         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_TONE, val) < 0)
 263                 return -1;
 264
 265         return 0;
 266 }
 267
 268 API int device_get_image_enhance_outdoor(void)
 269 {
 270         int val = -1;
 271
 272         if (device_get_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_OUTDOOR, &val) < 0)
 273                 return -1;
 274
 275         return val;
 276 }
 277
 278 API int device_set_image_enhance_outdoor(int val)
 279 {
 280         if (device_set_property(DEVTYPE_DISPLAY0, DISPLAY_PROP_IMAGE_ENHANCE_OUTDOOR, val) < 0)
 281                 return -1;
 282
 283         return 0;
 284 }
 285
 286 API int device_power_suspend(void)
 287 {
 288         if (device_set_property(DEVTYPE_POWER, POWER_PROP_STATE, 0) < 0)
 289                 return -1;
 290
 291         return 0;
 292 }
 293
 294 API int device_get_led_brt(void)
 295 {
 296         int val;
 297
 298         if (device_get_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, &val) < 0)
 299                 return -1;
 300
 301         return val;
 302 }
 303
 304 API int device_set_led_brt(int val)
 305 {
 306         int ret=-1;
 307         if (device_set_property(DEVTYPE_LED, LED_PROP_BRIGHTNESS, val) < 0)
 308                 return -1;
 309
 310         if (val == 0) {
 311                 UNSET_FLAG(disp_flag, LED_BIT);
 312                 if (!disp_flag)
 313                         display_cancel_postjob();
 314         } else {
 315                 if (!disp_flag)
 316                         ret = display_register_postjob();
 317                 if (ret == 0)
 318                         SET_FLAG(disp_flag, LED_BIT);
 319         }
 320         return 0;
 321 }
 322
 323 API int device_get_max_led(void)
 324 {
 325         int val = -1;
 326
 327         if (device_get_property(DEVTYPE_LED, LED_PROP_MAX_BRIGHTNESS, &val) < 0)
 328                 return -1;
 329
 330         return val;
 331 }
 332
 333
 334 int device_get_acl_control_status(display_num_t num)
 335 {
 336         int val = -1;
 337         int cmd;
 338
 339         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_ACL_CONTROL, num);
 340         if (device_get_property(DEVTYPE_DISPLAY0, cmd, &val) < 0)
 341                 return -1;
 342
 343         return val;
 344 }
 345
 346 int device_set_acl_control_status(display_num_t num, int val)
 347 {
 348         int cmd;
 349
 350         COMBINE_DISP_CMD(cmd, DISPLAY_PROP_ACL_CONTROL, num);
 351         if (device_set_property(DEVTYPE_DISPLAY0, cmd, val) < 0)
 352                 return -1;
 353
 354         return 0;
 355 }