src/power/doze.c

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 #include <vconf.h>
  19
  20 #include "doze.h"
  21 #include "core/log.h"
  22 #include "shared/device-notifier.h"
  23 #include "display/core.h"
  24
  25 #define DOZE_DISABLED 0
  26 #define DOZE_ENABLED  1
  27 static int doze_mode; /* doze from setting */
  28
  29 enum doze_level {
  30         DOZE_LEVEL_0 = 0, /* doze off mode */
  31         DOZE_LEVEL_1,
  32         DOZE_LEVEL_MAX,
  33 };
  34 static enum doze_level doze_level;
  35 static int display_state;
  36 static bool doze_initialized = false;
  37
  38 int doze_pmqos_request(int req)
  39 {
  40         int ret = 0;
  41
  42         ret = gdbus_call_async(PASS_BUS_NAME,
  43                                         PASS_PATH_PMQOS,
  44                                         PASS_INTERFACE_PMQOS,
  45                                         PASS_METHOD_SET_SCENARIO,
  46                                         g_variant_new("(si)", "Doze", req));
  47         if (ret < 0)
  48                 _E("Failed to request pmqos: %d", ret);
  49
  50         return ret;
  51 }
  52
  53 static int change_doze_level(enum doze_level level)
  54 {
  55         int ret;
  56
  57         if (level < DOZE_LEVEL_0 || level >= DOZE_LEVEL_MAX) {
  58                 _E("Invalid doze level %d.", level);
  59                 return -EINVAL;
  60         }
  61
  62         if (doze_level == level)
  63                 return 0;
  64
  65         _D("Change doze level, %d -> %d.", doze_level, level);
  66         doze_level = level;
  67
  68         ret = vconf_set_int(VCONFKEY_SYSMAN_DOZE_MODE_LEVEL, doze_level);
  69         if (ret < 0) {
  70                 _E("Failed to set doze level, %d.", vconf_get_ext_errno());
  71                 return ret;
  72         }
  73
  74         return 0;
  75 }
  76
  77 static void _enter_doze(void)
  78 {
  79         /* already in doze mode */
  80         if (doze_level >= DOZE_LEVEL_1)
  81                 return;
  82
  83         _D("Entering doze mode.");
  84         change_doze_level(DOZE_LEVEL_1);
  85         doze_pmqos_request(DOZE_PMQOS_START);
  86 }
  87
  88 static void _leave_doze(void)
  89 {
  90         /* already not in doze mode */
  91         if (doze_level == DOZE_LEVEL_0)
  92                 return;
  93
  94         _D("Leaving doze mode.");
  95         change_doze_level(DOZE_LEVEL_0);
  96         doze_pmqos_request(DOZE_PMQOS_STOP);
  97 }
  98
  99 void enter_doze(void)
 100 {
 101         if (!doze_initialized)
 102                 return;
 103
 104         if (doze_mode == DOZE_DISABLED)
 105                 return;
 106
 107         _enter_doze();
 108 }
 109
 110 void leave_doze(void)
 111 {
 112         if (!doze_initialized)
 113                 return;
 114
 115         if (doze_mode == DOZE_DISABLED)
 116                 return;
 117
 118         _leave_doze();
 119 }
 120
 121 static int display_changed_cb(void *data)
 122 {
 123         display_state = *(int *)data;
 124
 125         return 0;
 126 }
 127
 128 static void setting_doze_mode_cb(keynode_t *key, void *data)
 129 {
 130         int val;
 131
 132         val = vconf_keynode_get_bool(key);
 133
 134         if (val < 0) {
 135                 _E("Failed to get vconf value for doze, %d.", vconf_get_ext_errno());
 136                 return;
 137         }
 138
 139         if (doze_mode == val)
 140                 return;
 141
 142         doze_mode = val;
 143
 144         if (!doze_initialized)
 145                 return;
 146
 147         if (doze_mode == DOZE_DISABLED) {
 148                 _leave_doze();
 149                 _D("Doze mode disabled.");
 150         } else if (doze_mode == DOZE_ENABLED) {
 151                 _D("Doze mode enabled.");
 152                 if (display_state == S_LCDOFF || display_state == S_SLEEP)
 153                         _enter_doze();
 154         }
 155
 156 }
 157
 158 int doze_init(void)
 159 {
 160         int ret;
 161
 162         ret = vconf_get_bool(VCONFKEY_SETAPPL_DOZE_MODE, &doze_mode);
 163         if (ret < 0) {
 164                 _E("Failed to get vconf value for doze, %d.", vconf_get_ext_errno());
 165                 return ret;
 166         }
 167
 168         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DOZE_MODE, setting_doze_mode_cb, NULL);
 169         if (ret < 0) {
 170                 _E("Failed to register vconf notify.");
 171                 return ret;
 172         }
 173
 174         doze_level = DOZE_LEVEL_0;
 175
 176         register_notifier(DEVICE_NOTIFIER_LCD, display_changed_cb);
 177
 178         doze_initialized = true;
 179         _D("Doze mode initialized. doze_mode: %d.", doze_mode);
 180
 181         return 0;
 182 }
 183
 184 int doze_exit(void)
 185 {
 186         doze_initialized = false;
 187
 188         unregister_notifier(DEVICE_NOTIFIER_LCD, display_changed_cb);
 189
 190         return 0;
 191 }