src/shared/display.c

   1 /*
   2  * deviced
   3  *
   4  * Copyright (c) 2012 - 2013 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
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <vconf.h>
  23 #include <errno.h>
  24 #include <device-node.h>
  25 #include <sys/types.h>
  26 #include <sys/socket.h>
  27 #include <sys/un.h>
  28 #include <unistd.h>
  29 #include <linux/limits.h>
  30
  31 #include "log.h"
  32 #include "dbus.h"
  33 #include "dd-display.h"
  34
  35 #define DISPLAY_MAX_BRIGHTNESS  100
  36 #define DISPLAY_MIN_BRIGHTNESS  1
  37 #define DISPLAY_DIM_BRIGHTNESS  0
  38
  39 #define SOCK_PATH                       "/tmp/pm_sock"
  40 #define SHIFT_UNLOCK                    4
  41 #define SHIFT_UNLOCK_PARAMETER          12
  42 #define SHIFT_CHANGE_STATE              8
  43 #define SHIFT_LOCK_FLAG                 16
  44 #define SHIFT_CHANGE_TIMEOUT            20
  45 #define TIMEOUT_RESET_BIT               0x80
  46 #define HOLDKEY_BLOCK_BIT               0x1
  47 #define STANDBY_MODE_BIT                0x2
  48 #define CUSTOM_HOLDKEY_BIT              0x2
  49
  50 #define METHOD_SET_FRAME_RATE           "setframerate"
  51 #define METHOD_LOCK_STATE               "lockstate"
  52 #define METHOD_UNLOCK_STATE             "unlockstate"
  53 #define METHOD_CHANGE_STATE             "changestate"
  54 #define METHOD_GET_DISPLAY_COUNT        "GetDisplayCount"
  55 #define METHOD_GET_BRIGHTNESS   "GetBrightness"
  56 #define METHOD_SET_BRIGHTNESS   "SetBrightness"
  57 #define METHOD_HOLD_BRIGHTNESS  "HoldBrightness"
  58 #define METHOD_RELEASE_BRIGHTNESS       "ReleaseBrightness"
  59 #define METHOD_GET_ACL_STATUS   "GetAclStatus"
  60 #define METHOD_SET_ACL_STATUS   "SetAclStatus"
  61
  62 #define STR_LCD_OFF   "lcdoff"
  63 #define STR_LCD_DIM   "lcddim"
  64 #define STR_LCD_ON    "lcdon"
  65 #define STR_SUSPEND   "suspend"
  66
  67 #define STR_STAYCURSTATE "staycurstate"
  68 #define STR_GOTOSTATENOW "gotostatenow"
  69
  70 #define STR_HOLDKEYBLOCK "holdkeyblock"
  71 #define STR_STANDBYMODE  "standbymode"
  72 #define STR_NULL         "NULL"
  73
  74 #define STR_SLEEP_MARGIN "sleepmargin"
  75 #define STR_RESET_TIMER  "resettimer"
  76 #define STR_KEEP_TIMER   "keeptimer"
  77
  78 struct disp_lock_msg {
  79         pid_t pid;
  80         unsigned int cond;
  81         unsigned int timeout;
  82         unsigned int timeout2;
  83 };
  84
  85
  86 API int display_get_count(void)
  87 {
  88         DBusError err;
  89         DBusMessage *msg;
  90         int ret, ret_val;
  91
  92         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
  93                         METHOD_GET_DISPLAY_COUNT, NULL, NULL);
  94         if (!msg)
  95                 return -EBADMSG;
  96
  97         dbus_error_init(&err);
  98
  99         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 100         if (!ret) {
 101                 _E("no message : [%s:%s]", err.name, err.message);
 102                 ret_val = -EBADMSG;
 103         }
 104
 105         dbus_message_unref(msg);
 106         dbus_error_free(&err);
 107         return ret_val;
 108 }
 109
 110 API int display_get_max_brightness(void)
 111 {
 112         return DISPLAY_MAX_BRIGHTNESS;
 113 }
 114
 115 API int display_get_min_brightness(void)
 116 {
 117         return DISPLAY_MIN_BRIGHTNESS;
 118 }
 119
 120 API int display_get_brightness(void)
 121 {
 122         DBusError err;
 123         DBusMessage *msg;
 124         int ret, ret_val;
 125
 126         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 127                         METHOD_GET_BRIGHTNESS, NULL, NULL);
 128         if (!msg)
 129                 return -EBADMSG;
 130
 131         dbus_error_init(&err);
 132
 133         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 134         if (!ret) {
 135                 _E("no message : [%s:%s]", err.name, err.message);
 136                 ret_val = -EBADMSG;
 137         }
 138
 139         dbus_message_unref(msg);
 140         dbus_error_free(&err);
 141         return ret_val;
 142 }
 143
 144 API int display_set_brightness_with_setting(int val)
 145 {
 146         DBusError err;
 147         DBusMessage *msg;
 148         char str_val[32];
 149         char *arr[1];
 150         int ret, ret_val;
 151
 152         snprintf(str_val, sizeof(str_val), "%d", val);
 153         arr[0] = str_val;
 154
 155         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 156                         METHOD_SET_BRIGHTNESS, "i", arr);
 157         if (!msg)
 158                 return -EBADMSG;
 159
 160         dbus_error_init(&err);
 161
 162         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 163         if (!ret) {
 164                 _E("no message : [%s:%s]", err.name, err.message);
 165                 ret_val = -EBADMSG;
 166         }
 167
 168         dbus_message_unref(msg);
 169         dbus_error_free(&err);
 170         return ret_val;
 171 }
 172
 173 API int display_set_brightness(int val)
 174 {
 175         DBusError err;
 176         DBusMessage *msg;
 177         char str_val[32];
 178         char *arr[1];
 179         int ret, ret_val;
 180
 181         snprintf(str_val, sizeof(str_val), "%d", val);
 182         arr[0] = str_val;
 183
 184         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 185                         METHOD_HOLD_BRIGHTNESS, "i", arr);
 186         if (!msg)
 187                 return -EBADMSG;
 188
 189         dbus_error_init(&err);
 190
 191         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 192         if (!ret) {
 193                 _E("no message : [%s:%s]", err.name, err.message);
 194                 ret_val = -EBADMSG;
 195         }
 196
 197         dbus_message_unref(msg);
 198         dbus_error_free(&err);
 199         return ret_val;
 200 }
 201
 202 API int display_release_brightness(void)
 203 {
 204         DBusError err;
 205         DBusMessage *msg;
 206         int ret, ret_val;
 207
 208         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 209                         METHOD_RELEASE_BRIGHTNESS, NULL, NULL);
 210         if (!msg)
 211                 return -EBADMSG;
 212
 213         dbus_error_init(&err);
 214
 215         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 216         if (!ret) {
 217                 _E("no message : [%s:%s]", err.name, err.message);
 218                 ret_val = -EBADMSG;
 219         }
 220
 221         dbus_message_unref(msg);
 222         dbus_error_free(&err);
 223         return ret_val;
 224 }
 225
 226 API int display_get_acl_status(void)
 227 {
 228         DBusError err;
 229         DBusMessage *msg;
 230         int ret, ret_val;
 231
 232         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 233                         METHOD_GET_ACL_STATUS, NULL, NULL);
 234         if (!msg)
 235                 return -EBADMSG;
 236
 237         dbus_error_init(&err);
 238
 239         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 240         if (!ret) {
 241                 _E("no message : [%s:%s]", err.name, err.message);
 242                 ret_val = -EBADMSG;
 243         }
 244
 245         dbus_message_unref(msg);
 246         dbus_error_free(&err);
 247         return ret_val;
 248 }
 249
 250 API int display_set_acl_status(int val)
 251 {
 252         DBusError err;
 253         DBusMessage *msg;
 254         char str_val[32];
 255         char *arr[1];
 256         int ret, ret_val;
 257
 258         snprintf(str_val, sizeof(str_val), "%d", val);
 259         arr[0] = str_val;
 260
 261         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 262                         METHOD_SET_ACL_STATUS, "i", arr);
 263         if (!msg)
 264                 return -EBADMSG;
 265
 266         dbus_error_init(&err);
 267
 268         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 269         if (!ret) {
 270                 _E("no message : [%s:%s]", err.name, err.message);
 271                 ret_val = -EBADMSG;
 272         }
 273
 274         dbus_message_unref(msg);
 275         dbus_error_free(&err);
 276         return ret_val;
 277 }
 278
 279 API int display_set_frame_rate(int val)
 280 {
 281         DBusError err;
 282         DBusMessage *msg;
 283         char str_val[32];
 284         char *arr[1];
 285         int ret, ret_val;
 286
 287         snprintf(str_val, sizeof(str_val), "%d", val);
 288         arr[0] = str_val;
 289
 290         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 291                         METHOD_SET_FRAME_RATE, "i", arr);
 292         if (!msg)
 293                 return -EBADMSG;
 294
 295         dbus_error_init(&err);
 296
 297         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ret_val, DBUS_TYPE_INVALID);
 298         if (!ret) {
 299                 _E("no message : [%s:%s]", err.name, err.message);
 300                 ret_val = -EBADMSG;
 301         }
 302
 303         dbus_message_unref(msg);
 304         dbus_error_free(&err);
 305         return ret_val;
 306 }
 307
 308 static inline char *get_lcd_str(unsigned int val)
 309 {
 310         switch (val) {
 311         case LCD_NORMAL:
 312                 return STR_LCD_ON;
 313         case LCD_DIM:
 314                 return STR_LCD_DIM;
 315         case LCD_OFF:
 316                 return STR_LCD_OFF;
 317         case SUSPEND:
 318                 return STR_SUSPEND;
 319         default:
 320                 return NULL;
 321         }
 322 }
 323
 324 API int display_change_state(unsigned int s_bits)
 325 {
 326         DBusError err;
 327         DBusMessage *msg;
 328         char *p, *pa[1];
 329         int ret, val;
 330
 331         p = get_lcd_str(s_bits);
 332         if (!p)
 333                 return -EINVAL;
 334         pa[0] = p;
 335
 336         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 337                         METHOD_CHANGE_STATE, "s", pa);
 338         if (!msg)
 339                 return -EBADMSG;
 340
 341         dbus_error_init(&err);
 342
 343         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &val, DBUS_TYPE_INVALID);
 344         if (!ret) {
 345                 _E("no message : [%s:%s]", err.name, err.message);
 346                 val = -EBADMSG;
 347         }
 348
 349         dbus_message_unref(msg);
 350         dbus_error_free(&err);
 351
 352         _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_CHANGE_STATE, val);
 353         return val;
 354 }
 355
 356 API int display_lock_state(unsigned int s_bits, unsigned int flag,
 357                       unsigned int timeout)
 358 {
 359         DBusError err;
 360         DBusMessage *msg;
 361         char *p, *pa[4];
 362         char str_timeout[32];
 363         int ret, val;
 364
 365         p = get_lcd_str(s_bits);
 366         if (!p)
 367                 return -EINVAL;
 368         pa[0] = p;
 369
 370         if (flag & GOTO_STATE_NOW)
 371                 /* if the flag is true, go to the locking state directly */
 372                 p = STR_GOTOSTATENOW;
 373         else
 374                 p = STR_STAYCURSTATE;
 375         pa[1] = p;
 376
 377         if (flag & HOLD_KEY_BLOCK)
 378                 p = STR_HOLDKEYBLOCK;
 379         else if (flag & STANDBY_MODE)
 380                 p = STR_STANDBYMODE;
 381         else
 382                 p = STR_NULL;
 383         pa[2] = p;
 384
 385         snprintf(str_timeout, sizeof(str_timeout), "%d", timeout);
 386         pa[3] = str_timeout;
 387
 388         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 389                         METHOD_LOCK_STATE, "sssi", pa);
 390         if (!msg)
 391                 return -EBADMSG;
 392
 393         dbus_error_init(&err);
 394
 395         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &val, DBUS_TYPE_INVALID);
 396         if (!ret) {
 397                 _E("no message : [%s:%s]", err.name, err.message);
 398                 val = -EBADMSG;
 399         }
 400         dbus_message_unref(msg);
 401         dbus_error_free(&err);
 402
 403         _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_LOCK_STATE, val);
 404         return val;
 405 }
 406
 407 API int display_unlock_state(unsigned int s_bits, unsigned int flag)
 408 {
 409         DBusError err;
 410         DBusMessage *msg;
 411         char *p, *pa[2];
 412         int ret, val;
 413
 414         p = get_lcd_str(s_bits);
 415         if (!p)
 416                 return -EINVAL;
 417         pa[0] = p;
 418
 419         switch (flag) {
 420         case PM_SLEEP_MARGIN:
 421                 p = STR_SLEEP_MARGIN;
 422                 break;
 423         case PM_RESET_TIMER:
 424                 p = STR_RESET_TIMER;
 425                 break;
 426         case PM_KEEP_TIMER:
 427                 p = STR_KEEP_TIMER;
 428                 break;
 429         default:
 430                 return -EINVAL;
 431         }
 432         pa[1] = p;
 433
 434         msg = deviced_dbus_method_sync(BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
 435                         METHOD_UNLOCK_STATE, "ss", pa);
 436         if (!msg)
 437                 return -EBADMSG;
 438
 439         dbus_error_init(&err);
 440
 441         ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &val, DBUS_TYPE_INVALID);
 442         if (!ret) {
 443                 _E("no message : [%s:%s]", err.name, err.message);
 444                 val = -EBADMSG;
 445         }
 446
 447         dbus_message_unref(msg);
 448         dbus_error_free(&err);
 449
 450         _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_UNLOCK_STATE, val);
 451         return val;
 452
 453 }
 454
 455 static int send_msg(unsigned int s_bits, unsigned int timeout, unsigned int timeout2)
 456 {
 457         int rc = 0;
 458         int sock;
 459         struct disp_lock_msg p;
 460         struct sockaddr_un remote;
 461
 462         p.pid = getpid();
 463         p.cond = s_bits;
 464         p.timeout = timeout;
 465         p.timeout2 = timeout2;
 466
 467         sock = socket(AF_UNIX, SOCK_DGRAM, 0);
 468         if (sock == -1) {
 469                 _E("pm socket() failed: %s", strerror(errno));
 470                 return sock;
 471         }
 472
 473         remote.sun_family = AF_UNIX;
 474         if(strlen(SOCK_PATH) >= sizeof(remote.sun_path)) {
 475                 _E("socket path is vey long");
 476                 close(sock);
 477                 return -ENAMETOOLONG;
 478         }
 479         strncpy(remote.sun_path, SOCK_PATH, sizeof(remote.sun_path));
 480
 481         rc = sendto(sock, (void *)&p, sizeof(p), 0, (struct sockaddr *)&remote,
 482                     sizeof(struct sockaddr_un));
 483         if (rc == -1)
 484                 _E("pm socket sendto() failed: %s", strerror(errno));
 485
 486         close(sock);
 487         return (rc > 0 ? 0 : rc);
 488 }
 489
 490 API void display_set_timeout(unsigned int normal, unsigned int dim, unsigned int lock)
 491 {
 492         unsigned int s_bits = CUSTOM_TIMEOUT;
 493
 494         if (lock == HOLD_KEY_BLOCK)
 495                 s_bits += CUSTOM_HOLDKEY_BIT;
 496
 497         s_bits = (s_bits << SHIFT_CHANGE_TIMEOUT);
 498         send_msg(s_bits, normal, dim);
 499 }