src/power/power.h

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2022 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
  19 #ifndef __POWER_STATE_MANAGER_H__
  20 #define __POWER_STATE_MANAGER_H__
  21
  22 #include <stdio.h>
  23 #include <stdint.h>
  24 #include <glib.h>
  25
  26 #include <libsyscommon/ini-parser.h>
  27
  28 #include "shared/log-macro.h"
  29 #include "shared/device-notifier.h"
  30
  31 enum {
  32         DEVICED_POWER_STATE_MIN_INDEX,
  33         DEVICED_POWER_STATE_START_INDEX = DEVICED_POWER_STATE_MIN_INDEX,
  34         DEVICED_POWER_STATE_NORMAL_INDEX,
  35         DEVICED_POWER_STATE_SLEEP_INDEX,
  36         DEVICED_POWER_STATE_POWEROFF_INDEX,
  37         DEVICED_POWER_STATE_REBOOT_INDEX,
  38         DEVICED_POWER_STATE_EXIT_INDEX,
  39         DEVICED_POWER_STATE_MAX_INDEX,
  40
  41         DEVICED_POWER_TRANSIENT_STATE_MIN_INDEX,
  42         DEVICED_POWER_TRANSIENT_STATE_RESUMING_EARLY_INDEX = DEVICED_POWER_TRANSIENT_STATE_MIN_INDEX,
  43         DEVICED_POWER_TRANSIENT_STATE_RESUMING_INDEX,
  44         DEVICED_POWER_TRANSIENT_STATE_RESUMING_LATE_INDEX,
  45         DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_EARLY_INDEX,
  46         DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_INDEX,
  47         DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_LATE_INDEX,
  48         DEVICED_POWER_TRANSIENT_STATE_MAX_INDEX,
  49 };
  50
  51 #define DEVICED_POWER_STATE_UNDEFINED                   (0)
  52
  53 #define DEVICED_POWER_STATE_START                       (1ULL << DEVICED_POWER_STATE_START_INDEX)
  54 #define DEVICED_POWER_STATE_NORMAL                      (1ULL << DEVICED_POWER_STATE_NORMAL_INDEX)
  55 #define DEVICED_POWER_STATE_SLEEP                       (1ULL << DEVICED_POWER_STATE_SLEEP_INDEX)
  56 #define DEVICED_POWER_STATE_POWEROFF                    (1ULL << DEVICED_POWER_STATE_POWEROFF_INDEX)
  57 #define DEVICED_POWER_STATE_REBOOT                      (1ULL << DEVICED_POWER_STATE_REBOOT_INDEX)
  58 #define DEVICED_POWER_STATE_EXIT                        (1ULL << DEVICED_POWER_STATE_EXIT_INDEX)
  59 #define DEVICED_POWER_STATE_ALL                         ((1ULL << DEVICED_POWER_STATE_MAX_INDEX) - (1ULL << DEVICED_POWER_STATE_MIN_INDEX))
  60
  61 #define DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_EARLY  (1ULL << DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_EARLY_INDEX)
  62 #define DEVICED_POWER_TRANSIENT_STATE_SUSPENDING        (1ULL << DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_INDEX)
  63 #define DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_LATE   (1ULL << DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_LATE_INDEX)
  64 #define DEVICED_POWER_TRANSIENT_STATE_RESUMING_EARLY    (1ULL << DEVICED_POWER_TRANSIENT_STATE_RESUMING_EARLY_INDEX)
  65 #define DEVICED_POWER_TRANSIENT_STATE_RESUMING          (1ULL << DEVICED_POWER_TRANSIENT_STATE_RESUMING_INDEX)
  66 #define DEVICED_POWER_TRANSIENT_STATE_RESUMING_LATE     (1ULL << DEVICED_POWER_TRANSIENT_STATE_RESUMING_LATE_INDEX)
  67
  68 #define DEVICED_POWER_STATE_INDEX(state)                (__builtin_ctzll(state))
  69
  70 struct trans_info {
  71         uint64_t curr;
  72         uint64_t next;
  73         int reason;
  74         void *data;
  75 };
  76
  77 void power_state_manager_init(void *data);
  78
  79 static inline uint64_t convert_action_string_to_power_state(const char *str)
  80 {
  81         if (MATCH(str, "start"))
  82                 return DEVICED_POWER_STATE_START;
  83         else if (MATCH(str, "sleep"))
  84                 return DEVICED_POWER_STATE_SLEEP;
  85         else if (MATCH(str, "normal"))
  86                 return DEVICED_POWER_STATE_NORMAL;
  87         else if (MATCH(str, "poweroff"))
  88                 return DEVICED_POWER_STATE_POWEROFF;
  89         else if (MATCH(str, "reboot"))
  90                 return DEVICED_POWER_STATE_REBOOT;
  91         else if (MATCH(str, "exit"))
  92                 return DEVICED_POWER_STATE_EXIT;
  93         else if (MATCH(str, "current"))
  94                 return DEVICED_POWER_STATE_ALL;
  95
  96         _W("Invalid power state=%s", str);
  97
  98         return DEVICED_POWER_STATE_UNDEFINED;
  99 }
 100
 101 static inline const char *state_name(uint64_t state)
 102 {
 103         if (state == DEVICED_POWER_STATE_START)
 104                 return "POWER_STATE_START";
 105         if (state == DEVICED_POWER_STATE_NORMAL)
 106                 return "POWER_STATE_NORMAL";
 107         if (state == DEVICED_POWER_STATE_SLEEP)
 108                 return "POWER_STATE_SLEEP";
 109         if (state == DEVICED_POWER_STATE_POWEROFF)
 110                 return "POWER_STATE_POWEROFF";
 111         if (state == DEVICED_POWER_STATE_REBOOT)
 112                 return "POWER_STATE_REBOOT";
 113         if (state == DEVICED_POWER_STATE_EXIT)
 114                 return "POWER_STATE_EXIT";
 115         if (state == DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_EARLY)
 116                 return "POWER_TRANSIENT_STATE_SUSPENDING_EARLY";
 117         if (state == DEVICED_POWER_TRANSIENT_STATE_SUSPENDING)
 118                 return "POWER_TRANSIENT_STATE_SUSPENDING";
 119         if (state == DEVICED_POWER_TRANSIENT_STATE_SUSPENDING_LATE)
 120                 return "POWER_TRANSIENT_STATE_SUSPENDING_LATE";
 121         if (state == DEVICED_POWER_TRANSIENT_STATE_RESUMING_EARLY)
 122                 return "POWER_TRANSIENT_STATE_RESUMING_EARLY";
 123         if (state == DEVICED_POWER_TRANSIENT_STATE_RESUMING)
 124                 return "POWER_TRANSIENT_STATE_RESUMING";
 125         if (state == DEVICED_POWER_TRANSIENT_STATE_RESUMING_LATE)
 126                 return "POWER_TRANSIENT_STATE_RESUMING_LATE";
 127         if (state == DEVICED_POWER_STATE_ALL)
 128                 return "POWER_STATE_ALL";
 129
 130         return "POWER_STATE_INVALID";
 131 }
 132
 133 static inline int is_poweroff_state(uint64_t state)
 134 {
 135         return !!(state & (DEVICED_POWER_STATE_POWEROFF | DEVICED_POWER_STATE_REBOOT | DEVICED_POWER_STATE_EXIT));
 136 }
 137
 138 static inline void power_request_change_state_strict(uint64_t curr, uint64_t next, int reason, void *udata)
 139 {
 140         struct trans_info ti = { curr, next, reason, udata };
 141         GList l = { &ti, NULL, NULL };
 142
 143         device_notify(DEVICE_NOTIFIER_REQUEST_TRANSITION_STATE, &l);
 144 }
 145
 146 static inline void power_request_change_state(uint64_t next, int reason)
 147 {
 148         power_request_change_state_strict(DEVICED_POWER_STATE_ALL, next, reason, NULL);
 149 }
 150
 151 uint64_t power_get_state(void);
 152 int add_change_state_wait(pid_t pid, guint64 state);
 153 void remove_change_state_wait(pid_t pid, guint64 state);
 154 int confirm_change_state_wait(pid_t pid, guint64 id);
 155
 156 #endif //__POWER_STATE_MANAGER_H__