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 /* FIXME: default_action/default_trans naming should be changed after state transition functions are relocated  */
 170 bool display_plugin_state_is_there_default_action(enum state_t state)
 171 {
 172         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->action)
 173                 return true;
 174
 175         return false;
 176 }
 177
 178 int display_plugin_state_get_name(enum state_t state, const char **state_name)
 179 {
 180         if (!state_name)
 181                 return -EINVAL;
 182
 183         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->name) {
 184                 *state_name = g_display_plugin.display_states[state]->name;
 185                 return 0;
 186         }
 187
 188         *state_name = NULL;
 189         return -EOPNOTSUPP;
 190 }
 191
 192 int display_plugin_state_set_timeout(enum state_t state, int state_timeout)
 193 {
 194         if (g_display_plugin.display_states[state]) {
 195                 g_display_plugin.display_states[state]->timeout = state_timeout;
 196                 return 0;
 197         }
 198
 199         return -EOPNOTSUPP;
 200 }
 201
 202 int display_plugin_state_get_timeout(enum state_t state, int* state_timeout)
 203 {
 204         if (!state_timeout)
 205                 return -EINVAL;
 206
 207         if (g_display_plugin.display_states[state]) {
 208                 *state_timeout = g_display_plugin.display_states[state]->timeout;
 209                 return 0;
 210         }
 211
 212         return -EOPNOTSUPP;
 213 }
 214
 215 int display_plugin_state_get_state_by_state_index(int state_index, enum state_t *state)
 216 {
 217         if (!state)
 218                 return -EINVAL;
 219
 220         if (g_display_plugin.display_states[state_index]) {
 221                 *state = g_display_plugin.display_states[state_index]->state;
 222                 return 0;
 223         }
 224
 225         return -EOPNOTSUPP;
 226 }
 227
 228 int display_plugin_config_get_timeout_enable(bool *timeout_enable)
 229 {
 230         if (!timeout_enable)
 231                 return -EINVAL;
 232
 233         if (g_display_plugin.config) {
 234                 *timeout_enable = g_display_plugin.config->timeout_enable;
 235                 return 0;
 236         }
 237
 238         return -EOPNOTSUPP;
 239 }
 240
 241 int display_plugin_config_get_lcdoff_timeout(int *lcdoff_timeout)
 242 {
 243         if (!lcdoff_timeout)
 244                 return -EINVAL;
 245
 246         if (g_display_plugin.config) {
 247                 *lcdoff_timeout = g_display_plugin.config->lcdoff_timeout;
 248                 return 0;
 249         }
 250
 251         return -EOPNOTSUPP;
 252 }
 253
 254 int display_plugin_config_get_lcd_always_on(int *lcd_always_on)
 255 {
 256         if (!lcd_always_on)
 257                 return -EINVAL;
 258
 259         if (g_display_plugin.config) {
 260                 *lcd_always_on = g_display_plugin.config->lcd_always_on;
 261                 return 0;
 262         }
 263
 264         return -EOPNOTSUPP;
 265 }
 266
 267 int display_plugin_config_get_dimming(int *dimming)
 268 {
 269         if (!dimming)
 270                 return -EINVAL;
 271
 272         if (g_display_plugin.config) {
 273                 *dimming = g_display_plugin.config->dimming;
 274                 return 0;
 275         }
 276
 277         return -EOPNOTSUPP;
 278 }
 279
 280 int display_plugin_set_dim_state(bool on)
 281 {
 282         if (g_display_plugin.set_dim_state) {
 283                 g_display_plugin.set_dim_state(on);
 284                 return 0;
 285         }
 286
 287         return -EOPNOTSUPP;
 288 }
 289
 290 int display_plugin_get_device_flags(unsigned long *device_flags)
 291 {
 292         if (!device_flags)
 293                 return -EINVAL;
 294
 295         if (g_display_plugin.get_device_flags)
 296                 return g_display_plugin.get_device_flags(device_flags);
 297
 298         *device_flags = NORMAL_MODE;
 299         bool lcd_paneloff_mode = false;
 300         bool stay_touchscreen_off = false;
 301         display_panel_get_lcd_paneloff_mode(&lcd_paneloff_mode);
 302         display_misc_get_stay_touchscreen_off(&stay_touchscreen_off);
 303
 304         if (lcd_paneloff_mode)
 305                 *device_flags |= LCD_PANEL_OFF_MODE;
 306
 307         if (stay_touchscreen_off)
 308                 *device_flags |= TOUCH_SCREEN_OFF_MODE;
 309
 310         return 0;
 311 }