src/display/display-plugin.c

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2023 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 #include <errno.h>
  20 #include "display-misc.h"
  21 #include "display-plugin.h"
  22 #include "shared/log-macro.h"
  23
  24 struct display_plugin g_display_plugin;
  25
  26 void* display_plugin_handle(void)
  27 {
  28         return g_display_plugin.handle;
  29 }
  30
  31 int display_plugin_pm_lock_internal(pid_t pid, int s_bits, int flags, int timeout)
  32 {
  33         if (g_display_plugin.pm_lock_internal)
  34                 return g_display_plugin.pm_lock_internal(pid, s_bits, flags, timeout);
  35
  36         return 0;
  37 }
  38
  39 int display_plugin_pm_unlock_internal(pid_t pid, int s_bits, int flags)
  40 {
  41         if (g_display_plugin.pm_unlock_internal)
  42                 return g_display_plugin.pm_unlock_internal(pid, s_bits, flags);
  43
  44         return 0;
  45 }
  46
  47 int display_plugin_pm_change_internal(pid_t pid, int s_bits)
  48 {
  49         if (g_display_plugin.pm_change_internal)
  50                 return g_display_plugin.pm_change_internal(pid, s_bits);
  51
  52         return 0;
  53 }
  54
  55 int display_plugin_update_pm_setting(int key_idx, int val)
  56 {
  57         if (g_display_plugin.update_pm_setting)
  58                 return g_display_plugin.update_pm_setting(key_idx, val);
  59
  60         return 0;
  61 }
  62
  63 /* FIXME: return 0 can be value of get_lock_screen_state, it is hard to distinguish error or not */
  64 int display_plugin_get_lock_screen_state(void)
  65 {
  66         if (g_display_plugin.get_lock_screen_state)
  67                 return g_display_plugin.get_lock_screen_state();
  68
  69         return 0;
  70 }
  71
  72 int display_plugin_get_system_wakeup_flag(bool *flag)
  73 {
  74         *flag = g_display_plugin.system_wakeup_flag;
  75
  76         return 0;
  77 }
  78
  79 int display_plugin_set_system_wakeup_flag(bool flag)
  80 {
  81         g_display_plugin.system_wakeup_flag = flag;
  82
  83         return 0;
  84 }
  85
  86 const char* display_plugin_device_flags_to_string(enum device_flags flags)
  87 {
  88         if (g_display_plugin.device_flags_to_string)
  89                 return g_display_plugin.device_flags_to_string(flags);
  90
  91         return NULL;
  92 }
  93
  94 int display_plugin_auto_brightness_control(enum brightness_request_e request, int set_brightness)
  95 {
  96         if (g_display_plugin.auto_brightness_control)
  97                 return g_display_plugin.auto_brightness_control(request, set_brightness);
  98
  99         return 0;
 100 }
 101
 102 int display_plugin_backlight_get_lcd_power(void)
 103 {
 104         if (g_display_plugin.backlight && g_display_plugin.backlight->get_lcd_power)
 105                 return g_display_plugin.backlight->get_lcd_power();
 106
 107         return -EOPNOTSUPP;
 108 }
 109
 110 int display_plugin_backlight_set_brightness(int brightness)
 111 {
 112         if (g_display_plugin.backlight && g_display_plugin.backlight->set_brightness)
 113                 return g_display_plugin.backlight->set_brightness(brightness);
 114
 115         return -EOPNOTSUPP;
 116 }
 117
 118 int display_plugin_backlight_get_brightness(int *brightness)
 119 {
 120         if (g_display_plugin.backlight && g_display_plugin.backlight->get_brightness)
 121                 return g_display_plugin.backlight->get_brightness(brightness);
 122
 123         return -EOPNOTSUPP;
 124 }
 125
 126 int display_plugin_backlight_transit_state(int state)
 127 {
 128         if (g_display_plugin.backlight && g_display_plugin.backlight->transit_state)
 129                 return g_display_plugin.backlight->transit_state(state);
 130
 131         return -EOPNOTSUPP;
 132 }
 133
 134 int display_plugin_backlight_transit_brightness(int start, int end, int step)
 135 {
 136         if (g_display_plugin.backlight && g_display_plugin.backlight->transit_brt) {
 137                 g_display_plugin.backlight->transit_brt(start, end, step);
 138                 return 0;
 139         }
 140
 141         return -EOPNOTSUPP;
 142 }
 143
 144 /* FIXME: Below functions are temorary to separtate display state transition functions */
 145 int display_plugin_state_do_default_trans(enum state_t state, int evt)
 146 {
 147         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->trans)
 148                 return g_display_plugin.display_states[state]->trans(evt);
 149
 150         return -EOPNOTSUPP;
 151 }
 152
 153 bool display_plugin_state_is_there_default_trans(enum state_t state)
 154 {
 155         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->trans)
 156                 return true;
 157
 158         return false;
 159 }
 160
 161 int display_plugin_state_do_default_action(enum state_t state, int timeout)
 162 {
 163         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->action)
 164                 return g_display_plugin.display_states[state]->action(timeout);
 165
 166         return -EOPNOTSUPP;
 167 }
 168
 169 int display_plugin_state_do_default_check(enum state_t state, int curr, int next)
 170 {
 171         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->check)
 172                 return g_display_plugin.display_states[state]->check(curr, next);
 173
 174         return -EOPNOTSUPP;
 175 }
 176
 177 int display_plugin_state_delete_state_cond(void *data, enum state_t s_state)
 178 {
 179         if (g_display_plugin.delete_state_cond) {
 180                 g_display_plugin.delete_state_cond(data, s_state);
 181                 return 0;
 182         }
 183
 184         return -EOPNOTSUPP;
 185 }
 186
 187 int display_plugin_state_get_name(enum state_t state, const char **state_name)
 188 {
 189         if (!state_name)
 190                 return -EINVAL;
 191
 192         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->name) {
 193                 *state_name = g_display_plugin.display_states[state]->name;
 194                 return 0;
 195         }
 196
 197         return -EOPNOTSUPP;
 198 }
 199
 200 int display_plugin_state_set_timeout(enum state_t state, int state_timeout)
 201 {
 202         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->timeout) {
 203                 g_display_plugin.display_states[state]->timeout = state_timeout;
 204                 return 0;
 205         }
 206
 207         return -EOPNOTSUPP;
 208 }
 209
 210 int display_plugin_state_get_timeout(enum state_t state, int* state_timeout)
 211 {
 212         if (!state_timeout)
 213                 return -EINVAL;
 214
 215         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->timeout) {
 216                 *state_timeout = g_display_plugin.display_states[state]->timeout;
 217                 return 0;
 218         }
 219
 220         return -EOPNOTSUPP;
 221 }
 222
 223 int display_plugin_config_get_timeout_enable(bool *timeout_enable)
 224 {
 225         if (!timeout_enable)
 226                 return -EINVAL;
 227
 228         if (g_display_plugin.config) {
 229                 *timeout_enable = g_display_plugin.config->timeout_enable;
 230                 return 0;
 231         }
 232
 233         return -EOPNOTSUPP;
 234 }
 235
 236 int display_plugin_set_dim_state(bool on)
 237 {
 238         if (g_display_plugin.set_dim_state) {
 239                 g_display_plugin.set_dim_state(on);
 240                 return 0;
 241         }
 242
 243         return -EOPNOTSUPP;
 244 }
 245
 246 int display_plugin_get_device_flags(unsigned long *device_flags)
 247 {
 248         if (!device_flags)
 249                 return -EINVAL;
 250
 251         if (g_display_plugin.get_device_flags)
 252                 return g_display_plugin.get_device_flags(device_flags);
 253
 254         *device_flags = NORMAL_MODE;
 255         bool lcd_paneloff_mode = false;
 256         bool stay_touchscreen_off = false;
 257         display_panel_get_lcd_paneloff_mode(&lcd_paneloff_mode);
 258         display_misc_get_stay_touchscreen_off(&stay_touchscreen_off);
 259
 260         if (lcd_paneloff_mode)
 261                 *device_flags |= LCD_PANEL_OFF_MODE;
 262
 263         if (stay_touchscreen_off)
 264                 *device_flags |= TOUCH_SCREEN_OFF_MODE;
 265
 266         return 0;
 267 }