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