pm_llinterface.c

   1 /*
   2  * power-manager
   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 <stdio.h>
  20 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <limits.h>
  28 #include <device-node.h>
  29 #include <vconf.h>
  30
  31 #include "pm_llinterface.h"
  32 #include "util.h"
  33 #include "pm_conf.h"
  34 #include "pm_core.h"
  35
  36 #define DISP_INDEX_BIT                      4
  37 #define COMBINE_DISP_CMD(cmd, prop, index)  (cmd = (prop | (index << DISP_INDEX_BIT)))
  38
  39 typedef struct _PMSys PMSys;
  40 struct _PMSys {
  41         int def_brt;
  42         int dim_brt;
  43
  44         int (*sys_power_state) (PMSys *, int);
  45         int (*bl_onoff) (PMSys *, int);
  46         int (*bl_brt) (PMSys *, int);
  47         int (*sys_get_battery_capacity) (PMSys *p);
  48         int (*sys_get_battery_capacity_raw) (PMSys *p);
  49         int (*sys_get_battery_charge_full) (PMSys *p);
  50 };
  51
  52 static PMSys *pmsys;
  53
  54 #ifdef ENABLE_X_LCD_ONOFF
  55 #include "pm_x_lcd_onoff.c"
  56 static bool x_dpms_enable = false;
  57 #endif
  58
  59 /*
  60 static void _update_curbrt(PMSys *p)
  61 {
  62         int power_saving_stat = -1;
  63         int power_saving_display_stat = -1;
  64         vconf_get_bool(VCONFKEY_SETAPPL_PWRSV_SYSMODE_STATUS, &power_saving_stat);
  65         if (power_saving_stat == 1)
  66                 vconf_get_bool(VCONFKEY_SETAPPL_PWRSV_CUSTMODE_DISPLAY, &power_saving_display_stat);
  67         if (power_saving_display_stat != 1)
  68                 power_saving_display_stat = 0;
  69         plugin_intf->OEM_sys_get_backlight_brightness(DEFAULT_DISPLAY, &(p->def_brt), power_saving_display_stat);
  70 }
  71 */
  72
  73 static int _bl_onoff(PMSys *p, int onoff)
  74 {
  75         int cmd;
  76         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_ONOFF, DEFAULT_DISPLAY);
  77         return device_set_property(DEVICE_TYPE_DISPLAY, cmd, onoff);
  78 }
  79
  80 static int _bl_brt(PMSys *p, int brt)
  81 {
  82         int cmd;
  83         int ret;
  84         int old_brt;
  85
  86         COMBINE_DISP_CMD(cmd, PROP_DISPLAY_BRIGHTNESS, DEFAULT_DISPLAY);
  87         ret = device_get_property(DEVICE_TYPE_DISPLAY, cmd, &old_brt);
  88
  89         /* Update new brightness to vconf */
  90         if (!ret && (brt != old_brt))
  91                 vconf_set_int(VCONFKEY_PM_CURRENT_BRIGHTNESS, brt);
  92
  93         /* Update device brightness */
  94         ret = device_set_property(DEVICE_TYPE_DISPLAY, cmd, brt);
  95
  96         LOGERR("set brightness %d,%d %d", DEFAULT_DISPLAY, brt, ret);
  97
  98         return ret;
  99 }
 100
 101 static int _sys_power_state(PMSys *p, int state)
 102 {
 103         if (state < POWER_STATE_SUSPEND || state > POWER_STATE_POST_RESUME)
 104                 return 0;
 105         return device_set_property(DEVICE_TYPE_POWER, PROP_POWER_STATE, state);
 106 }
 107
 108 static int _sys_get_battery_capacity(PMSys *p)
 109 {
 110         int value = 0;
 111         int ret = -1;
 112
 113         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY, &value);
 114         if(ret < 0)
 115                 return -1;
 116
 117         if(value < 0)
 118                 return 0;
 119
 120         return value;
 121 }
 122
 123 static int _sys_get_battery_capacity_raw(PMSys *p)
 124 {
 125         int value = 0;
 126         int ret = -1;
 127
 128         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CAPACITY_RAW, &value);
 129         if(ret < 0)
 130                 return -1;
 131
 132         if(value < 0)
 133                 return 0;
 134
 135         return value;
 136 }
 137
 138 static int _sys_get_battery_charge_full(PMSys *p)
 139 {
 140         int value = 0;
 141         int ret = -1;
 142
 143         ret = device_get_property(DEVICE_TYPE_POWER, PROP_POWER_CHARGE_FULL, &value);
 144         if(ret < 0)
 145                 return -1;
 146
 147         if(value < 0)
 148                 return 0;
 149
 150         return value;
 151 }
 152
 153 static void _init_bldev(PMSys *p, unsigned int flags)
 154 {
 155         int ret;
 156         //_update_curbrt(p);
 157         p->bl_brt = _bl_brt;
 158         p->bl_onoff = _bl_onoff;
 159 #ifdef ENABLE_X_LCD_ONOFF
 160         if (flags & FLAG_X_DPMS) {
 161                 p->bl_onoff = pm_x_set_lcd_backlight;
 162                 x_dpms_enable = true;
 163         }
 164 #endif
 165 }
 166
 167 static void _init_pmsys(PMSys *p)
 168 {
 169         char tmp[NAME_MAX];
 170
 171         get_env(EN_SYS_DIMBRT, tmp, sizeof(tmp));
 172
 173         p->dim_brt = atoi(tmp);
 174         p->sys_power_state = _sys_power_state;
 175         p->sys_get_battery_capacity = _sys_get_battery_capacity;
 176         p->sys_get_battery_capacity_raw = _sys_get_battery_capacity_raw;
 177         p->sys_get_battery_charge_full = _sys_get_battery_charge_full;
 178 }
 179
 180 int system_suspend()
 181 {
 182         LOGINFO("enter system suspend");
 183         if (pmsys && pmsys->sys_power_state)
 184                 return pmsys->sys_power_state(pmsys, POWER_STATE_SUSPEND);
 185
 186         return 0;
 187 }
 188
 189 int system_pre_suspend()
 190 {
 191         LOGINFO("enter system pre suspend");
 192         if (pmsys && pmsys->sys_power_state)
 193                 return pmsys->sys_power_state(pmsys, POWER_STATE_PRE_SUSPEND);
 194
 195         return 0;
 196 }
 197
 198 int system_post_resume()
 199 {
 200         LOGINFO("enter system post resume");
 201         if (pmsys && pmsys->sys_power_state)
 202                 return pmsys->sys_power_state(pmsys, POWER_STATE_POST_RESUME);
 203
 204         return 0;
 205 }
 206
 207 int battery_capacity()
 208 {
 209         if (pmsys && pmsys->sys_get_battery_capacity)
 210                 return pmsys->sys_get_battery_capacity(pmsys);
 211
 212         return 0;
 213 }
 214
 215 int battery_capacity_raw()
 216 {
 217         if (pmsys && pmsys->sys_get_battery_capacity_raw)
 218                 return pmsys->sys_get_battery_capacity_raw(pmsys);
 219
 220         return 0;
 221 }
 222
 223 int battery_charge_full()
 224 {
 225         if (pmsys && pmsys->sys_get_battery_charge_full)
 226                 return pmsys->sys_get_battery_charge_full(pmsys);
 227
 228         return 0;
 229 }
 230
 231 int backlight_on()
 232 {
 233         LOGINFO("LCD on");
 234
 235         if (pmsys && pmsys->bl_onoff) {
 236                 return pmsys->bl_onoff(pmsys, STATUS_ON);
 237         }
 238
 239         return 0;
 240 }
 241
 242 int backlight_off()
 243 {
 244         LOGINFO("LCD off");
 245
 246         if (pmsys && pmsys->bl_onoff) {
 247 #ifdef ENABLE_X_LCD_ONOFF
 248                 if (x_dpms_enable == false)
 249 #endif
 250                         usleep(30000);
 251                 return pmsys->bl_onoff(pmsys, STATUS_OFF);
 252         }
 253
 254         return 0;
 255 }
 256
 257 int backlight_dim()
 258 {
 259         int ret = 0;
 260
 261         if (pmsys && pmsys->bl_brt) {
 262                 ret = pmsys->bl_brt(pmsys, pmsys->dim_brt);
 263         }
 264         return ret;
 265 }
 266
 267 int backlight_restore()
 268 {
 269         int ret = 0;
 270         int val = -1;
 271
 272         ret = vconf_get_int(VCONFKEY_PM_CUSTOM_BRIGHTNESS_STATUS, &val);
 273         if (ret == 0 && val == VCONFKEY_PM_CUSTOM_BRIGHTNESS_ON) {
 274                 LOGINFO("custom brightness mode! brt no restored");
 275                 return 0;
 276         }
 277         if ((status_flag & PWRSV_FLAG) && !(status_flag & BRTCH_FLAG))
 278                 ret = backlight_dim();
 279         else if (pmsys && pmsys->bl_brt)
 280                 ret = pmsys->bl_brt(pmsys, pmsys->def_brt);
 281
 282         return ret;
 283 }
 284
 285 int set_default_brt(int level)
 286 {
 287         if (level < PM_MIN_BRIGHTNESS || level > PM_MAX_BRIGHTNESS)
 288                 level = PM_DEFAULT_BRIGHTNESS;
 289         pmsys->def_brt = level;
 290
 291         return 0;
 292 }
 293
 294 inline int check_wakeup_src(void)
 295 {
 296         /*  TODO if nedded.
 297          * return wackeup source. user input or device interrupts? (EVENT_DEVICE or EVENT_INPUT)
 298          */
 299         return EVENT_DEVICE;
 300 }
 301
 302 int init_sysfs(unsigned int flags)
 303 {
 304         int ret;
 305
 306         pmsys = (PMSys *) malloc(sizeof(PMSys));
 307         if (pmsys == NULL) {
 308                 LOGERR("Not enough memory to alloc PM Sys");
 309                 return -1;
 310         }
 311
 312         memset(pmsys, 0x0, sizeof(PMSys));
 313
 314         _init_pmsys(pmsys);
 315         _init_bldev(pmsys, flags);
 316
 317         if (pmsys->bl_onoff == NULL && pmsys->sys_power_state == NULL) {
 318                 LOGERR
 319                     ("We have no managable resource to reduce the power consumption");
 320                 return -1;
 321         }
 322
 323         return 0;
 324 }
 325
 326 int exit_sysfs()
 327 {
 328         int fd = -1;
 329
 330         fd = open("/tmp/sem.pixmap_1", O_RDONLY);
 331         if (fd == -1) {
 332                 LOGERR("X server disable");
 333                 backlight_on();
 334         }
 335
 336         backlight_restore();
 337         free(pmsys);
 338         pmsys = NULL;
 339         if (fd != -1)
 340                 close(fd);
 341
 342         return 0;
 343 }