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-plugin.h"
  21 #include "shared/log-macro.h"
  22
  23 struct display_plugin g_display_plugin;
  24
  25 void* display_plugin_handle(void)
  26 {
  27         return g_display_plugin.handle;
  28 }
  29
  30 int display_plugin_update_pm_setting(int key_idx, int val)
  31 {
  32         if (g_display_plugin.update_pm_setting)
  33                 return g_display_plugin.update_pm_setting(key_idx, val);
  34
  35         return 0;
  36 }
  37
  38 bool display_plugin_is_there_update_pm_setting(void)
  39 {
  40         if (g_display_plugin.update_pm_setting)
  41                 return true;
  42
  43         return false;
  44 }
  45
  46 /* FIXME: return 0 can be value of get_lock_screen_state, it is hard to distinguish error or not */
  47 int display_plugin_get_lock_screen_state(void)
  48 {
  49         if (g_display_plugin.get_lock_screen_state)
  50                 return g_display_plugin.get_lock_screen_state();
  51
  52         return 0;
  53 }
  54
  55 int display_plugin_get_system_wakeup_flag(bool *flag)
  56 {
  57         *flag = g_display_plugin.system_wakeup_flag;
  58
  59         return 0;
  60 }
  61
  62 int display_plugin_set_system_wakeup_flag(bool flag)
  63 {
  64         g_display_plugin.system_wakeup_flag = flag;
  65
  66         return 0;
  67 }
  68
  69 int display_plugin_auto_brightness_control(enum brightness_request_e request, int set_brightness)
  70 {
  71         if (g_display_plugin.auto_brightness_control)
  72                 return g_display_plugin.auto_brightness_control(request, set_brightness);
  73
  74         return 0;
  75 }
  76
  77 int display_plugin_lcd_on_procedure(int state, enum device_flags flag)
  78 {
  79         if (g_display_plugin.lcd_on_procedure) {
  80                 g_display_plugin.lcd_on_procedure(state, flag);
  81                 return 0;
  82         }
  83
  84         return -EOPNOTSUPP;
  85 }
  86
  87 int display_plugin_lcd_off_procedure(enum device_flags flag)
  88 {
  89         if (g_display_plugin.lcd_off_procedure) {
  90                 g_display_plugin.lcd_off_procedure(flag);
  91                 return 0;
  92         }
  93
  94         return -EOPNOTSUPP;
  95 }
  96
  97 int display_plugin_custom_lcd_on(int timeout)
  98 {
  99         if (g_display_plugin.custom_lcd_on) {
 100                 g_display_plugin.custom_lcd_on(timeout);
 101                 return 0;
 102         }
 103
 104         return -EOPNOTSUPP;
 105 }
 106
 107 int display_plugin_custom_lcd_off(enum device_flags flag)
 108 {
 109         if (g_display_plugin.custom_lcd_off) {
 110                 g_display_plugin.custom_lcd_off(flag);
 111                 return 0;
 112         }
 113
 114         return -EOPNOTSUPP;
 115 }
 116
 117 int dipslay_plugin_display_on_by_reason(const char *reason, int timeout)
 118 {
 119         if (g_display_plugin.display_on_by_reason) {
 120                 g_display_plugin.display_on_by_reason(reason, timeout);
 121                 return 0;
 122         }
 123
 124         return -EOPNOTSUPP;
 125 }
 126
 127 int display_plugin_display_off_by_reason(const char *reason)
 128 {
 129         if (g_display_plugin.display_off_by_reason) {
 130                 g_display_plugin.display_off_by_reason(reason);
 131                 return 0;
 132         }
 133
 134         return -EOPNOTSUPP;
 135 }
 136
 137 int display_plugin_set_power_save_mode_flag(int onoff)
 138 {
 139         if (g_display_plugin.default_saving_mode) {
 140                 g_display_plugin.default_saving_mode(onoff);
 141                 return 0;
 142         }
 143
 144         return -EOPNOTSUPP;
 145 }
 146
 147 /** FIXME: is_lcdon_blocked() should be moved or refactored after plugin relocation
 148  *         Also, this is temporary wrapper function. It should be removed.
 149  */
 150 int display_plugin_is_lcd_on_blocked(void)
 151 {
 152         if (g_display_plugin.is_lcdon_blocked)
 153                 return g_display_plugin.is_lcdon_blocked();
 154
 155         return -EOPNOTSUPP;
 156 }
 157
 158 int display_plugin_backlight_get_lcd_power(void)
 159 {
 160         if (g_display_plugin.backlight && g_display_plugin.backlight->get_lcd_power)
 161                 return g_display_plugin.backlight->get_lcd_power();
 162
 163         return -EOPNOTSUPP;
 164 }
 165
 166 int display_plugin_backlight_set_brightness(int brightness)
 167 {
 168         if (g_display_plugin.backlight && g_display_plugin.backlight->set_brightness)
 169                 return g_display_plugin.backlight->set_brightness(brightness);
 170
 171         return -EOPNOTSUPP;
 172 }
 173
 174 int display_plugin_backlight_get_brightness(int *brightness)
 175 {
 176         if (g_display_plugin.backlight && g_display_plugin.backlight->get_brightness)
 177                 return g_display_plugin.backlight->get_brightness(brightness);
 178
 179         return -EOPNOTSUPP;
 180 }
 181
 182 int display_plugin_backlight_transit_state(int state)
 183 {
 184         if (g_display_plugin.backlight && g_display_plugin.backlight->transit_state)
 185                 return g_display_plugin.backlight->transit_state(state);
 186
 187         return -EOPNOTSUPP;
 188 }
 189
 190 int display_plugin_backlight_transit_brightness(int start, int end, int step)
 191 {
 192         if (g_display_plugin.backlight && g_display_plugin.backlight->transit_brt) {
 193                 g_display_plugin.backlight->transit_brt(start, end, step);
 194                 return 0;
 195         }
 196
 197         return -EOPNOTSUPP;
 198 }
 199
 200 /* FIXME: Below functions are temorary to separtate display state transition functions */
 201 int display_plugin_state_do_default_trans(enum state_t state, int evt)
 202 {
 203         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->trans)
 204                 return g_display_plugin.display_states[state]->trans(evt);
 205
 206         return -EOPNOTSUPP;
 207 }
 208
 209 bool display_plugin_state_is_there_default_trans(enum state_t state)
 210 {
 211         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->trans)
 212                 return true;
 213
 214         return false;
 215 }
 216
 217 int display_plugin_state_get_name(enum state_t state, const char **state_name)
 218 {
 219         if (!state_name)
 220                 return -EINVAL;
 221
 222         if (g_display_plugin.display_states[state] && g_display_plugin.display_states[state]->name) {
 223                 *state_name = g_display_plugin.display_states[state]->name;
 224                 return 0;
 225         }
 226
 227         *state_name = NULL;
 228         return -EOPNOTSUPP;
 229 }
 230
 231 int display_plugin_state_set_timeout(enum state_t state, int state_timeout)
 232 {
 233         if (g_display_plugin.display_states[state]) {
 234                 g_display_plugin.display_states[state]->timeout = state_timeout;
 235                 return 0;
 236         }
 237
 238         return -EOPNOTSUPP;
 239 }
 240
 241 int display_plugin_state_get_timeout(enum state_t state, int* state_timeout)
 242 {
 243         if (!state_timeout)
 244                 return -EINVAL;
 245
 246         if (g_display_plugin.display_states[state]) {
 247                 *state_timeout = g_display_plugin.display_states[state]->timeout;
 248                 return 0;
 249         }
 250
 251         return -EOPNOTSUPP;
 252 }
 253
 254 int display_plugin_state_get_state_by_state_index(int state_index, enum state_t *state)
 255 {
 256         if (!state)
 257                 return -EINVAL;
 258
 259         if (g_display_plugin.display_states[state_index]) {
 260                 *state = g_display_plugin.display_states[state_index]->state;
 261                 return 0;
 262         }
 263
 264         return -EOPNOTSUPP;
 265 }
 266
 267 bool display_plugin_state_is_there_proc_change_state(void)
 268 {
 269         return (g_display_plugin.proc_change_state != NULL);
 270 }
 271
 272 int display_plugin_state_proc_change_state(unsigned int cond, pid_t pid)
 273 {
 274         if (!g_display_plugin.proc_change_state)
 275                 return -EOPNOTSUPP;
 276
 277         return g_display_plugin.proc_change_state(cond, pid);
 278 }
 279
 280 int display_plugin_config_get_timeout_enable(bool *timeout_enable)
 281 {
 282         if (!timeout_enable)
 283                 return -EINVAL;
 284
 285         if (g_display_plugin.config) {
 286                 *timeout_enable = g_display_plugin.config->timeout_enable;
 287                 return 0;
 288         }
 289
 290         return -EOPNOTSUPP;
 291 }
 292
 293 int display_plugin_config_get_lcdoff_timeout(int *lcdoff_timeout)
 294 {
 295         if (!lcdoff_timeout)
 296                 return -EINVAL;
 297
 298         if (g_display_plugin.config) {
 299                 *lcdoff_timeout = g_display_plugin.config->lcdoff_timeout;
 300                 return 0;
 301         }
 302
 303         return -EOPNOTSUPP;
 304 }
 305
 306 int display_plugin_config_get_lcd_always_on(int *lcd_always_on)
 307 {
 308         if (!lcd_always_on)
 309                 return -EINVAL;
 310
 311         if (g_display_plugin.config) {
 312                 *lcd_always_on = g_display_plugin.config->lcd_always_on;
 313                 return 0;
 314         }
 315
 316         return -EOPNOTSUPP;
 317 }
 318
 319 int display_plugin_config_get_dimming(int *dimming)
 320 {
 321         if (!dimming)
 322                 return -EINVAL;
 323
 324         if (g_display_plugin.config) {
 325                 *dimming = g_display_plugin.config->dimming;
 326                 return 0;
 327         }
 328
 329         return -EOPNOTSUPP;
 330 }
 331
 332 int display_plugin_config_get_pm_default_brightness(int *pm_default_brightness)
 333 {
 334         if (!pm_default_brightness)
 335                 return -EINVAL;
 336
 337         if (!g_display_plugin.config)
 338                 return -EOPNOTSUPP;
 339
 340         *pm_default_brightness = g_display_plugin.config->pm_default_brightness;
 341
 342         return 0;
 343 }
 344
 345 int display_plugin_set_dim_state(bool on)
 346 {
 347         if (g_display_plugin.set_dim_state) {
 348                 g_display_plugin.set_dim_state(on);
 349                 return 0;
 350         }
 351
 352         return -EOPNOTSUPP;
 353 }
 354
 355 int display_plugin_get_device_flags(unsigned long *device_flags)
 356 {
 357         if (!device_flags)
 358                 return -EINVAL;
 359
 360         if (!g_display_plugin.get_device_flags)
 361                 return -EOPNOTSUPP;
 362
 363         return g_display_plugin.get_device_flags(device_flags);
 364 }