From 7d7dd28dca001d30018e4c39871fd8505534b2cd Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Mon, 29 Jul 2019 18:09:06 +0900 Subject: [PATCH 01/16] Change log level for failed AOD mode to avoid confusion Change-Id: I3647f7db0a07c3d29219ecef7f9d1a5899dde5cd Signed-off-by: lokilee73 --- src/display/ambient-mode.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/display/ambient-mode.c b/src/display/ambient-mode.c index 9254100..fdec29b 100644 --- a/src/display/ambient-mode.c +++ b/src/display/ambient-mode.c @@ -138,7 +138,7 @@ void ambient_check_invalid_state(pid_t pid) if (ambient_get_state() == false) return; - _E("Invalid state. Ambient state is change to off."); + _I("Invalid state. Ambient state is change to off."); /* If lcd_power is on and ambient state is true * when pm state is changed to sleep, -- 2.7.4 From 5ea7e1f6b1d76522c9beb34065512e17b25e068a Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Tue, 30 Jul 2019 16:17:48 +0900 Subject: [PATCH 02/16] Remove power off popup from power off type Change-Id: I16ed1f64ba7a26340975796071f1736bd6470ba9 Signed-off-by: lokilee73 --- plugins/iot/display/core.c | 1 - plugins/iot/display/key-filter.c | 19 +++++++++++-------- plugins/mobile/display/core.c | 1 - plugins/mobile/display/key-filter.c | 19 +++++++++++-------- plugins/tv/display/core.c | 1 - plugins/tv/display/key-filter.c | 19 +++++++++++-------- plugins/wearable/display/core.c | 1 - plugins/wearable/display/key-filter.c | 19 +++++++++++-------- src/power/power-handler.c | 13 ------------- src/power/power-handler.h | 1 - 10 files changed, 44 insertions(+), 50 deletions(-) diff --git a/plugins/iot/display/core.c b/plugins/iot/display/core.c index 42ef795..b9d7d14 100644 --- a/plugins/iot/display/core.c +++ b/plugins/iot/display/core.c @@ -1849,7 +1849,6 @@ static int update_setting(int key_idx, int val) case SETTING_POWEROFF: switch (val) { case POWEROFF_TYPE_NONE: - case POWEROFF_TYPE_POPUP: pm_status_flag &= ~PWROFF_FLAG; break; case POWEROFF_TYPE_DIRECT: diff --git a/plugins/iot/display/key-filter.c b/plugins/iot/display/key-filter.c index 6ef373c..0baf72a 100644 --- a/plugins/iot/display/key-filter.c +++ b/plugins/iot/display/key-filter.c @@ -38,6 +38,7 @@ #include "core/device-notifier.h" #include "power/power-handler.h" #include "led/touch-key.h" +#include "apps/apps.h" #include #ifndef KEY_SCREENLOCK @@ -49,7 +50,6 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" -#define PWROFF_POPUP_ACT "pwroff-popup" #define USEC_PER_SEC 1000000 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ @@ -118,18 +118,22 @@ static inline void restore_custom_brightness(void) backlight_ops.custom_update(); } -static int power_execute(void *data) +static void pwroff_popup(void) { - static const struct device_ops *ops = NULL; + int ret; - FIND_DEVICE_INT(ops, POWER_OPS_NAME); + ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); + if (ret < 0) + _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - return ops->execute(data); + pm_status_flag &= ~PWROFF_FLAG; + ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); + if (ret < 0) + _E("Failed to launch power off popup."); } static void longkey_pressed() { - char *opt; unsigned int caps; _I("Power key long pressed!"); @@ -149,8 +153,7 @@ static void longkey_pressed() return; } - opt = POWEROFF_ACT; - power_execute(opt); + pwroff_popup(); } static gboolean longkey_pressed_cb(void *data) diff --git a/plugins/mobile/display/core.c b/plugins/mobile/display/core.c index d38d9ac..f252e4e 100644 --- a/plugins/mobile/display/core.c +++ b/plugins/mobile/display/core.c @@ -1850,7 +1850,6 @@ static int update_setting(int key_idx, int val) case SETTING_POWEROFF: switch (val) { case POWEROFF_TYPE_NONE: - case POWEROFF_TYPE_POPUP: pm_status_flag &= ~PWROFF_FLAG; break; case POWEROFF_TYPE_DIRECT: diff --git a/plugins/mobile/display/key-filter.c b/plugins/mobile/display/key-filter.c index 6789e71..7f060d0 100644 --- a/plugins/mobile/display/key-filter.c +++ b/plugins/mobile/display/key-filter.c @@ -38,6 +38,7 @@ #include "core/device-notifier.h" #include "power/power-handler.h" #include "led/touch-key.h" +#include "apps/apps.h" #include #ifndef KEY_SCREENLOCK @@ -49,7 +50,6 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" -#define PWROFF_POPUP_ACT "pwroff-popup" #define USEC_PER_SEC 1000000 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ @@ -118,18 +118,22 @@ static inline void restore_custom_brightness(void) backlight_ops.custom_update(); } -static int power_execute(void *data) +static void pwroff_popup(void) { - static const struct device_ops *ops = NULL; + int ret; - FIND_DEVICE_INT(ops, POWER_OPS_NAME); + ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); + if (ret < 0) + _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - return ops->execute(data); + pm_status_flag &= ~PWROFF_FLAG; + ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); + if (ret < 0) + _E("Failed to launch power off popup."); } static void longkey_pressed() { - char *opt; unsigned int caps; _I("Power key long pressed!"); @@ -149,8 +153,7 @@ static void longkey_pressed() return; } - opt = PWROFF_POPUP_ACT; - power_execute(opt); + pwroff_popup(); } static gboolean longkey_pressed_cb(void *data) diff --git a/plugins/tv/display/core.c b/plugins/tv/display/core.c index 7529349..5f07dde 100644 --- a/plugins/tv/display/core.c +++ b/plugins/tv/display/core.c @@ -1851,7 +1851,6 @@ static int update_setting(int key_idx, int val) case SETTING_POWEROFF: switch (val) { case POWEROFF_TYPE_NONE: - case POWEROFF_TYPE_POPUP: pm_status_flag &= ~PWROFF_FLAG; break; case POWEROFF_TYPE_DIRECT: diff --git a/plugins/tv/display/key-filter.c b/plugins/tv/display/key-filter.c index 6ef373c..0baf72a 100644 --- a/plugins/tv/display/key-filter.c +++ b/plugins/tv/display/key-filter.c @@ -38,6 +38,7 @@ #include "core/device-notifier.h" #include "power/power-handler.h" #include "led/touch-key.h" +#include "apps/apps.h" #include #ifndef KEY_SCREENLOCK @@ -49,7 +50,6 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" -#define PWROFF_POPUP_ACT "pwroff-popup" #define USEC_PER_SEC 1000000 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ @@ -118,18 +118,22 @@ static inline void restore_custom_brightness(void) backlight_ops.custom_update(); } -static int power_execute(void *data) +static void pwroff_popup(void) { - static const struct device_ops *ops = NULL; + int ret; - FIND_DEVICE_INT(ops, POWER_OPS_NAME); + ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); + if (ret < 0) + _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - return ops->execute(data); + pm_status_flag &= ~PWROFF_FLAG; + ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); + if (ret < 0) + _E("Failed to launch power off popup."); } static void longkey_pressed() { - char *opt; unsigned int caps; _I("Power key long pressed!"); @@ -149,8 +153,7 @@ static void longkey_pressed() return; } - opt = POWEROFF_ACT; - power_execute(opt); + pwroff_popup(); } static gboolean longkey_pressed_cb(void *data) diff --git a/plugins/wearable/display/core.c b/plugins/wearable/display/core.c index bf6ff62..d5e35f9 100644 --- a/plugins/wearable/display/core.c +++ b/plugins/wearable/display/core.c @@ -1850,7 +1850,6 @@ static int update_setting(int key_idx, int val) case SETTING_POWEROFF: switch (val) { case POWEROFF_TYPE_NONE: - case POWEROFF_TYPE_POPUP: pm_status_flag &= ~PWROFF_FLAG; break; case POWEROFF_TYPE_DIRECT: diff --git a/plugins/wearable/display/key-filter.c b/plugins/wearable/display/key-filter.c index a6cb3fc..d66fa9d 100644 --- a/plugins/wearable/display/key-filter.c +++ b/plugins/wearable/display/key-filter.c @@ -38,6 +38,7 @@ #include "core/device-notifier.h" #include "power/power-handler.h" #include "led/touch-key.h" +#include "apps/apps.h" #include #ifndef KEY_SCREENLOCK @@ -49,7 +50,6 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" -#define PWROFF_POPUP_ACT "pwroff-popup" #define USEC_PER_SEC 1000000 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ @@ -129,18 +129,22 @@ static inline void restore_custom_brightness(void) backlight_ops.custom_update(); } -static int power_execute(void *data) +static void pwroff_popup(void) { - static const struct device_ops *ops = NULL; + int ret; - FIND_DEVICE_INT(ops, POWER_OPS_NAME); + ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); + if (ret < 0) + _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - return ops->execute(data); + pm_status_flag &= ~PWROFF_FLAG; + ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); + if (ret < 0) + _E("Failed to launch power off popup."); } static void longkey_pressed() { - char *opt; unsigned int caps; _I("Power key long pressed!"); @@ -160,8 +164,7 @@ static void longkey_pressed() return; } - opt = PWROFF_POPUP_ACT; - power_execute(opt); + pwroff_popup(); } static gboolean longkey_restore_cb(void *data) diff --git a/src/power/power-handler.c b/src/power/power-handler.c index 222eeeb..41aac63 100644 --- a/src/power/power-handler.c +++ b/src/power/power-handler.c @@ -77,7 +77,6 @@ static const char *poweroff_type_flagpaths[] = { // index denotes type static const char *poweroff_type_names[] = { // index denotes type [POWEROFF_TYPE_POWEROFF] = POWER_POWEROFF, - [POWEROFF_TYPE_POPUP] = POWER_OFF_POPUP, [POWEROFF_TYPE_REBOOT] = POWER_REBOOT, [POWEROFF_TYPE_EXIT] = POWER_EXIT, }; @@ -414,11 +413,6 @@ static void system_shutdown_send_system_event(void) bundle_free(b); } -static int pwroff_popup(void) -{ - return launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); -} - static int poweroff_option_valid(enum poweroff_type type_e, const char *option) { dd_list *l; @@ -493,12 +487,6 @@ static int power_execute_pid(const char *typename, const char *option) if (ret < 0) _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - if (poweroff_opt.type == POWEROFF_TYPE_POPUP) { - _D("Request popup."); - pwroff_popup(); - return 0; - } - during_poweroff = true; /* Poweroff event broadcasting */ @@ -756,7 +744,6 @@ static void power_init(void *data) add_poweroff_option(POWEROFF_TYPE_POWEROFF, NULL); add_poweroff_option(POWEROFF_TYPE_RESTART, NULL); - add_poweroff_option(POWEROFF_TYPE_POPUP, NULL); add_poweroff_option(POWEROFF_TYPE_EXIT, NULL); ret = config_parse(POWER_CONF_FILE, load_config, NULL); diff --git a/src/power/power-handler.h b/src/power/power-handler.h index 5ef317d..608a9a2 100644 --- a/src/power/power-handler.h +++ b/src/power/power-handler.h @@ -33,7 +33,6 @@ enum poweroff_type { POWEROFF_TYPE_INVALID = 0, POWEROFF_TYPE_NONE = POWEROFF_TYPE_INVALID, // compat only - POWEROFF_TYPE_POPUP, POWEROFF_TYPE_POWEROFF, /* replaces POWEROFF_TYPE_DIRECT */ POWEROFF_TYPE_DIRECT = POWEROFF_TYPE_POWEROFF, // compat only POWEROFF_TYPE_REBOOT, -- 2.7.4 From 09e4e1757d17cce60540d0056bb5739b3af63152 Mon Sep 17 00:00:00 2001 From: Youngjae Cho Date: Tue, 30 Jul 2019 10:18:37 +0900 Subject: [PATCH 03/16] Add a board info module Change-Id: I89309dec1f198a5fbac3e4fbbbee484bcb6f5bf2 Signed-off-by: Youngjae Cho Signed-off-by: lokilee73 Signed-off-by: Youngjae Cho --- CMakeLists.txt | 5 ++ packaging/deviced.spec | 1 + src/board/board-info.c | 173 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 179 insertions(+) create mode 100644 src/board/board-info.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 33ca1c4..b28ba3f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -155,6 +155,11 @@ IF(TIZEN_FEATURE_USBHOST_TEST STREQUAL on) DESTINATION /etc/deviced/usb-host-test/) ENDIF() +IF(DEVICE_BOARD_MODULE STREQUAL on) + ADD_SOURCE(src/board PRODUCT_BOARD_SRCS) + SET(SRCS ${SRCS} ${PRODUCT_BOARD_SRCS}) +ENDIF() + INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/src) INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/src/deviced) diff --git a/packaging/deviced.spec b/packaging/deviced.spec index fd8a375..e2da603 100644 --- a/packaging/deviced.spec +++ b/packaging/deviced.spec @@ -163,6 +163,7 @@ Plugin libraries for IoT devices -DTIZEN_FEATURE_BATTERY_OVER_TEMPERATURE=on \ -DTOUCH_SENSITIVITY_MODULE=on \ -DDUMP_MODULE=on \ + -DDEVICE_BOARD_MODULE=on \ #eol %build diff --git a/src/board/board-info.c b/src/board/board-info.c new file mode 100644 index 0000000..2af9fd9 --- /dev/null +++ b/src/board/board-info.c @@ -0,0 +1,173 @@ +/* + * deviced + * + * Copyright (c) 2019 - 2013 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include +#include +#include +#include +#include + +#include "core/log.h" +#include "core/common.h" +#include "core/devices.h" +#include "core/config-parser.h" + +struct board_info { + char *serial; + char *num; + int revision; +}; + +static struct board_info info; +static struct hw_board *board_dev; + +static GVariant *dbus_revision_handler(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int ret; + if (!board_dev->get_device_revision) { + _E("GetHWRev not supported."); + ret = -ENOTSUP; + goto revision_fail; + } + ret = board_dev->get_device_revision(&info.revision); + if (ret < 0) { + _E("Fail to get revision."); + goto revision_fail; + } + _D("Revision: %d", info.revision); + return g_variant_new("(i)", info.revision); + +revision_fail: + return g_variant_new("(i)", ret); +} + +static GVariant *dbus_serial_handler(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int ret; + if (!board_dev->get_device_serial) { + _E("GetSerial not supported."); + ret = -ENOTSUP; + goto serial_out; + } + ret = board_dev->get_device_serial(&info.serial); + if (ret < 0) { + _E("Failed to get serial."); + goto serial_out; + } + _D("Serial(%s) len(%d).", info.serial, strlen(info.serial)); + +serial_out: + return g_variant_new("(si)", info.serial, ret); +} + +static GVariant *dbus_num_handler(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int ret; + char *p; + if (!board_dev->get_device_serial) { + _E("GetNum not supported."); + ret = -ENOTSUP; + goto num_out; + } + ret = board_dev->get_device_serial(&info.num); + if (ret < 0) { + _E("Failed to get num."); + goto num_out; + } + + p = strchr(info.num, ','); + if (p) { + ++p; + strcpy(info.num, p); + } + _D("Num(%s) len(%d).", info.num, strlen(info.num)); + +num_out: + return g_variant_new("(si)", info.num, ret); +} + +static const dbus_method_s dbus_methods[] = { + { "GetSerial", NULL, "si", dbus_serial_handler }, + { "GetHWRev", NULL, "i", dbus_revision_handler }, + { "GetNum", NULL, "si", dbus_num_handler}, +}; + +static const dbus_interface_u dbus_interface = { + .oh = NULL, + .name = DEVICED_INTERFACE_BOARD, + .methods = dbus_methods, + .nr_methods = ARRAY_SIZE(dbus_methods), +}; + +static int board_probe(void *data) +{ + struct hw_info *info; + int ret; + + if (board_dev) + return 0; + + ret = hw_get_info(BOARD_HARDWARE_DEVICE_ID, + (const struct hw_info**)&info); + if (ret < 0) { + _E("Failed to load board shared library: %d", ret); + return -ENODEV; + } + + if (!info->open) { + _E("Failed to open board device: open(NULL)"); + return -ENODEV; + } + + ret = info->open(info, NULL, (struct hw_common**)&board_dev); + if (ret < 0) { + _E("Failed to get board device structure: %d", ret); + return -ENODEV; + } + + _I("Board device structure load success."); + return 0; +} + +static void board_init(void *data) +{ + int ret; + + ret = dbus_handle_add_dbus_object(NULL, DEVICED_PATH_BOARD, &dbus_interface); + if (ret < 0) + _E("Failed to init dbus method: %d", ret); + ret = board_dev->get_device_serial(&info.serial); + if (ret < 0) + _E("Failed to get serial info: %d", ret); +} + +static const struct device_ops board_device_ops = { + .name = "board", + .probe = board_probe, + .init = board_init, +}; + +DEVICE_OPS_REGISTER(&board_device_ops) -- 2.7.4 From 4dba2d36d847d3736accf912ae302e91007c6fbf Mon Sep 17 00:00:00 2001 From: Youngjae Cho Date: Thu, 1 Aug 2019 16:52:55 +0900 Subject: [PATCH 04/16] Add exception handle, fix log format specifier Change-Id: I0f3f230501ba46c345dcd20d2b737fbb5722dfa1 Signed-off-by: Youngjae Cho --- src/board/board-info.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/board/board-info.c b/src/board/board-info.c index 2af9fd9..6f72ca8 100644 --- a/src/board/board-info.c +++ b/src/board/board-info.c @@ -43,7 +43,7 @@ static GVariant *dbus_revision_handler(GDBusConnection *conn, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { int ret; - if (!board_dev->get_device_revision) { + if (!board_dev || !board_dev->get_device_revision) { _E("GetHWRev not supported."); ret = -ENOTSUP; goto revision_fail; @@ -65,7 +65,7 @@ static GVariant *dbus_serial_handler(GDBusConnection *conn, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { int ret; - if (!board_dev->get_device_serial) { + if (!board_dev || !board_dev->get_device_serial) { _E("GetSerial not supported."); ret = -ENOTSUP; goto serial_out; @@ -75,7 +75,7 @@ static GVariant *dbus_serial_handler(GDBusConnection *conn, _E("Failed to get serial."); goto serial_out; } - _D("Serial(%s) len(%d).", info.serial, strlen(info.serial)); + _D("Serial(%s) len(%zu).", info.serial, strlen(info.serial)); serial_out: return g_variant_new("(si)", info.serial, ret); @@ -87,7 +87,7 @@ static GVariant *dbus_num_handler(GDBusConnection *conn, { int ret; char *p; - if (!board_dev->get_device_serial) { + if (!board_dev || !board_dev->get_device_serial) { _E("GetNum not supported."); ret = -ENOTSUP; goto num_out; @@ -103,7 +103,7 @@ static GVariant *dbus_num_handler(GDBusConnection *conn, ++p; strcpy(info.num, p); } - _D("Num(%s) len(%d).", info.num, strlen(info.num)); + _D("Num(%s) len(%zu).", info.num, strlen(info.num)); num_out: return g_variant_new("(si)", info.num, ret); @@ -159,9 +159,6 @@ static void board_init(void *data) ret = dbus_handle_add_dbus_object(NULL, DEVICED_PATH_BOARD, &dbus_interface); if (ret < 0) _E("Failed to init dbus method: %d", ret); - ret = board_dev->get_device_serial(&info.serial); - if (ret < 0) - _E("Failed to get serial info: %d", ret); } static const struct device_ops board_device_ops = { -- 2.7.4 From 9b571384444b4360a9af9ed0d9a1d066c7689bbf Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Thu, 25 Jul 2019 18:11:00 +0900 Subject: [PATCH 05/16] Fix battery module Change-Id: I29a241fad703080b55d02d5bc7267e7a0832e719 Signed-off-by: lokilee73 --- CMakeLists.txt | 3 - packaging/deviced.spec | 1 - src/apps/apps.c | 2 + src/apps/apps.h | 2 + src/battery/battery.h | 12 +- src/battery/config.c | 16 +- src/battery/lowbat-handler.c | 686 ++++++++++++++++++++++---------------- src/battery/lowbat-handler.h | 3 +- src/battery/power-supply.c | 775 +++++++++++++++++++++++++++++++------------ src/battery/power-supply.h | 52 ++- src/core/udev.h | 8 + src/display/display-dbus.c | 2 +- src/shared/CMakeLists.txt | 4 +- src/shared/eventsystem.c | 49 +++ src/shared/eventsystem.h | 27 ++ 15 files changed, 1114 insertions(+), 528 deletions(-) create mode 100644 src/shared/eventsystem.c create mode 100644 src/shared/eventsystem.h diff --git a/CMakeLists.txt b/CMakeLists.txt index b28ba3f..072b6c6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -83,9 +83,6 @@ SET(SRCS IF(BATTERY_MODULE STREQUAL on) ADD_SOURCE(src/battery BATTERY_SRCS) SET(SRCS ${SRCS} ${BATTERY_SRCS}) - IF(TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE STREQUAL on) - ADD_DEFINITIONS("-DTIZEN_FEATURE_BATTERY_OVER_TEMPERATURE") - ENDIF(TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE STREQUAL on) ENDIF() IF(THERMAL_MODULE STREQUAL on) diff --git a/packaging/deviced.spec b/packaging/deviced.spec index e2da603..f56037b 100644 --- a/packaging/deviced.spec +++ b/packaging/deviced.spec @@ -160,7 +160,6 @@ Plugin libraries for IoT devices -DTHERMAL_MODULE=on \ -DTIZEN_FEATURE_CPU_MODULE=on \ -DTIZEN_FEATURE_USBHOST_TEST=on \ - -DTIZEN_FEATURE_BATTERY_OVER_TEMPERATURE=on \ -DTOUCH_SENSITIVITY_MODULE=on \ -DDUMP_MODULE=on \ -DDEVICE_BOARD_MODULE=on \ diff --git a/src/apps/apps.c b/src/apps/apps.c index 6b8656f..59a9a33 100644 --- a/src/apps/apps.c +++ b/src/apps/apps.c @@ -35,6 +35,8 @@ static const struct app_dbus_match { { APP_DEFAULT , POPUP_BUS_NAME, POPUP_PATH_SYSTEM , POPUP_INTERFACE_SYSTEM , POPUP_METHOD }, { APP_POWERKEY, POPUP_BUS_NAME, POPUP_PATH_POWERKEY, POPUP_INTERFACE_POWERKEY, POPUP_METHOD }, { APP_OVERHEAT, POPUP_BUS_NAME, POPUP_PATH_OVERHEAT, POPUP_INTERFACE_OVERHEAT, POPUP_METHOD }, + { APP_ABNORMAL, POPUP_BUS_NAME, POPUP_PATH_SYSTEM , POPUP_INTERFACE_SYSTEM , POPUP_METHOD }, + { APP_REMOVE , POPUP_BUS_NAME, POPUP_PATH_SYSTEM , POPUP_INTERFACE_SYSTEM , POPUP_METHOD }, }; static void __cb(GVariant *var, void *user_data, GError *err) diff --git a/src/apps/apps.h b/src/apps/apps.h index dc11d92..f467ece 100644 --- a/src/apps/apps.h +++ b/src/apps/apps.h @@ -27,6 +27,8 @@ #define APP_POWERKEY "powerkey" #define APP_OVERHEAT "overheat" #define APP_DEFAULT "system" +#define APP_ABNORMAL "abnormal" +#define APP_REMOVE "remove" #define APP_KEY_TYPE "_SYSPOPUP_CONTENT_" int launch_system_app(char *type, int num, ...); diff --git a/src/battery/battery.h b/src/battery/battery.h index 8dc15a1..51c73a3 100644 --- a/src/battery/battery.h +++ b/src/battery/battery.h @@ -25,9 +25,15 @@ #define BATTERY_LEVEL_CHECK_LOW 5 #define BATTERY_LEVEL_CHECK_CRITICAL 1 -#define LOWBAT_OPT_WARNING 1 -#define LOWBAT_OPT_CHARGEERR 3 -#define LOWBAT_OPT_CHECK 4 +enum battery_option_type { + BAT_OPT_NONE, + BAT_OPT_WARNING, + BAT_OPT_CRITICAL, + BAT_OPT_POWEROFF, + BAT_OPT_ERR_TEMP_LOW, + BAT_OPT_ERR_TEMP_HIGH, + BAT_OPT_ERR_CF_OPEN, +}; #define METHOD_NAME_MAX 32 struct battery_config_info { diff --git a/src/battery/config.c b/src/battery/config.c index ac14c99..7c3376c 100644 --- a/src/battery/config.c +++ b/src/battery/config.c @@ -68,8 +68,16 @@ void battery_config_load(struct battery_config_info *info) { int ret; - ret = config_parse(BAT_CONF_FILE, load_config, info); - - if (ret < 0) - _E("Failed to load '%s'. Use default value: %d", BAT_CONF_FILE, ret); + ret = access(POWER_SUPPLY_UEVENT, F_OK); + if (ret == 0) { + ret = config_parse(BAT_CONF_FILE, load_config, info); + if (ret < 0) + _E("Failed to load '%s'. Use default value: %d", BAT_CONF_FILE, ret); + } else { + info->normal = 100; + info->warning = -1; + info->critical = -2; + info->poweroff = -3; + info->realoff = -4; + } } diff --git a/src/battery/lowbat-handler.c b/src/battery/lowbat-handler.c index f952633..226beb3 100644 --- a/src/battery/lowbat-handler.c +++ b/src/battery/lowbat-handler.c @@ -37,6 +37,7 @@ #include "core/common.h" #include "core/list.h" #include "core/udev.h" +#include "shared/eventsystem.h" #include "device-node.h" #include "display/setting.h" #include "display/poll.h" @@ -45,37 +46,29 @@ #include "apps/apps.h" #include "power-supply.h" -#define CHARGE_POWERSAVE_FREQ_ACT "charge_powersave_freq_act" -#define CHARGE_RELEASE_FREQ_ACT "charge_release_freq_act" - -#define BATTERY_CHARGING 65535 #define BATTERY_UNKNOWN -1 #define BATTERY_DISABLED 0 #define BATTERY_ENABLED 1 -#define WARNING_LOW_BAT_ACT "warning_low_bat_act" -#define CRITICAL_LOW_BAT_ACT "critical_low_bat_act" -#define CHARGE_BAT_ACT "charge_bat_act" -#define CHARGE_CHECK_ACT "charge_check_act" -#define CHARGE_ERROR_ACT "charge_error_act" -#define CHARGE_ERROR_LOW_ACT "charge_error_low_act" -#define CHARGE_ERROR_HIGH_ACT "charge_error_high_act" -#define CHARGE_ERROR_OVP_ACT "charge_error_ovp_act" -#define POWER_SOURCE_USB "usb" -#define POWER_SOURCE_AC "ac" -#define POWER_SOURCE_NONE "none" -#define POWER_SOURCE_WIRELESS "wireless" - -#define WAITING_INTERVAL 10 - -#define LOWBAT_CPU_CTRL_ID "id6" -#define LOWBAT_CPU_FREQ_RATE (0.7) - #define VCONF_KEY_BATTERY_WARNING_LEVEL "db/sysman/battery_warning_level" -enum low_battery_type { - LOW_BATTERY, - CRITICAL_BATTERY, +#define METHOD_LOW_NOTI_ON "BatteryLowNotiOn" +#define METHOD_LOW_NOTI_UPDATE "BatteryLowNotiUpdate" +#define METHOD_LOW_NOTI_OFF "BatteryLowNotiOff" +#define METHOD_CRITICAL_NOTI_ON "BatteryCriticalNotiOn" +#define METHOD_CRITICAL_NOTI_UPDATE "BatteryCriticalNotiUpdate" +#define METHOD_CRITICAL_NOTI_OFF "BatteryCriticalNotiOff" +#define RETRY_MAX 5 + +enum custom_level_control_type { + CUSTOM_CONTROL_NONE, + LOWER_THAN_WARNING, + HIGHER_THAN_WARNING, +}; + +enum event_noti_type { + NOTI_NONE = -1, + NOTI_UPDATE = 0, }; struct lowbat_process_entry { @@ -87,8 +80,7 @@ struct lowbat_process_entry { static int cur_bat_state = BATTERY_UNKNOWN; static int cur_bat_capacity = BATTERY_UNKNOWN; static int custom_warning_level = BATTERY_UNKNOWN; -static int default_battery_warning = BATTERY_WARNING; -static int event_noti_num = -1, active_noti_num = -1; +static bool custom_warning_launch; static struct battery_config_info battery_info = { .normal = BATTERY_NORMAL, @@ -98,6 +90,9 @@ static struct battery_config_info battery_info = { .realoff = BATTERY_REALOFF, }; +static int noti_low = NOTI_NONE; +static int noti_crit = NOTI_NONE; + static dd_list *lpe; static int scenario_count; @@ -127,10 +122,8 @@ static int lowbat_scenario(int old, int now, void *data) continue; if (!scenario->func) continue; - if (scenario->func(data) == 0) + scenario->func(data); found = 1; - else - found = 0; break; } return found; @@ -140,7 +133,7 @@ static int lowbat_add_scenario(int old, int now, int (*func)(void *data)) { struct lowbat_process_entry *scenario; - _D("lowbat_add_scenario: old=%d now=%d func=%p", old, now, func); + _D("Lowbat_add_scenario: old(%d) now(%d) func(%p)", old, now, func); if (!func) { _E("Invalid func address."); @@ -195,7 +188,7 @@ static int booting_done(void *data) popup = 0; if (battery.charge_now != CHARGER_CHARGING && battery.charge_full != CHARGING_FULL) - lowbat_popup(NULL); + lowbat_popup(BAT_OPT_NONE); else _I("Skip low battery popup during charging."); } @@ -203,224 +196,258 @@ out: return done; } -static int get_lowbat_noti_value(int low_battery_type, char **active_noti, char **event_noti) +int lowbat_popup(int option) { - int len; - int ret = 1; + static int launched_poweroff; + static int lowbat_popup_option; + static char *value; + + if (option == BAT_OPT_NONE) { + if (!value) + return -1; + else + goto direct_launch; + } + + if (option == BAT_OPT_POWEROFF) + launched_poweroff = 0; + + switch (option) { + case BAT_OPT_CRITICAL: + value = "lowbattery_critical"; + break; + case BAT_OPT_WARNING: + value = "lowbattery_warning"; + break; + case BAT_OPT_POWEROFF: + value = "poweroff"; + break; + case BAT_OPT_ERR_TEMP_LOW: + value = "chargeerrlow"; + break; + case BAT_OPT_ERR_TEMP_HIGH: + value = "chargeerrhigh"; + break; + case BAT_OPT_ERR_CF_OPEN: + value = "battdisconnect"; + break; + default: + return -1; + } + + lowbat_popup_option = option; + +direct_launch: + _D("Popup value=%s", value); + if (booting_done(NULL)) { - len = strlen(battery.power_source_s); - if (!strncmp(battery.power_source_s, POWER_SOURCE_NONE, len)) { - if (low_battery_type == LOW_BATTERY) { - *active_noti = "BatteryLowActNotiOn"; - *event_noti = "BatteryLowNotiOn"; - } else if (low_battery_type == CRITICAL_BATTERY) { - *active_noti = "BatteryCriticalActNotiOn"; - *event_noti = "BatteryCriticalNotiOn"; + if (launched_poweroff == 1) { + _I("Will be foreced power off."); + power_execute(POWER_POWEROFF); + return 0; } - ret = 0; - } else if (!strncmp(battery.power_source_s, POWER_SOURCE_AC, len) || - !strncmp(battery.power_source_s, POWER_SOURCE_WIRELESS, len)) { - if (low_battery_type == LOW_BATTERY) { - *active_noti = "BatteryLowActNotiChgOn"; - *event_noti = NULL; - } else if (low_battery_type == CRITICAL_BATTERY) { - *active_noti = "BatteryCriticalActNotiChgOn"; - *event_noti = NULL; + + if (lowbat_popup_option == BAT_OPT_POWEROFF) + launched_poweroff = 1; + + if (battery_do_not_disturb()) { + _I("block LCD and %s Popup", value); + return 0; } - } else if (!strncmp(battery.power_source_s, POWER_SOURCE_USB, len)) { - if (low_battery_type == LOW_BATTERY) { - *active_noti = "BatteryLowActNotiUsbOn"; - *event_noti = NULL; - } else if (low_battery_type == CRITICAL_BATTERY) { - *active_noti = "BatteryCriticalActNotiUsbOn"; - *event_noti = NULL; + if (lowbat_popup_option == BAT_OPT_ERR_TEMP_LOW || + lowbat_popup_option == BAT_OPT_ERR_TEMP_HIGH || + lowbat_popup_option == BAT_OPT_ERR_CF_OPEN) { + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_LOWBAT, LCD_DIM); + } else { + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_LOWBAT, LCD_NORMAL); } - } else { - _E("Invalid power resource type(%s).", battery.power_source_s); - *active_noti = NULL; - *event_noti = NULL; - } - _D("active_noti=%s event_noti=%s", *active_noti, *event_noti); - return ret; + if (lowbat_popup_option == BAT_OPT_ERR_TEMP_LOW || + lowbat_popup_option == BAT_OPT_ERR_TEMP_HIGH || + lowbat_popup_option == BAT_OPT_ERR_CF_OPEN) + return launch_system_app(APP_ABNORMAL, + 2, APP_KEY_TYPE, value); + return launch_system_app(APP_DEFAULT, + 2, APP_KEY_TYPE, value); + } else + _D("Boot-animation running yet."); + + return 0; } -static void event_noti_cb(GVariant *var, void *user_data, GError *err) +static void low_noti_cb(GVariant *var, void *user_data, GError *err) { int id = 0; - if (!var) { - if (err) - _E("Failed to notify event: %s", err->message); + if (!var) return; - } if (!dh_get_param_from_var(var, "(i)", &id)) { - _E("Failed to notify event: no message(%s)", g_variant_get_type_string(var)); + _E("Failed to notify low: no message(%s)", g_variant_get_type_string(var)); goto out; } - event_noti_num = id; - _D("Event noti. id=%d", event_noti_num); + noti_low = id; + _D("Inserted battery low noti : %d", noti_low); out: g_variant_unref(var); } -static void active_noti_cb(GVariant *var, void *user_data, GError *err) +static void critical_noti_cb(GVariant *var, void *user_data, GError *err) { int id = 0; - if (!var) { - if (err) - _E("Failed to notify active: %s", err->message); + if (!var) return; - } if (!dh_get_param_from_var(var, "(i)", &id)) { - _E("Failed to notify active: no message(%s)", g_variant_get_type_string(var)); + _E("Failed to notify critical: no message(%s)", g_variant_get_type_string(var)); goto out; } - active_noti_num = id; - _D("Active noti. id=%d", active_noti_num); + noti_crit = id; + _D("Inserted battery critical noti : %d", noti_crit); out: g_variant_unref(var); } -int lowbat_popup(char *option) +int launch_lowbat_noti(int option) { - static int lowbat_popup_option; - int ret; - int power_source = 1; - static char *value; - char *active_noti = NULL, *event_noti = NULL; - char temp[10] = {0,}; - - if (!option) { - if (!value) - return -1; - else - goto direct_launch; - } - - if (!strcmp(option, WARNING_LOW_BAT_ACT)) { - power_source = get_lowbat_noti_value(LOW_BATTERY, &active_noti, &event_noti); - lowbat_popup_option = LOWBAT_OPT_CHECK; - } else if (!strcmp(option, CRITICAL_LOW_BAT_ACT)) { - power_source = get_lowbat_noti_value(CRITICAL_BATTERY, &active_noti, &event_noti); - lowbat_popup_option = LOWBAT_OPT_WARNING; - } else if (!strcmp(option, CHARGE_ERROR_ACT)) { - value = "chargeerr"; - lowbat_popup_option = LOWBAT_OPT_CHARGEERR; - } else if (!strcmp(option, CHARGE_ERROR_LOW_ACT)) { - value = "chargeerrlow"; - lowbat_popup_option = LOWBAT_OPT_CHARGEERR; - } else if (!strcmp(option, CHARGE_ERROR_HIGH_ACT)) { - value = "chargeerrhigh"; - lowbat_popup_option = LOWBAT_OPT_CHARGEERR; - } else if (!strcmp(option, CHARGE_ERROR_OVP_ACT)) { - value = "chargeerrovp"; - lowbat_popup_option = LOWBAT_OPT_CHARGEERR; - } else - return -1; - -direct_launch: - _D("Popup value=%s", value); - if (booting_done(NULL)) { - - if (battery.charge_now && - (lowbat_popup_option == LOWBAT_OPT_CHECK || - lowbat_popup_option == LOWBAT_OPT_WARNING)) { - _I("Skip low battery popup during charging."); - return 0; + int ret = -EINVAL; + char batcap[10] = {0,}; + char notiid[10] = {0,}; + int noti_id; + const char *pa[2]; + int retry; + char *noti_type = NULL; + static int prev_level = BATTERY_NORMAL; + + snprintf(batcap, sizeof(batcap), "%d", cur_bat_capacity); + pa[0] = batcap; + + if (option == BAT_OPT_WARNING) { + if (noti_crit > 0) { + /* remove waring notiid*/ + noti_id = noti_crit; + for (retry = RETRY_MAX; retry > 0; retry--) { + ret = dbus_handle_method_async_var(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + METHOD_LOW_NOTI_OFF, + g_variant_new("(i)", noti_id)); + if (ret == 0) { + _D("Deleted battery critical noti."); + break; + } else + _E("Failed to call dbus method (err: %d)", ret); + } } - - if (battery_do_not_disturb()) { - _I("block LCD and %s Popup", value); - return 0; + memset(notiid, 0x0, sizeof(notiid)); + snprintf(notiid, sizeof(notiid), "%d", noti_low); + pa[1] = notiid; + if (prev_level == battery_info.critical || noti_low == NOTI_UPDATE) + noti_type = METHOD_LOW_NOTI_UPDATE; + else { + noti_type = METHOD_LOW_NOTI_ON; + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_LOWBAT, LCD_NORMAL); } - - if (lowbat_popup_option == LOWBAT_OPT_CHECK || - lowbat_popup_option == LOWBAT_OPT_WARNING) { - - if (power_source) { - _D("active_noti=%d event_noti=%d", active_noti_num, event_noti_num); - return 0; - } - - if (event_noti_num > 0) { - ret = remove_notification("BatteryLowCriticalNotiOff", event_noti_num); - if (ret < 0) - _E("Failed to remove event_noti: %d", ret); - else - event_noti_num = -1; - } - - ret = add_async_notification(event_noti, event_noti_cb, NULL, NULL); - if (ret < 0) - _E("Failed to launch event_noti: %d", ret); - - if (active_noti_num > 0) { - ret = remove_notification("BatteryLowCriticalNotiOff", active_noti_num); - if (ret < 0) - _E("Failed to launch remove active_noti: %d", ret); - else - active_noti_num = -1; + prev_level = battery_info.warning; + if (battery.charge_now) + ret = dbus_handle_method_async_var(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + noti_type, + g_variant_new("(ss)", pa[0], pa[1])); + else + ret = dbus_handle_method_async_with_reply(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + noti_type, + "ss", pa, low_noti_cb, -1, NULL); + } else if (option == BAT_OPT_CRITICAL) { + if (noti_low > 0) { + /* remove waring notiid*/ + noti_id = noti_low; + for (retry = RETRY_MAX; retry > 0; retry--) { + ret = dbus_handle_method_async_var(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + METHOD_CRITICAL_NOTI_OFF, + g_variant_new("(i)", noti_id)); + if (ret == 0) { + _D("Deleted battery low noti"); + break; + } else + _E("Failed to call dbus method (err: %d)", ret); } + } + memset(notiid, 0x0, sizeof(notiid)); + snprintf(notiid, sizeof(notiid), "%d", noti_crit); + pa[1] = notiid; + if (noti_crit == NOTI_UPDATE) + noti_type = METHOD_CRITICAL_NOTI_UPDATE; + else { + noti_type = METHOD_CRITICAL_NOTI_ON; + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_LOWBAT, LCD_NORMAL); + } + prev_level = battery_info.critical; + if (battery.charge_now) + ret = dbus_handle_method_async_var(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + noti_type, + g_variant_new("(ss)", pa)); + else + ret = dbus_handle_method_async_with_reply(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + noti_type, + "ss", pa, critical_noti_cb, -1, NULL); - snprintf(temp, sizeof(temp), "%d", cur_bat_capacity); - ret = add_async_notification(active_noti, active_noti_cb, "s", temp); - if (ret < 0) - _E("Failed to launch active noti: %d", ret); - - _D("active_noti=%d event_noti=%d", active_noti_num, event_noti_num); - return 0; - } else - return launch_system_app(APP_DEFAULT, - 2, APP_KEY_TYPE, value); - } else { - _D("Boot-animation running yet."); - return -1; - } + } else + prev_level = battery_info.normal; - return 0; + _D("Requested type(%s) id(%s)", noti_type, notiid); + return ret; } static int battery_warning_low_act(void *data) { - return lowbat_popup(WARNING_LOW_BAT_ACT); + (void)launch_lowbat_noti(BAT_OPT_WARNING); + (void)lowbat_popup(BAT_OPT_WARNING); + return 0; } static int battery_critical_low_act(void *data) { - return lowbat_popup(CRITICAL_LOW_BAT_ACT); + (void)launch_lowbat_noti(BAT_OPT_CRITICAL); + (void)lowbat_popup(BAT_OPT_CRITICAL); + return 0; } int battery_power_off_act(void *data) { - power_execute(POWER_POWEROFF); - return 0; + return power_execute(POWER_POWEROFF); } -int battery_charge_err_act(void *data) +int battery_charge_err_cf_act(void *data) { - return lowbat_popup(CHARGE_ERROR_ACT); + return lowbat_popup(BAT_OPT_ERR_CF_OPEN); } int battery_charge_err_low_act(void *data) { - return lowbat_popup(CHARGE_ERROR_LOW_ACT); + return lowbat_popup(BAT_OPT_ERR_TEMP_LOW); } int battery_charge_err_high_act(void *data) { - return lowbat_popup(CHARGE_ERROR_HIGH_ACT); -} - -int battery_charge_err_ovp_act(void *data) -{ - return lowbat_popup(CHARGE_ERROR_OVP_ACT); + return lowbat_popup(BAT_OPT_ERR_TEMP_HIGH); } static void lowbat_scenario_init(void) @@ -450,77 +477,118 @@ static void lowbat_scenario_init(void) lowbat_add_scenario(battery_info.realoff, battery_info.realoff, battery_power_off_act); } -static void lowbat_update_scenario() +static bool check_remove_condition(const char *prev, const char *cur) { - dd_list *n; - dd_list *l = lpe; - - while (l != NULL) { - n = l->next; - lpe = g_list_remove_link(lpe, l); - free(l->data); - g_list_free(l); - l = n; - scenario_count--; - } + int prev_len; + int cur_len; + bool ret = false; + + prev_len = strlen(prev); + cur_len = strlen(cur); + + if (!strncmp(prev, EVT_VAL_BATTERY_LEVEL_CRITICAL,prev_len) && + !strncmp(cur, EVT_VAL_BATTERY_LEVEL_LOW, cur_len)) + ret = true; + else if (!strncmp(prev, EVT_VAL_BATTERY_LEVEL_CRITICAL,prev_len) && + !strncmp(cur, EVT_VAL_BATTERY_LEVEL_HIGH, cur_len)) + ret = true; + else if (!strncmp(prev, EVT_VAL_BATTERY_LEVEL_CRITICAL,prev_len) && + !strncmp(cur, EVT_VAL_BATTERY_LEVEL_FULL, cur_len)) + ret = true; + else if (!strncmp(prev, EVT_VAL_BATTERY_LEVEL_LOW, prev_len) && + !strncmp(cur, EVT_VAL_BATTERY_LEVEL_HIGH, cur_len)) + ret = true; + else if (!strncmp(prev, EVT_VAL_BATTERY_LEVEL_LOW, prev_len) && + !strncmp(cur, EVT_VAL_BATTERY_LEVEL_FULL, cur_len)) + ret = true; - lowbat_scenario_init(); - return; + return ret; } -void clear_noti_if_needed(const char *old_string, const char *new_string) +static void clean_lowbat_noti(const char *prev, const char *str) { - int ret = -1; + int noti_id; + int retry; + int ret; + bool condition; - if (old_string == new_string) + if (!prev || !str) { + _E("There is no data."); return; - - if (event_noti_num > 0) { - ret = remove_notification("BatteryLowCriticalNotiOff", event_noti_num); - if (ret < 0) - _E("Failed to launch remove_event_noti: %d", ret); - else - event_noti_num = -1; } - if (active_noti_num > 0) { - ret = remove_notification("BatteryLowCriticalNotiOff", active_noti_num); - if (ret < 0) - _E("Failed to launch remove_active_noti: %d", ret); - active_noti_num = -1; + if (prev == str && !battery.charge_now) + return; + + condition = check_remove_condition(prev, str); + _D("Condition: %d", condition); + + if (condition || battery.charge_now) { + if (noti_crit > 1) { + /* remove critical notiid */ + noti_id = noti_crit; + for (retry = RETRY_MAX; retry > 0; retry--) { + ret = dbus_handle_method_async_var(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + METHOD_CRITICAL_NOTI_OFF, + g_variant_new("(i)", noti_id)); + if (ret == 0) { + _D("Deleted battery critical noti."); + noti_crit = NOTI_NONE; + break; + } else + _E("Failed to call dbus method: %d", ret); + } + } + + if (noti_low > 1) { + /* remove waring notiid*/ + noti_id = noti_low; + for (retry = RETRY_MAX; retry > 0; retry--) { + ret = dbus_handle_method_async_var(POPUP_BUS_NAME, + POPUP_PATH_BATTERY, + POPUP_INTERFACE_BATTERY, + METHOD_LOW_NOTI_OFF, + g_variant_new("(i)", noti_id)); + if (ret == 0) { + _D("Deleted battery low noti."); + noti_low = NOTI_NONE; + break; + } else + _E("Failed to call dbus method: %d", ret); + } + } } + _D("Noti_crit(%d) noti_low(%d).", noti_crit, noti_low); } static void battery_level_send_system_event(int bat_percent) { - bundle *b; const char *str; static const char *prev; - if (bat_percent >= battery_info.normal && battery.charge_full == CHARGING_FULL) { + if (bat_percent >= battery_info.normal && battery.charge_full == CHARGING_FULL) str = EVT_VAL_BATTERY_LEVEL_FULL; - clear_noti_if_needed(prev, str); - } else if (bat_percent > battery_info.warning) { + else if (bat_percent > battery_info.warning) str = EVT_VAL_BATTERY_LEVEL_HIGH; - clear_noti_if_needed(prev, str); - } else if (bat_percent > battery_info.critical) + else if (bat_percent > battery_info.critical) str = EVT_VAL_BATTERY_LEVEL_LOW; else if (bat_percent > battery_info.poweroff) str = EVT_VAL_BATTERY_LEVEL_CRITICAL; else str = EVT_VAL_BATTERY_LEVEL_EMPTY; + clean_lowbat_noti(prev, str); + if (prev == str) return; prev = str; - _D("system_event=%s", str); - - b = bundle_create(); - bundle_add_str(b, EVT_KEY_BATTERY_LEVEL_STATUS, str); - eventsystem_send_system_event(SYS_EVENT_BATTERY_LEVEL_STATUS, b); - bundle_free(b); + _D("System_event: %s", str); + event_system_send(SYS_EVENT_BATTERY_LEVEL_STATUS, + EVT_KEY_BATTERY_LEVEL_STATUS, str); } static void change_lowbat_level(int bat_percent) @@ -558,6 +626,69 @@ static void change_lowbat_level(int bat_percent) } } +static void lowbat_custom_popup(int online, int capacity) +{ + static int custom_type = BATTERY_UNKNOWN; + + if (custom_type == CUSTOM_CONTROL_NONE) + return; + if (custom_warning_level == BATTERY_UNKNOWN || + custom_warning_level == battery_info.warning) + return; + + if (custom_type == BATTERY_UNKNOWN) { + if (custom_warning_level < battery_info.warning) + custom_type = LOWER_THAN_WARNING; + else if (custom_warning_level > battery_info.warning) + custom_type = HIGHER_THAN_WARNING; + else { + custom_type = CUSTOM_CONTROL_NONE; + _E("Custom type is not defined: %d", custom_warning_level); + return; + } + } + + if (custom_type == LOWER_THAN_WARNING && capacity <= battery_info.critical) + return; + if (custom_type == HIGHER_THAN_WARNING && capacity <= battery_info.warning) + return; + + if (capacity > custom_warning_level) { + custom_warning_launch = false; + return; + } + if (online == battery.online && custom_warning_launch) + return; + if (battery.online > POWER_SUPPLY_TYPE_BATTERY && custom_warning_launch) + return; + + custom_warning_launch = true; + _I("Launch custom lowbattery warning popup. online(%d, %d), capacity(%d, %d)", online, battery.online, capacity, custom_warning_level); + (void)battery_warning_low_act(NULL); +} + +void check_extreme_status(int status) +{ + int extreme = 0; + int ret; + + if (status <= VCONFKEY_SYSMAN_BAT_POWER_OFF || + status > VCONFKEY_SYSMAN_BAT_FULL) + return; + ret = vconf_get_int(VCONFKEY_PM_KEY_IGNORE, &extreme); + if (ret < 0) + _E("Failed to get vconf value for pm key ignore: %d", vconf_get_ext_errno()); + if (ret != 0 || extreme != 1) + return; + + ret = vconf_set_int(VCONFKEY_PM_KEY_IGNORE, 0); + if (ret != 0) { + _E("Failed to set vconf value for pm key ignore: %d", vconf_get_ext_errno()); + return; + } + _I("Release key ignore."); +} + static int lowbat_process(int bat_percent, void *ad) { static int online; @@ -569,12 +700,12 @@ static int lowbat_process(int bat_percent, void *ad) int status = -1; bool low_bat = false; int result = 0; - int lock = -1; new_bat_capacity = bat_percent; if (new_bat_capacity < 0) return -EINVAL; change_lowbat_level(new_bat_capacity); + lowbat_custom_popup(online, new_bat_capacity); battery_level_send_system_event(new_bat_capacity); cur_bat_capacity = new_bat_capacity; @@ -582,13 +713,13 @@ static int lowbat_process(int bat_percent, void *ad) ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &vconf_state); if (ret < 0) { _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); - result = -EIO; - goto exit; + return -EIO; } - // set new_bat_state and status if (new_bat_capacity <= battery_info.realoff) { - if (battery.charge_now) { + if (battery.charge_now == CHARGER_CHARGING || battery.charger_charging == CHARGER_DISABLED) { + _I("Skip lowbat poweroff during test (c:%d charge:%d online:%d charger_charging:%d)", + battery.capacity, battery.charge_now, battery.online, battery.charger_charging); new_bat_state = battery_info.poweroff; if (vconf_state != VCONFKEY_SYSMAN_BAT_POWER_OFF) status = VCONFKEY_SYSMAN_BAT_POWER_OFF; @@ -626,20 +757,13 @@ static int lowbat_process(int bat_percent, void *ad) } if (status != -1) { - if (disp_plgn.pm_lock_internal) - lock = disp_plgn.pm_lock_internal(INTERNAL_LOCK_BATTERY, LCD_OFF, STAY_CUR_STATE, 0); - ret = vconf_set_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, status); - if (ret < 0) - _E("Failed to set vconf value for battery status low: %d", vconf_get_ext_errno()); - power_supply_broadcast(CHARGE_LEVEL_SIGNAL, status); + result = status; if (disp_plgn.update_pm_setting) disp_plgn.update_pm_setting(SETTING_LOW_BATT, status); - } + } else + result = vconf_state; - if (ret < 0) { - result = -EIO; - goto exit; - } + check_extreme_status(status); if (new_bat_capacity <= battery_info.warning) low_bat = true; @@ -649,32 +773,17 @@ static int lowbat_process(int bat_percent, void *ad) low_bat_old = low_bat; } - if (battery.online == POWER_SUPPLY_TYPE_UNKNOWN) { - _E("Battery online is not initialized."); - goto exit; - } - if (cur_bat_state == new_bat_state && - online == battery.online) - goto exit; + if (battery.online == POWER_SUPPLY_TYPE_UNKNOWN) + return result; + if (cur_bat_state == new_bat_state && online == battery.online) + return result; + online = battery.online; if (cur_bat_state == BATTERY_UNKNOWN) cur_bat_state = battery_info.normal; - if (battery.charge_now) { - clear_noti_if_needed("clear", "all"); - result = 1; - } else { - result = lowbat_scenario(cur_bat_state, new_bat_state, NULL); - if (result) - _I("cur=%d new=%d(capacity=%d)", - cur_bat_state, new_bat_state, bat_percent); - } - if (result == 1) + if (lowbat_scenario(cur_bat_state, new_bat_state, NULL)) + _I("Cur(%d) new(%d) capacity(%d).", cur_bat_state, new_bat_state, bat_percent); cur_bat_state = new_bat_state; -exit: - if (lock == 0) { - if (disp_plgn.pm_unlock_internal) - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BATTERY, LCD_OFF, PM_SLEEP_MARGIN); - } return result; } @@ -684,10 +793,8 @@ static int check_lowbat_percent(int *pct) int bat_percent; bat_percent = battery.capacity; - if (bat_percent < 0) { - _E("[BAT_MON] Cannot read battery gage. Stop read fuel gage."); + if (bat_percent < 0) return -ENODEV; - } if (bat_percent > 100) bat_percent = 100; change_lowbat_level(bat_percent); @@ -696,21 +803,21 @@ static int check_lowbat_percent(int *pct) return 0; } -static void lowbat_monitor(void *data) +static int lowbat_monitor(void *data) { int bat_percent, r; r = lowbat_initialized(NULL); if (r != BATTERY_ENABLED) - return; + return battery.charging_level; if (data == NULL) { r = check_lowbat_percent(&bat_percent); if (r < 0) - return; + return battery.charging_level; } else bat_percent = *(int *)data; - lowbat_process(bat_percent, NULL); + return lowbat_process(bat_percent, NULL); } static int lowbat_monitor_init(void *data) @@ -729,9 +836,7 @@ static int lowbat_monitor_init(void *data) /* load battery configuration file */ battery_config_load(&battery_info); - default_battery_warning = battery_info.warning; - - _I("Battery conf normal=%d warning=%d critical=%d poweroff=%d realoff=%d", battery_info.normal, battery_info.warning, + _I("Battery conf: %d %d %d %d %d", battery_info.normal, battery_info.warning, battery_info.critical, battery_info.poweroff, battery_info.realoff); lowbat_scenario_init(); @@ -758,22 +863,20 @@ static GVariant * dbus_set_lowbat_level(GDBusConnection *conn, goto out; } - if (now <= default_battery_warning && now != BATTERY_UNKNOWN) { - _E("Invalid level is requested(%d).", now); + if (now <= battery_info.warning && now != BATTERY_UNKNOWN) { + _E("Invalid level is requested: %d", now); ret = -EINVAL; goto out; } - if (now == battery_info.warning) - goto out; - custom_warning_level = now; + custom_warning_launch = false; ret = vconf_set_int(VCONF_KEY_BATTERY_WARNING_LEVEL, custom_warning_level); if (ret < 0) _E("Failed to set vconf value for battery warning level: %d", vconf_get_ext_errno()); _D("Custom warning level is changed to %d.", custom_warning_level); - lowbat_update_scenario(); + out: return g_variant_new("(i)", ret); } @@ -782,7 +885,7 @@ static GVariant * dbus_get_lowbat_level(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { - _D("Warning level(%d)", custom_warning_level); + _D("Warning level: %d", custom_warning_level); return g_variant_new("(i)", custom_warning_level); } @@ -801,16 +904,15 @@ static const dbus_interface_u dbus_interface = { static int lowbat_probe(void *data) { - struct hw_info *info; - int ret; - - ret = hw_get_info(BATTERY_HARDWARE_DEVICE_ID, - (const struct hw_info **)&info); + static const struct device_ops *ops; + int ret = -EINVAL; - if (ret < 0) /* There is no HAL for battery */ - return -ENODEV; + FIND_DEVICE_INT(ops, "power_supply"); + ret = ops->probe(data); + if (ret == 0) + _I("Support lowbat handler."); - return 0; + return ret; } static void lowbat_init(void *data) @@ -830,13 +932,11 @@ static void lowbat_exit(void *data) int status = BATTERY_DISABLED; lowbat_initialized(&status); - unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); } static int lowbat_execute(void *data) { - lowbat_monitor(data); - return 0; + return lowbat_monitor(data); } static const struct device_ops lowbat_device_ops = { diff --git a/src/battery/lowbat-handler.h b/src/battery/lowbat-handler.h index b24c5d2..658ee14 100644 --- a/src/battery/lowbat-handler.h +++ b/src/battery/lowbat-handler.h @@ -20,7 +20,6 @@ #ifndef __LOWBAT_HANDLER_H__ #define __LOWBAT_HANDLER_H__ -int battery_charge_err_act(void *data); -int lowbat_popup(char *option); +int lowbat_popup(int option); #endif /* __LOWBAT_HANDLER_H__ */ diff --git a/src/battery/power-supply.c b/src/battery/power-supply.c index 1099556..3d8bcb1 100644 --- a/src/battery/power-supply.c +++ b/src/battery/power-supply.c @@ -24,6 +24,7 @@ #include #include #include +#include #include "core/devices.h" #include "core/device-notifier.h" @@ -32,12 +33,25 @@ #include "core/config-parser.h" #include "display/poll.h" #include "display/setting.h" +#include "shared/eventsystem.h" #include "display/core.h" #include "display/display-ops.h" #include "apps/apps.h" #include "power-supply.h" #include "battery.h" +#ifndef VCONFKEY_SETAPPL_BLOCKMODE_WEARABLE_BOOL +#define VCONFKEY_SETAPPL_BLOCKMODE_WEARABLE_BOOL "db/setting/blockmode_wearable" +#endif + +#ifndef VCONFKEY_SETAPPL_THEATER_MODE_ENABLE +#define VCONFKEY_SETAPPL_THEATER_MODE_ENABLE "db/setting/theater_mode_enable" +#endif + +#ifndef VCONFKEY_SETAPPL_GOODNIGHT_MODE_ENABLE +#define VCONFKEY_SETAPPL_GOODNIGHT_MODE_ENABLE "db/setting/goodnight_mode_enable" +#endif + #define BATTERY_NAME "battery" #define CHARGEFULL_NAME "Full" #define CHARGENOW_NAME "Charging" @@ -48,105 +62,131 @@ #define OVERVOLT_NAME "Over voltage" #define GOOD_NAME "Good" -#define REMOVE_POPUP "remove_battery_popups" +#define REMOVE_POPUP "remove_battery_popups" +#define DISCONNECT_POPUP "battdisconnect" -#define BUFF_MAX 255 +#define CHARGER_WIRELESS_TYPE_BT 10 +#define CHARGER_WIRELESS_TYPE_3G 22 +#define CHARGER_INCOMPATIBLE_TYPE 11 +#define WIRELESS_CHARGER_CONNECTED 2 #define SIGNAL_CHARGEERR_RESPONSE "ChargeErrResponse" #define SIGNAL_TEMP_GOOD "TempGood" #define ABNORMAL_CHECK_TIMER_INTERVAL 60 -#define LCD_DIM_TIME_IN_BATTERY_HEALTH 10000 /* ms */ -#define HEALTH_POPUP_TERMINATE_TIMEOUT 10 -#define HEALTH_POPUP_RELAUNCH_TIMEOUT 3600 #define METHOD_FULL_NOTI_ON "BatteryFullNotiOn" #define METHOD_FULL_NOTI_OFF "BatteryFullNotiOff" #define METHOD_CHARGE_NOTI_ON "BatteryChargeNotiOn" +#define CHARGER_CHARGE_ON_NODE "/sys/class/power_supply/battery/chg_on" + #define RETRY_MAX 5 #define BATTERY_CHECK_TIMER_INTERVAL 500 /* 0.5 second */ +#define LCD_DIM_TIME_IN_BATTERY_HEALTH 10000 /* ms */ +#define HEALTH_POPUP_TERMINATE_TIMEOUT 10 +#define HEALTH_POPUP_RELAUNCH_TIMEOUT 3600 + +enum charger_type { + CHARGER_TYPE_NONE = 0, + CHARGER_TYPE_WIRE, + CHARGER_TYPE_WIRELESS, + CHARGER_TYPE_INCOMPATIBLE, +}; -enum power_supply_init_type { - POWER_SUPPLY_NOT_READY = 0, - POWER_SUPPLY_INITIALIZED = 1, +static void uevent_power_handler(struct udev_device *dev); +static const struct uevent_handler uh = { + .subsystem = POWER_SUBSYSTEM, + .uevent_func = uevent_power_handler, }; -struct battery_status battery; -struct battery_status old_battery; static int noti_id; -static guint power_timer; +static int online_status; -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE +static guint power_timer; +static guint abnormal_timer; static guint health_popup_timer; static struct timespec health_relaunch_start_st; static struct timespec health_relaunch_end_st; -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ bool battery_do_not_disturb(void); - static int battery_pm_change_internal(int pid, int s_bits); static int display_changed(void *data); -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE static void health_popup_timer_init(const char *func); static void update_health_popup_relaunch_time(int timeout); static void change_health_popup_timer(enum battery_noti_status status); -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ static int booting_done(void *data); static struct battery_device *battery_dev; -static void lowbat_execute(void *data) +static int load_uevent(struct parse_result *result, void *user_data); +static int event_handler_state_changed(void *data); + +static int lowbat_execute(void *data) { static const struct device_ops *lowbat_ops; - FIND_DEVICE_VOID(lowbat_ops, "lowbat"); - device_execute(lowbat_ops, data); + FIND_DEVICE_INT(lowbat_ops, "lowbat"); + return device_execute(lowbat_ops, data); } -static void pm_check_and_change(int bInserted) +static int power_supply_broadcast_str(char *sig, char *status) { - static int old = -1; + static char old_sig[32]; + static char old_status[32]; + char *str; + int ret; - if (old == bInserted) - return; + if (!sig || !status) { + _E("there is no signal name"); + return -EINVAL; + } - old = bInserted; - battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL); -} + if (strncmp(old_sig, sig, strlen(sig)) == 0 && strncmp(old_status, status, strlen(status)) == 0) + return 0; -static int changed_battery_cf(enum present_type status) -{ - char *value; + snprintf(old_sig, sizeof(old_sig), "%s", sig); + snprintf(old_status, sizeof(old_status), "%s", status); - if (status == PRESENT_ABNORMAL) - value = "battdisconnect"; - else - value = "remove_battery_popups"; + str = status; - return launch_system_app(APP_DEFAULT, - 2, APP_KEY_TYPE, value); + ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_BATTERY, + DEVICED_INTERFACE_BATTERY, + sig, + g_variant_new("(s)", str)); + + if (ret == 0) + return 1; + else + return ret; } -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE -static void health_status_broadcast(void) +static void pm_check_and_change(int bInserted) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, - SIGNAL_TEMP_GOOD, NULL, NULL); -} + static int old = -1; -static guint abnormal_timer; + if (old == bInserted) + return; + old = bInserted; + battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL); +} static void abnormal_popup_timer_init(void) { if (abnormal_timer == 0) return; - g_source_remove(abnormal_timer); abnormal_timer = 0; _I("Delete health timer."); } +static void health_status_broadcast(void) +{ + dbus_handle_broadcast_dbus_signal(DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, + SIGNAL_TEMP_GOOD, NULL, NULL); +} + + static void health_timer_reset(void) { abnormal_timer = 0; @@ -190,7 +230,6 @@ static void abnormal_popup_dbus_signal_handler(GDBusConnection *conn, if (abnormal_timer == 0) _E("Failed to add abnormal check timer."); } -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ static void full_noti_cb(GVariant *var, void *user_data, GError *err) { @@ -226,15 +265,12 @@ out: g_variant_unref(var); } -static int check_power_supply_noti(void) +int check_power_supply_noti(void) { - int block, ret; + int block; - ret = vconf_get_bool("db/setting/blockmode_wearable", &block); - if (ret < 0) { - _E("Failed to get vconf value for blockmode wearable: %d", vconf_get_ext_errno()); + if (vconf_get_bool("db/setting/blockmode_wearable", &block) != 0) return 1; - } if (block == 0) return 1; return 0; @@ -300,7 +336,7 @@ static void charge_noti_on(GVariant *var, void *user_data, GError *err) goto out; } - _D("Inserted battery charge noti(%d)", id); + _D("Inserted battery charge noti: %d", id); out: g_variant_unref(var); @@ -311,9 +347,6 @@ static int send_charge_noti(void) int ret = 0; int retry; - if (battery_do_not_disturb()) - return ret; - for (retry = RETRY_MAX; retry > 0; retry--) { ret = dbus_handle_method_async_with_reply(POPUP_BUS_NAME, POPUP_PATH_NOTI, @@ -339,9 +372,8 @@ static void power_supply_noti(enum battery_noti_type type, enum battery_noti_sta if (status == DEVICE_NOTI_ON && charger == CHARGER_DISCHARGING) { send_charge_noti(); charger = CHARGER_CHARGING; - } else if (status == DEVICE_NOTI_OFF && charger == CHARGER_CHARGING) { + } else if (status == DEVICE_NOTI_OFF && charger == CHARGER_CHARGING) charger = CHARGER_DISCHARGING; - } } else if (type == DEVICE_NOTI_BATT_FULL) { if (status == DEVICE_NOTI_ON && full == CHARGING_NOT_FULL) { ret = send_full_noti(CHARGING_FULL); @@ -355,34 +387,46 @@ static void power_supply_noti(enum battery_noti_type type, enum battery_noti_sta } } -void power_supply_broadcast(char *sig, int status) +int power_supply_broadcast(char *sig, int status) { static int old; static char sig_old[32]; int ret; + int chg_on; if (!sig) { - _E("there is no signal name"); - return; + _E("There is no signal name."); + return -EINVAL; } if (strncmp(sig_old, sig, strlen(sig)) == 0 && old == status) { - _D("Skip broadcasting same signal and status: %s %d", sig, status); - return; + _D("Skip broadcasting same signal(%s) and status(%d).", sig, status); + return 0; } - _D("signal=%s status=%d", sig, status); - old = status; + + if (battery.charger_charging == CHARGER_DISABLED) { + ret = sys_get_int(CHARGER_CHARGE_ON_NODE, &chg_on); + if (ret == 0 && battery.charger_charging != chg_on) { + ret = sys_set_int(CHARGER_CHARGE_ON_NODE, battery.charger_charging); + _I("%s to change status with %d", ((ret == 0) ? "success" : "fail"), battery.charger_charging); + } + if (strncmp(sig, CHARGE_NOW_SIGNAL, strlen(CHARGE_NOW_SIGNAL)) == 0) { + _I("Skip signal while charger disabled."); + return 0; + } + } + snprintf(sig_old, sizeof(sig_old), "%s", sig); - /*snprintf(str_status, sizeof(str_status), "%d", status); - arr[0] = str_status;*/ ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, sig, g_variant_new("(i)", status)); - if (ret < 0) - _E("Failed to send dbus signal(%s)", sig); + if (ret == 0) + return 1; + else + return ret; } static void noti_batt_full(void) @@ -401,9 +445,9 @@ static void noti_batt_full(void) bat_full_noti = 1; /* turn on LCD, if battery is full charged */ noti = check_power_supply_noti(); - if (noti) + if (noti) { battery_pm_change_internal(INTERNAL_LOCK_BATTERY_FULL, LCD_NORMAL); - else + } else _I("Block LCD."); /* on the full charge state */ @@ -420,7 +464,6 @@ static void check_power_supply(int state) static void charger_state_send_system_event(int state) { - bundle *b; const char *str; switch (state) { @@ -438,21 +481,26 @@ static void charger_state_send_system_event(int state) str = EVT_VAL_BATTERY_CHARGER_DISCONNECTED; break; default: - _E("Invalid parameter(%d).", state); + _E("Invalid parameter: %d", state); return; } - _D("system_event(%s)", str); + _D("System_event: %s", str); - b = bundle_create(); - bundle_add_str(b, EVT_KEY_BATTERY_CHARGER_STATUS, str); - eventsystem_send_system_event(SYS_EVENT_BATTERY_CHARGER_STATUS, b); - bundle_free(b); + event_system_send(SYS_EVENT_BATTERY_CHARGER_STATUS, EVT_KEY_BATTERY_CHARGER_STATUS, str); +} + +int changed_battery_cf(int status) +{ + if (status == PRESENT_ABNORMAL) + return launch_system_app(APP_ABNORMAL, 2, APP_KEY_TYPE, DISCONNECT_POPUP); + return launch_system_app(APP_REMOVE, 2, APP_KEY_TYPE, REMOVE_POPUP); } static void update_present(enum battery_noti_status status) { - _I("charge=%d present=%d", battery.charge_now, battery.present); + + _I("Charge(%d) present(%d)", battery.charge_now, battery.present); if (status == DEVICE_NOTI_ON) { battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM); @@ -468,14 +516,20 @@ static void update_present(enum battery_noti_status status) changed_battery_cf(battery.present); } -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE +void remove_health_popup(void) +{ + launch_system_app(APP_REMOVE, 2, APP_KEY_TYPE, REMOVE_POPUP); +} + static void update_health(enum battery_noti_status status) { - _I("charge=%d health=%d", battery.charge_now, battery.health); + _I("Charge(%d) health(%d)", battery.charge_now, battery.health); if (status == DEVICE_NOTI_ON) { _I("Popup: Battery health status is not good."); battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_POPUP, LCD_DIM); device_notify(DEVICE_NOTIFIER_BATTERY_HEALTH, (void *)&battery.health); if (disp_plgn.pm_unlock_internal) disp_plgn.pm_unlock_internal(INTERNAL_LOCK_POPUP, LCD_OFF, PM_SLEEP_MARGIN); @@ -496,7 +550,7 @@ static void update_health(enum battery_noti_status status) change_health_popup_timer(status); health_status_broadcast(); abnormal_popup_timer_init(); - launch_system_app(APP_DEFAULT, 2, APP_KEY_TYPE, REMOVE_POPUP); + remove_health_popup(); } } @@ -512,7 +566,6 @@ void update_health_popup_relaunch(void) update_health_popup_relaunch_time((HEALTH_POPUP_RELAUNCH_TIMEOUT - delta)); } -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ static void update_ovp(enum battery_noti_status status) { @@ -522,7 +575,7 @@ static void update_ovp(enum battery_noti_status status) return; old = status; - _I("charge %d ovp %d with lcd %s", battery.charge_now, battery.health, + _I("Charge(%d) ovp(%d) with lcd(%s)", battery.charge_now, battery.health, (status == DEVICE_NOTI_ON) ? "dim" : "normal"); device_notify(DEVICE_NOTIFIER_BATTERY_OVP, (void *)&battery.health); @@ -531,7 +584,6 @@ static void update_ovp(enum battery_noti_status status) static void check_abnormal_status(void) { -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE if (battery.health == HEALTH_LOW || battery.health == HEALTH_HIGH) update_health_popup_relaunch(); @@ -541,7 +593,6 @@ static void check_abnormal_status(void) else if ((old_battery.health == HEALTH_LOW || old_battery.health == HEALTH_HIGH) && battery.health != HEALTH_LOW && battery.health != HEALTH_HIGH) update_health(DEVICE_NOTI_OFF); -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ if (old_battery.present != PRESENT_ABNORMAL && battery.present == PRESENT_ABNORMAL) update_present(DEVICE_NOTI_ON); @@ -554,67 +605,71 @@ static void check_abnormal_status(void) update_ovp(DEVICE_NOTI_OFF); } -static void check_online(void) +static bool update_online(void) { - static int old_online; - static int old_charge_status; - int charge_status, ret; - - if (battery.charge_status == CHARGE_STATUS_FULL) - charge_status = CHARGE_STATUS_DISCHARGING; - else - charge_status = battery.charge_status; + int chg_on; + int ret; + bool broadcast = false; + + if (battery.online <= POWER_SUPPLY_TYPE_BATTERY && + battery.charger_charging == CHARGER_DISABLED) { + battery.charger_charging = CHARGER_ENABLED; + ret = sys_get_int(CHARGER_CHARGE_ON_NODE, &chg_on); + if (ret == 0 && battery.charger_charging != chg_on) { + ret = sys_set_int(CHARGER_CHARGE_ON_NODE, battery.charger_charging); + _I("%s to change status with %d", ((ret == 0) ? "success" : "fail"), battery.charger_charging); + } + } if (battery.online > POWER_SUPPLY_TYPE_BATTERY && - old_online == VCONFKEY_SYSMAN_CHARGER_DISCONNECTED) { - old_online = VCONFKEY_SYSMAN_CHARGER_CONNECTED; - ret = vconf_set_int(VCONFKEY_SYSMAN_CHARGER_STATUS, old_online); - if (ret < 0) - _E("Failed to set vconf value for charger status: %d", vconf_get_ext_errno()); - power_supply_broadcast(CHARGER_STATUS_SIGNAL, old_online); - check_power_supply(old_online); + online_status == VCONFKEY_SYSMAN_CHARGER_DISCONNECTED) { + online_status = VCONFKEY_SYSMAN_CHARGER_CONNECTED; + check_power_supply(online_status); charger_state_send_system_event(CHARGE_STATUS_CONNECTED); - if (charge_status != old_charge_status) - charger_state_send_system_event(charge_status); - + if (old_battery.charge_status != battery.charge_status) + charger_state_send_system_event(battery.charge_status); + broadcast = true; } else if (battery.online <= POWER_SUPPLY_TYPE_BATTERY && - old_online == VCONFKEY_SYSMAN_CHARGER_CONNECTED) { - old_online = VCONFKEY_SYSMAN_CHARGER_DISCONNECTED; - ret = vconf_set_int(VCONFKEY_SYSMAN_CHARGER_STATUS, old_online); - if (ret < 0) - _E("Failed to set vconf value for charger status: %d", vconf_get_ext_errno()); - power_supply_broadcast(CHARGER_STATUS_SIGNAL, old_online); - check_power_supply(old_online); - if (charge_status != old_charge_status) - charger_state_send_system_event(charge_status); + online_status == VCONFKEY_SYSMAN_CHARGER_CONNECTED) { + online_status = VCONFKEY_SYSMAN_CHARGER_DISCONNECTED; + check_power_supply(online_status); + if (old_battery.charge_status != battery.charge_status) + charger_state_send_system_event(battery.charge_status); charger_state_send_system_event(CHARGE_STATUS_DISCONNECTED); - + broadcast = true; } else { - if (charge_status != old_charge_status) - charger_state_send_system_event(charge_status); + if (old_battery.charge_status != battery.charge_status) + charger_state_send_system_event(battery.charge_status); } - old_charge_status = charge_status; + if (battery.online <= POWER_SUPPLY_TYPE_BATTERY) + battery.online_type = CHARGER_TYPE_NONE; + else if (battery.online == CHARGER_WIRELESS_TYPE_BT || + battery.online == CHARGER_WIRELESS_TYPE_3G) + battery.online_type = CHARGER_TYPE_WIRELESS; + else if (battery.online == CHARGER_INCOMPATIBLE_TYPE) + battery.online_type = CHARGER_TYPE_INCOMPATIBLE; + else + battery.online_type = CHARGER_TYPE_WIRE; + + return broadcast; } static void check_charge_status(const char *env_value) { + int len; + if (env_value == NULL) return; - _D("Charge Status(%s)", env_value); - - if (strncmp(env_value, CHARGEFULL_NAME, - sizeof(CHARGEFULL_NAME)) == 0) + len = strlen(env_value); + if (strncmp(env_value, CHARGEFULL_NAME, len) == 0) battery.charge_status = CHARGE_STATUS_FULL; - else if (strncmp(env_value, CHARGENOW_NAME, - sizeof(CHARGENOW_NAME)) == 0) + else if (strncmp(env_value, CHARGENOW_NAME, len) == 0) battery.charge_status = CHARGE_STATUS_CHARGING; - else if (strncmp(env_value, DISCHARGE_NAME, - sizeof(DISCHARGE_NAME)) == 0) + else if (strncmp(env_value, DISCHARGE_NAME, len) == 0) battery.charge_status = CHARGE_STATUS_DISCHARGING; - else if (strncmp(env_value, NOTCHARGE_NAME, - sizeof(NOTCHARGE_NAME)) == 0) + else if (strncmp(env_value, NOTCHARGE_NAME, len) == 0) battery.charge_status = CHARGE_STATUS_NOT_CHARGING; else battery.charge_status = CHARGE_STATUS_UNKNOWN; @@ -639,6 +694,8 @@ static void check_charge_status(const char *env_value) static void check_health_status(const char *env_value) { + int len; + if (env_value == NULL) { battery.health = HEALTH_GOOD; return; @@ -646,22 +703,28 @@ static void check_health_status(const char *env_value) snprintf(battery.health_s, sizeof(battery.health_s), "%s", env_value); - if (strncmp(env_value, OVERHEAT_NAME, - sizeof(OVERHEAT_NAME)) == 0) + len = strlen(env_value); + if (strncmp(env_value, OVERHEAT_NAME, len) == 0) battery.health = HEALTH_HIGH; - else if (strncmp(env_value, TEMPCOLD_NAME, - sizeof(TEMPCOLD_NAME)) == 0) + else if (strncmp(env_value, TEMPCOLD_NAME, len) == 0) battery.health = HEALTH_LOW; - else if (strncmp(env_value, OVERVOLT_NAME, - sizeof(OVERVOLT_NAME)) == 0) + else if (strncmp(env_value, OVERVOLT_NAME, len) == 0) battery.health = HEALTH_OVP; - else if (strncmp(env_value, GOOD_NAME, - sizeof(GOOD_NAME)) == 0) + else if (strncmp(env_value, GOOD_NAME, len) == 0) battery.health = HEALTH_GOOD; else battery.health = HEALTH_NO_OPT; } +static void check_misc_status(const char *env_value) +{ + if (env_value == NULL) { + battery.misc = MISC_NONE; + return; + } + battery.misc = atoi(env_value); +} + static void check_online_status(const char *env_value) { if (env_value == NULL) @@ -687,42 +750,163 @@ static void check_capacity_status(const char *env_value) static void process_power_supply(void *data) { + bool broadcasted = true; + int lock = -1; int ret; + _D("process_power_supply()"); + if (disp_plgn.pm_lock_internal) { + lock = disp_plgn.pm_lock_internal(INTERNAL_LOCK_BATTERY, LCD_OFF, STAY_CUR_STATE, 0); if (old_battery.charge_now != battery.charge_now || battery.charge_now == CHARGER_ABNORMAL) { - ret = vconf_set_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, battery.charge_now); - if (ret < 0) { - _E("Failed to set vconf value for battery charge now: %d", vconf_get_ext_errno()); - return; + ret = vconf_set_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, battery.charge_now); + if (ret < 0) + _E("Failed to set vconf value for battery charge now: %d", vconf_get_ext_errno()); + + if (power_supply_broadcast(CHARGE_NOW_SIGNAL, battery.charge_now) < 0) + broadcasted = false; } - power_supply_broadcast(CHARGE_NOW_SIGNAL, battery.charge_now); } + if (old_battery.charge_full != battery.charge_full) + if (power_supply_broadcast(CHARGE_FULL_SIGNAL, battery.charge_full) < 0) + broadcasted = false; + + if (strncmp(old_battery.health_s, battery.health_s, strlen(battery.health_s))) + if (power_supply_broadcast_str(CHARGE_HEALTH_SIGNAL, battery.health_s) < 0) + broadcasted = false; + if (old_battery.capacity != battery.capacity) { ret = vconf_set_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, battery.capacity); if (ret < 0) _E("Failed to set vconf value for battery capacity: %d", vconf_get_ext_errno()); - power_supply_broadcast(CHARGE_CAPACITY_SIGNAL, battery.capacity); + + if (power_supply_broadcast(CHARGE_CAPACITY_SIGNAL, battery.capacity) < 0) + broadcasted = false; + } + battery.charging_level = lowbat_execute(data); + if (battery.charging_level > 0 && old_battery.charging_level != battery.charging_level) { + ret = vconf_set_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, battery.charging_level); + if (ret < 0) + _E("Failed to set vconf value for battery capacity: %d", vconf_get_ext_errno()); + + if (power_supply_broadcast(CHARGE_LEVEL_SIGNAL, battery.charging_level) < 0) + broadcasted = false; + } + + if (update_online()) { + ret = vconf_set_int(VCONFKEY_SYSMAN_CHARGER_STATUS, online_status); + if (ret < 0) + _E("Failed to set vconf value for charger status: %d", vconf_get_ext_errno()); + + if (power_supply_broadcast(CHARGER_STATUS_SIGNAL, online_status) < 0) + broadcasted = false; + } + + if (old_battery.online_type != battery.online_type) { + if (power_supply_broadcast(CHARGER_TYPE_SIGNAL, battery.online_type) < 0) + broadcasted = false; } - lowbat_execute(data); - check_online(); + if (old_battery.misc != battery.misc) + if (power_supply_broadcast(CHARGE_MISC_EVENT_SIGNAL, battery.misc) < 0) + broadcasted = false; + if (old_battery.charge_full != battery.charge_full) noti_batt_full(); + if (old_battery.charge_now != battery.charge_now || + old_battery.charge_full != battery.charge_full || + old_battery.capacity != battery.capacity || + old_battery.health != battery.health || + old_battery.misc != battery.misc || + old_battery.online_type != battery.online_type) + _I("Signal(%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d : %s)", + broadcasted, + CHARGER_STATUS_SIGNAL, online_status, + CHARGER_TYPE_SIGNAL, battery.online_type, + CHARGE_NOW_SIGNAL, battery.charge_now, + CHARGE_FULL_SIGNAL, battery.charge_full, + CHARGE_CAPACITY_SIGNAL, battery.capacity, + CHARGE_LEVEL_SIGNAL, battery.charging_level, + CHARGE_MISC_EVENT_SIGNAL, battery.misc, + CHARGE_HEALTH_SIGNAL, battery.health, battery.health_s); + old_battery.capacity = battery.capacity; + old_battery.charging_level = battery.charging_level; old_battery.online = battery.online; + old_battery.online_type = battery.online_type; old_battery.charge_status = battery.charge_status; - old_battery.charge_now = battery.charge_now; old_battery.charge_full = battery.charge_full; check_abnormal_status(); old_battery.health = battery.health; + old_battery.misc = battery.misc; old_battery.present = battery.present; snprintf(old_battery.health_s, sizeof(old_battery.health_s), "%s", battery.health_s); + device_notify(DEVICE_NOTIFIER_POWER_SUPPLY, NULL); + if (old_battery.charge_now != battery.charge_now) { device_notify(DEVICE_NOTIFIER_BATTERY_CHARGING, &battery.charge_now); + old_battery.charge_now = battery.charge_now; + } + if (lock == 0) { + if (disp_plgn.pm_unlock_internal) + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BATTERY, LCD_OFF, PM_SLEEP_MARGIN); + } +} + +static void uevent_power_handler(struct udev_device *dev) +{ + struct udev_list_entry *list_entry; + const char *env_name; + const char *env_value; + bool matched = false; + int ret; + + udev_list_entry_foreach(list_entry, + udev_device_get_properties_list_entry(dev)) { + env_name = udev_list_entry_get_name(list_entry); + if (!env_name) + continue; + + if (!strncmp(env_name, CHARGE_NAME, sizeof(CHARGE_NAME))) { + env_value = udev_list_entry_get_value(list_entry); + if (!env_value) + continue; + if (!strncmp(env_value, BATTERY_NAME, + sizeof(BATTERY_NAME))) { + matched = true; + break; + } + } + } + + if (!matched) + return; + + env_value = udev_device_get_property_value(dev, CHARGE_STATUS); + check_charge_status(env_value); + env_value = udev_device_get_property_value(dev, CHARGE_ONLINE); + check_online_status(env_value); + env_value = udev_device_get_property_value(dev, CHARGE_HEALTH); + check_health_status(env_value); + env_value = udev_device_get_property_value(dev, CHARGE_MISC_EVENT); + check_misc_status(env_value); + env_value = udev_device_get_property_value(dev, CHARGE_PRESENT); + check_present_status(env_value); + env_value = udev_device_get_property_value(dev, CAPACITY); + check_capacity_status(env_value); + + ret = booting_done(NULL); + if (ret) { + if (battery.online > POWER_SUPPLY_TYPE_BATTERY) + power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_ON); + else + power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_OFF); + } + + process_power_supply(&battery.capacity); } static int battery_state(struct battery_info *info) @@ -751,6 +935,18 @@ static int battery_state(struct battery_info *info) prev_status.present = battery.present; prev_status.online = battery.online; + _I("%s(%s) %s(%d) Capa(%d) Hth(%s,%d) Pres(%d) Curr(%d,%d)", + info->status, + battery.charge_now == CHARGER_CHARGING ? "Charging" + : (battery.charge_now == CHARGER_DISCHARGING ? "Discharging" : "Abnormal"), + info->power_source, + info->online, + info->capacity, + info->health, + battery.health, + info->present, + info->current_now, + info->current_average); return 1; } @@ -788,8 +984,6 @@ static void battery_changed(struct battery_info *info, void *data) battery.capacity = info->capacity; battery.current_now = info->current_now; battery.current_average = info->current_average; - battery.voltage_now = info->voltage_now; - battery.voltage_average = info->voltage_average; battery.temperature = info->temperature; ret = battery_state(info); @@ -797,8 +991,8 @@ static void battery_changed(struct battery_info *info, void *data) return; ret = booting_done(NULL); - if (ret) { - if (battery.online > POWER_SUPPLY_TYPE_BATTERY) + if (ret && old_battery.online != battery.online) { + if (battery.online > POWER_SUPPLY_TYPE_BATTERY && battery.charge_now == CHARGER_CHARGING) power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_ON); else power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_OFF); @@ -822,6 +1016,15 @@ static void power_supply_status_init(void) _E("Failed to get battery capacity (capa: %d, ret: %d)", battery.capacity, r); return; } + } else { + r = config_parse(POWER_SUPPLY_UEVENT, load_uevent, &battery); + if (r < 0) { + _E("Failed to load %s, %d Use default value.", POWER_SUPPLY_UEVENT, r); + return; + } + battery.health = HEALTH_GOOD; + battery.present = PRESENT_NORMAL; + process_power_supply(&battery.capacity); } } @@ -838,13 +1041,15 @@ static void power_supply_timer_start(void) power_supply_update, NULL); if (power_timer == 0) _E("Failed to add battery init timer during booting."); + else + _I("Started battery init timer during booting."); } static void power_supply_timer_stop(void) { - _D("Battery init timer during booting."); - if (!power_timer) + if (power_timer == 0) return; + _I("Stop battery init timer during booting."); g_source_remove(power_timer); power_timer = 0; } @@ -863,6 +1068,47 @@ static GVariant *dbus_get_charger_status(GDBusConnection *conn, return g_variant_new("(i)", status); } +static GVariant *dbus_get_charger_type(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int type = battery.online_type; + + return g_variant_new("(i)", type); +} + +static GVariant *dbus_charger_charging(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int ret = 0; + int val; + int chg_on; + + g_variant_get(param, "(i)", &val); + + if (val != CHARGER_ENABLED && val != CHARGER_DISABLED) { + _E("There is no valid input: %d", battery.charger_charging); + ret = -EINVAL; + goto out; + } + if (battery.online <= POWER_SUPPLY_TYPE_BATTERY) { + _E("There is no charger(%d) input(%d).", battery.online, battery.charger_charging); + ret = -EACCES; + goto out; + } + ret = sys_get_int(CHARGER_CHARGE_ON_NODE, &chg_on); + if (ret == 0 && val != chg_on) { + battery.charger_charging = val; + ret = sys_set_int(CHARGER_CHARGE_ON_NODE, battery.charger_charging); + _I("%s to change status with %d.", ((ret == 0) ? "success" : "fail"), battery.charger_charging); + } else { + _I("Skip change status with %d (ret %d prev %d)", val, ret, battery.charger_charging); + } +out: + return g_variant_new("(i)", ret); +} + static GVariant *dbus_get_charge_now(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) @@ -874,19 +1120,19 @@ static GVariant *dbus_get_charge_now(GDBusConnection *conn, return g_variant_new("(i)", ret); } -static GVariant *dbus_get_status_low(GDBusConnection *conn, +static GVariant *dbus_get_charge_level(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { - int ret, status; + int ret, val; - ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &status); + ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &val); if (ret < 0) { _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); - status = -EIO; + val = -EIO; } - return g_variant_new("(i)", status); + return g_variant_new("(i)", val); } static GVariant *dbus_get_percent(GDBusConnection *conn, @@ -926,9 +1172,20 @@ static GVariant *dbus_get_health(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { + const char *str; + + str = battery.health_s; + + return g_variant_new("(s)", str); +} + +static GVariant *dbus_get_misc(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ int ret; - ret = battery.health; + ret = battery.misc; return g_variant_new("(i)", ret); } @@ -941,15 +1198,16 @@ static GVariant *dbus_power_supply_handler(GDBusConnection *conn, int ret = 0; int argc = 0; char *type_str; - char *argv[5]; + char *argv[6]; - g_variant_get(param, "(sisssss)", &type_str, + g_variant_get(param, "(sissssss)", &type_str, &argc, &argv[0], &argv[1], &argv[2], &argv[3], - &argv[4]); + &argv[4], + &argv[5]); if (argc < 0) { _E("Message is invalid."); @@ -968,14 +1226,28 @@ static GVariant *dbus_power_supply_handler(GDBusConnection *conn, check_health_status(argv[2]); check_online_status(argv[3]); check_present_status(argv[4]); - _I("capa=%d full=%d now=%d health=%d online=%d present=%d temp=%d", + check_misc_status(argv[5]); + if (battery_dev) + battery_changed(NULL, NULL); + snprintf(battery.status_s, sizeof(battery.status_s), "%s", + (battery.charge_now == CHARGER_CHARGING) ? "Charging" : + (battery.charge_now == CHARGER_ABNORMAL) ? "Not Charging" : + (battery.charge_full == CHARGING_FULL) ? "Full" : + "Discharging"); + _I("%s(%d) %s(f:%d n:%d) %s(%d) %s(%d) %s(%d) %s(%d)", + argv[0], battery.capacity, + argv[1], battery.charge_full, battery.charge_now, + argv[2], battery.health, + argv[3], battery.online, + argv[4], battery.present, - battery.temperature); + argv[5], + battery.misc); if (battery.online > POWER_SUPPLY_TYPE_BATTERY) power_supply_noti(DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_ON); @@ -990,6 +1262,7 @@ out: g_free(argv[2]); g_free(argv[3]); g_free(argv[4]); + g_free(argv[5]); return g_variant_new("(i)", ret); } @@ -1009,18 +1282,17 @@ static void battery_get_info(struct battery_info *info, void *data) bat->capacity = info->capacity; bat->current_now = info->current_now; bat->current_average = info->current_average; - bat->voltage_now = info->voltage_now; - bat->voltage_average = info->voltage_average; - bat->temperature = info->temperature; } static GVariant *dbus_get_battery_info(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { - int ret; - struct battery_info info = { 0, }; + int ret, val; + const char *str; + struct battery_info info = {0, }; + if (battery_dev && battery_dev->get_current_state) { ret = battery_dev->get_current_state(battery_get_info, &info); if (ret < 0) _E("Failed to get battery info: %d", ret); @@ -1029,6 +1301,21 @@ static GVariant *dbus_get_battery_info(GDBusConnection *conn, free(info.status); free(info.health); free(info.power_source); + } else { + if (vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &val) == 0 && + val != VCONFKEY_SYSMAN_USB_DISCONNECTED) + str = POWER_SOURCE_USB; + else if (vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &val) == 0 && + val == VCONFKEY_SYSMAN_CHARGER_CONNECTED) + str = POWER_SOURCE_AC; + else + str = POWER_SOURCE_NONE; + snprintf(battery.power_source_s, sizeof(battery.power_source_s), "%s", str); + + battery.current_now = -1; /* Not supported */ + battery.current_average = -1; /* Not supported */ + ret = 0; + } return g_variant_new("(isssiiiiiiii)", ret, battery.status_s, @@ -1044,17 +1331,41 @@ static GVariant *dbus_get_battery_info(GDBusConnection *conn, battery.temperature); } +static void update_battery_props(void) +{ + if (config_parse(POWER_SUPPLY_UEVENT, load_uevent, &battery) < 0) + _E("Failed to check power supply uevent."); +} + +static GVariant *dbus_get_battery_props(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + update_battery_props(); + + return g_variant_new("(iiiiii)", + battery.capacity, + battery.temperature, + battery.voltage_now, + battery.voltage_average, + battery.current_now, + battery.current_average); +} + static const dbus_method_s dbus_methods[] = { { CHARGER_STATUS_SIGNAL, NULL, "i", dbus_get_charger_status }, { CHARGE_NOW_SIGNAL, NULL, "i", dbus_get_charge_now }, - { CHARGE_LEVEL_SIGNAL, NULL, "i", dbus_get_status_low }, + { CHARGE_LEVEL_SIGNAL, NULL, "i", dbus_get_charge_level }, { CHARGE_CAPACITY_SIGNAL, NULL, "i", dbus_get_percent }, { CHARGE_CAPACITY_LAW_SIGNAL, NULL, "i", dbus_get_percent_raw }, { CHARGE_FULL_SIGNAL, NULL, "i", dbus_is_full }, - { CHARGE_HEALTH_SIGNAL, NULL, "i", dbus_get_health }, - { POWER_SUBSYSTEM, "sisssss", "i", dbus_power_supply_handler }, + { CHARGE_HEALTH_SIGNAL, NULL, "s", dbus_get_health }, + { POWER_SUBSYSTEM, "sissssss", "i", dbus_power_supply_handler }, { "GetBatteryInfo", NULL, "isssiiiiiiii", dbus_get_battery_info }, - /* Add methods here */ + { CHARGER_TYPE_SIGNAL, NULL, "i", dbus_get_charger_type }, + { "ChargerCharging", "i", "i", dbus_charger_charging }, + { CHARGE_BATTERY_PROPERTIES, NULL, "iiiiii", dbus_get_battery_props }, + { CHARGE_MISC_EVENT_SIGNAL, NULL, "i", dbus_get_misc }, }; static const dbus_interface_u dbus_interface = { @@ -1067,6 +1378,7 @@ static const dbus_interface_u dbus_interface = { static int booting_done(void *data) { static int done; + device_notifier_state_e state = DEVICE_NOTIFIER_STATE_START; if (data == NULL) return done; @@ -1074,18 +1386,23 @@ static int booting_done(void *data) if (done == 0) return done; - _I("Booting done."); - power_supply_timer_stop(); + event_handler_state_changed((void *)&state); - /* for simple noti change cb */ - power_supply_status_init(); - process_power_supply(NULL); + _I("booting done %s(%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d) %s(%d : %s)", + CHARGER_STATUS_SIGNAL, online_status, + CHARGE_NOW_SIGNAL, battery.charge_now, + CHARGE_FULL_SIGNAL, battery.charge_full, + CHARGE_CAPACITY_SIGNAL, battery.capacity, + CHARGE_LEVEL_SIGNAL, battery.charging_level, + CHARGE_MISC_EVENT_SIGNAL, battery.misc, + CHARGE_HEALTH_SIGNAL, battery.health, battery.health_s); + + unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); return done; } -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE static gboolean update_health_pm_status(void *data) { battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_OFF); @@ -1102,9 +1419,9 @@ static void change_health_popup_timer(enum battery_noti_status status) if (status == DEVICE_NOTI_ON) { health_popup_timer = g_timeout_add_seconds(HEALTH_POPUP_TERMINATE_TIMEOUT, update_health_pm_status, NULL); if (health_popup_timer == 0) - _E("fail to add battery init timer during booting"); + _E("Failed to add battery init timer during booting."); else - _I("turn off after %d sec by abnormal health condition", HEALTH_POPUP_TERMINATE_TIMEOUT); + _I("Turn off after %d sec by abnormal health condition.", HEALTH_POPUP_TERMINATE_TIMEOUT); return; } health_popup_timer_init(__func__); @@ -1112,7 +1429,7 @@ static void change_health_popup_timer(enum battery_noti_status status) static void launch_health_popup(void) { - _I("popup - Health is not good(health %s)", (battery.health == HEALTH_HIGH) ? "TempHigh" : "TempLow"); + _I("Popup - Health is not good(health %s)", (battery.health == HEALTH_HIGH) ? "TempHigh" : "TempLow"); health_popup_timer_init(__func__); device_notify(DEVICE_NOTIFIER_BATTERY_HEALTH, (void *)&battery.health); battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL); @@ -1127,7 +1444,6 @@ static void launch_health_popup(void) else if (battery.health == HEALTH_HIGH) battery_charge_err_high_act(NULL); } -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ bool battery_do_not_disturb(void) { @@ -1137,11 +1453,17 @@ bool battery_do_not_disturb(void) if (display_changed(NULL) == S_LCDOFF) { r = vconf_get_bool(VCONFKEY_SETAPPL_BLOCKMODE_WEARABLE_BOOL, &block); if (r < 0) - _E("Failed to set vconf value for charger status: %d", vconf_get_ext_errno()); + _E("Failed to set vconf value for blockmode wearable: %d", vconf_get_ext_errno()); + r = vconf_get_bool(VCONFKEY_SETAPPL_THEATER_MODE_ENABLE, &block); + if (r < 0) + _E("Failed to set vconf value for theator mode enable: %d", vconf_get_ext_errno()); + r = vconf_get_bool(VCONFKEY_SETAPPL_GOODNIGHT_MODE_ENABLE, &block); + if (r < 0) + _E("Failed to set vconf value for goodnight mode enable: %d", vconf_get_ext_errno()); } if (block != 0) { - _I("Skip lcd and popup(block %d)", block); + _I("Skip lcd and popup(block %d).", block); return true; } @@ -1159,7 +1481,6 @@ static int battery_pm_change_internal(int pid, int s_bits) return 0; } -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE static gboolean change_health_pm_normal(void *data) { battery_pm_change_internal(INTERNAL_LOCK_POPUP, LCD_NORMAL); @@ -1176,7 +1497,7 @@ static void update_health_popup_relaunch_time(int timeout) if (health_popup_timer == 0) _E("Failed to add battery init timer during booting."); else - _D("Relaunch timeout with %d sec", timeout); + _D("Relaunch timeout with %d sec.", timeout); } static void health_popup_timer_init(const char *func) @@ -1188,7 +1509,6 @@ static void health_popup_timer_init(const char *func) health_popup_timer = 0; _D("init by %s", func); } -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ static int display_changed(void *data) { @@ -1200,7 +1520,6 @@ static int display_changed(void *data) state = *(int *)data; -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE if (battery.health != HEALTH_LOW && battery.health != HEALTH_HIGH) goto out; @@ -1213,13 +1532,53 @@ static int display_changed(void *data) goto out; } launch_health_popup(); -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ out: old = state; return 0; } +static int load_uevent(struct parse_result *result, void *user_data) +{ + struct battery_status *info = user_data; + + if (!info) + return -EINVAL; + + if (MATCH(result->name, CHARGE_STATUS)) { + if (strstr(result->value, "Charging")) { + info->charge_now = CHARGER_CHARGING; + info->charge_full = CHARGING_NOT_FULL; + } else if (strstr(result->value, "Discharging")) { + info->charge_now = CHARGER_DISCHARGING; + info->charge_full = CHARGING_NOT_FULL; + } else if (strstr(result->value, "Full")) { + info->charge_now = CHARGER_DISCHARGING; + info->charge_full = CHARGING_FULL; + } else if (strstr(result->value, "Not charging")) { + info->charge_now = CHARGER_ABNORMAL; + info->charge_full = CHARGING_NOT_FULL; + } + snprintf(info->status_s, sizeof(info->status_s), "%s", result->value); + } else if (MATCH(result->name, CAPACITY)) { + info->capacity = atoi(result->value); + } else if (MATCH(result->name, TEMPERATURE)) { + info->temperature = atoi(result->value); + } else if (MATCH(result->name, VOLTAGE_NOW)) { + info->voltage_now = atoi(result->value); + } else if (MATCH(result->name, VOLTAGE_AVG)) { + info->voltage_average = atoi(result->value); + } else if (MATCH(result->name, CURRENT_NOW)) { + info->current_now = atoi(result->value); + } else if (MATCH(result->name, CURRENT_AVG)) { + info->current_average = atoi(result->value); + } else if (MATCH(result->name, CHARGE_HEALTH)) { + snprintf(info->health_s, sizeof(info->health_s), "%s", result->value); + } + + return 0; +} + static int power_supply_probe(void *data) { struct hw_info *info; @@ -1230,27 +1589,26 @@ static int power_supply_probe(void *data) ret = hw_get_info(BATTERY_HARDWARE_DEVICE_ID, (const struct hw_info **)&info); - if (ret < 0) { - _E("Failed to load battery shared library: %d", ret); + if (ret < 0) { /* There is no HAL for battery */ + if (access(POWER_PATH, R_OK) == 0) + return 0; /* Just power_supply uevent is used */ goto out; } if (!info->open) { _E("Failed to open battery device: open(NULL)"); - ret = -ENODEV; - goto out; + return -ENODEV; } ret = info->open(info, NULL, (struct hw_common**)&battery_dev); if (ret < 0) { _E("Failed to get battery device structure: %d", ret); - goto out; + return ret; } if (!battery_dev || !battery_dev->get_current_state) { _E("get_current_state() is not supported by the Battery HAL."); - ret = -ENODEV; - goto out; + return -ENODEV; } _I("Battery device structure load success."); @@ -1276,17 +1634,29 @@ out: static void add_power_supply_handler(void) { - if (battery_dev->register_changed_event) - battery_dev->register_changed_event(battery_changed, NULL); + int ret; + + if (battery_dev) { + if (battery_dev->register_changed_event) + battery_dev->register_changed_event(battery_changed, NULL); + if (battery_dev->get_current_state) + battery_dev->get_current_state(battery_changed, NULL); + } else { + ret = config_parse(POWER_SUPPLY_UEVENT, load_uevent, &battery); + if (ret < 0) + _E("Failed to load %s, %d Use default value!", POWER_SUPPLY_UEVENT, ret); - /* already checked in power_supply_probe() */ - battery_dev->get_current_state(battery_changed, NULL); + /* register power subsystem */ + register_kernel_uevent_control(&uh); + } } static void remove_power_supply_handler(void) { - if (battery_dev->unregister_changed_event) + if (battery_dev) battery_dev->unregister_changed_event(battery_changed); + else + unregister_kernel_uevent_control(&uh); } static int event_handler_state_changed(void *data) @@ -1310,11 +1680,12 @@ static int event_handler_state_changed(void *data) static void power_supply_init(void *data) { int ret; - device_notifier_state_e state = DEVICE_NOTIFIER_STATE_START; + memset(&battery, 0, sizeof(struct battery_status)); + memset(&old_battery, 0, sizeof(struct battery_status)); battery.capacity = -1; - - event_handler_state_changed((void *)&state); + battery.charger_charging = CHARGER_ENABLED; + battery.misc = MISC_NONE; /* process check battery timer until booting done */ power_supply_timer_start(); @@ -1328,20 +1699,16 @@ static void power_supply_init(void *data) _E("Failed to init dbus method: %d", ret); -#ifdef TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE ret = subscribe_dbus_signal(NULL, DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_CHARGEERR_RESPONSE, abnormal_popup_dbus_signal_handler, NULL, NULL); if (ret <= 0) _E("Failed to init dbus signal: %d", ret); -#endif /* TIZEN_FEATURE_BATTERY_OVER_TEMPERATURE */ } static void power_supply_exit(void *data) { device_notifier_state_e state = DEVICE_NOTIFIER_STATE_STOP; - unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); - unregister_notifier(DEVICE_NOTIFIER_LCD, display_changed); unregister_notifier(DEVICE_NOTIFIER_EVENT_HANDLER, event_handler_state_changed); event_handler_state_changed((void *)&state); diff --git a/src/battery/power-supply.h b/src/battery/power-supply.h index 3f529ae..8c62417 100644 --- a/src/battery/power-supply.h +++ b/src/battery/power-supply.h @@ -20,9 +20,11 @@ #ifndef __POWER_SUPPLY_H__ #define __POWER_SUPPLY_H__ +#define CHARGER_TYPE_SIGNAL "ChargerType" + enum device_change_type { - DEVICE_CHANGE_ABNORMAL = 0, - DEVICE_CHANGE_NORMAL = 1, + DEVICE_CHANGE_ABNORMAL, + DEVICE_CHANGE_NORMAL, }; enum charge_status_type { @@ -34,14 +36,16 @@ enum charge_status_type { CHARGE_STATUS_NOT_CHARGING, CHARGE_STATUS_FULL, }; + enum charge_full_type { - CHARGING_NOT_FULL = 0, - CHARGING_FULL = 1, + CHARGING_NOT_FULL, + CHARGING_FULL, }; + enum charge_now_type { CHARGER_ABNORMAL = -1, - CHARGER_DISCHARGING = 0, - CHARGER_CHARGING = 1, + CHARGER_DISCHARGING, + CHARGER_CHARGING, }; enum health_type { @@ -54,20 +58,30 @@ enum health_type { }; enum present_type { - PRESENT_ABNORMAL = 0, - PRESENT_NORMAL = 1, + PRESENT_ABNORMAL, + PRESENT_NORMAL, +}; + +enum misc_type { + MISC_NONE, + MISC_MOISTURE, }; enum battery_noti_type { - DEVICE_NOTI_BATT_CHARGE = 0, + DEVICE_NOTI_BATT_CHARGE, DEVICE_NOTI_BATT_LOW, DEVICE_NOTI_BATT_FULL, DEVICE_NOTI_MAX, }; enum battery_noti_status { - DEVICE_NOTI_OFF = 0, - DEVICE_NOTI_ON = 1, + DEVICE_NOTI_OFF, + DEVICE_NOTI_ON, +}; + +enum charger_charging_status { + CHARGER_DISABLED, + CHARGER_ENABLED, }; struct battery_status { @@ -77,21 +91,25 @@ struct battery_status { int charge_now; int health; int present; + int voltage_now; + int voltage_average; int online; + int online_type; int temperature; int current_now; int current_average; - int voltage_now; - int voltage_average; + int charging_level; + int charger_charging; + int misc; char status_s[32]; char health_s[32]; char power_source_s[32]; }; -extern struct battery_status battery; -extern struct battery_status old_battery; +struct battery_status battery; +struct battery_status old_battery; -void power_supply_broadcast(char *sig, int status); +int power_supply_broadcast(char *sig, int status); #define CHARGER_STATUS_SIGNAL "ChargerStatus" #define CHARGE_NOW_SIGNAL "ChargeNow" @@ -100,5 +118,7 @@ void power_supply_broadcast(char *sig, int status); #define CHARGE_CAPACITY_LAW_SIGNAL "GetPercentRaw" #define CHARGE_HEALTH_SIGNAL "GetHealth" #define CHARGE_FULL_SIGNAL "IsFull" +#define CHARGE_BATTERY_PROPERTIES "BatteryProperties" +#define CHARGE_MISC_EVENT_SIGNAL "MiscEvent" #endif /* __POWER_SUPPLY_H__ */ diff --git a/src/core/udev.h b/src/core/udev.h index 68e94e5..d432766 100644 --- a/src/core/udev.h +++ b/src/core/udev.h @@ -31,12 +31,20 @@ /* battery device */ #define POWER_SUBSYSTEM "power_supply" +#define POWER_PATH "/sys/class/power_supply/battery" +#define POWER_SUPPLY_UEVENT POWER_PATH"/uevent" #define CAPACITY "POWER_SUPPLY_CAPACITY" #define CHARGE_HEALTH "POWER_SUPPLY_HEALTH" #define CHARGE_PRESENT "POWER_SUPPLY_PRESENT" #define CHARGE_NAME "POWER_SUPPLY_NAME" #define CHARGE_STATUS "POWER_SUPPLY_STATUS" #define CHARGE_ONLINE "POWER_SUPPLY_ONLINE" +#define TEMPERATURE "POWER_SUPPLY_TEMP" +#define VOLTAGE_NOW "POWER_SUPPLY_VOLTAGE_NOW" +#define VOLTAGE_AVG "POWER_SUPPLY_VOLTAGE_AVG" +#define CURRENT_NOW "POWER_SUPPLY_CURRENT_NOW" +#define CURRENT_AVG "POWER_SUPPLY_CURRENT_AVG" +#define CHARGE_MISC_EVENT "POWER_SUPPLY_BATT_MISC_EVENT" /* extcon */ #define EXTCON_SUBSYSTEM "extcon" diff --git a/src/display/display-dbus.c b/src/display/display-dbus.c index 308d665..8e1a2eb 100644 --- a/src/display/display-dbus.c +++ b/src/display/display-dbus.c @@ -1091,7 +1091,7 @@ static const dbus_method_s dbus_methods[] = { { "LCDPanelOffMode", "i", "i", dbus_lcdpaneloffmode }, { "ActorControl", "sii", "i", dbus_actorcontrol }, { "CustomBrightness", NULL, "i", dbus_getcustombrightness }, - { "CurrentBrightness", NULL, "i", dbus_getbrightness }, /* deprecated. It is remained for tizen 2.4 */ + { "CurrentBrightness", "i", "i", dbus_getbrightness }, /* deprecated. It is remained for tizen 2.4 */ { "LockTimeoutExpired", "s", "i", dbus_locktimeout_expired }, { "LockTimeoutInput", "si", "i", dbus_locktimeout_input }, /* Add methods here */ diff --git a/src/shared/CMakeLists.txt b/src/shared/CMakeLists.txt index 67290f9..e0c9dcc 100644 --- a/src/shared/CMakeLists.txt +++ b/src/shared/CMakeLists.txt @@ -2,6 +2,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) SET(SHARED_SRCS plugin.c + eventsystem.c ) INCLUDE(FindPkgConfig) @@ -9,7 +10,8 @@ pkg_check_modules(libshared REQUIRED glib-2.0 gio-2.0 gio-unix-2.0 - dlog) + dlog + eventsystem) FOREACH(flag ${libshared_CFLAGS}) SET(SHARED_LIB_CFLAGS "${SHARED_LIB_CFLAGS} ${flag}") diff --git a/src/shared/eventsystem.c b/src/shared/eventsystem.c new file mode 100644 index 0000000..05f45c1 --- /dev/null +++ b/src/shared/eventsystem.c @@ -0,0 +1,49 @@ +/* + * deviced + * + * copyright (c) 2019 samsung electronics co., ltd. all rights reserved. + * + * licensed under the apache license, version 2.0 (the "license"); + * you may not use this file except in compliance with the license. + * you may obtain a copy of the license at + * + * http://www.apache.org/licenses/license-2.0 + * + * unless required by applicable law or agreed to in writing, software + * distributed under the license is distributed on an "as is" basis, + * without warranties or conditions of any kind, either express or implied. + * see the license for the specific language governing permissions and + * limitations under the license. + */ + +#include +#include + +#include "eventsystem.h" +#include "core/common.h" +#include "log.h" + +static bundle *b; + +void event_system_send(const char *subject, const char *key, const char *value) +{ + if (!b) + return; + + _D("subject:%s, key:%s, value:%s", subject, key, value); + + bundle_add_str(b, key, value); + eventsystem_send_system_event(subject, b); + bundle_del(b, key); +} + +static void __CONSTRUCTOR__ event_system_init(void) +{ + b = bundle_create(); +} + +static void __DESTRUCTOR__ event_system_exit(void) +{ + if (b) + bundle_free(b); +} diff --git a/src/shared/eventsystem.h b/src/shared/eventsystem.h new file mode 100644 index 0000000..2d7cc53 --- /dev/null +++ b/src/shared/eventsystem.h @@ -0,0 +1,27 @@ +/* + * deviced + * + * copyright (c) 2019 samsung electronics co., ltd. all rights reserved. + * + * licensed under the apache license, version 2.0 (the "license"); + * you may not use this file except in compliance with the license. + * you may obtain a copy of the license at + * + * http://www.apache.org/licenses/license-2.0 + * + * unless required by applicable law or agreed to in writing, software + * distributed under the license is distributed on an "as is" basis, + * without warranties or conditions of any kind, either express or implied. + * see the license for the specific language governing permissions and + * limitations under the license. + */ + +#ifndef __EVENTSYSTEM_H__ +#define __EVENTSYSTEM_H__ + +#include +#include + +void event_system_send(const char *subject, const char *key, const char *value); + +#endif -- 2.7.4 From 432678af34b74687f6f84e8116b535b77b167722 Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Fri, 9 Aug 2019 16:17:12 +0900 Subject: [PATCH 06/16] Remove vconf enum for VCONFKEY_SYSMAN_POWER_OFF_POPUP - VCONFKEY_SYSMAN_POWER_OFF_POPUP is removed from VCONFKEY_SYSMAN_POWER_OFF_STATUS - So, remove related code Change-Id: I22ce64bf59fba048a969b0599961e829ebc1fd03 Signed-off-by: lokilee73 --- plugins/iot/display/key-filter.c | 4 ---- plugins/mobile/display/key-filter.c | 4 ---- plugins/tv/display/key-filter.c | 4 ---- plugins/wearable/display/key-filter.c | 4 ---- 4 files changed, 16 deletions(-) diff --git a/plugins/iot/display/key-filter.c b/plugins/iot/display/key-filter.c index 0baf72a..4dd1080 100644 --- a/plugins/iot/display/key-filter.c +++ b/plugins/iot/display/key-filter.c @@ -122,10 +122,6 @@ static void pwroff_popup(void) { int ret; - ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); - if (ret < 0) - _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - pm_status_flag &= ~PWROFF_FLAG; ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); if (ret < 0) diff --git a/plugins/mobile/display/key-filter.c b/plugins/mobile/display/key-filter.c index 7f060d0..52010d2 100644 --- a/plugins/mobile/display/key-filter.c +++ b/plugins/mobile/display/key-filter.c @@ -122,10 +122,6 @@ static void pwroff_popup(void) { int ret; - ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); - if (ret < 0) - _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - pm_status_flag &= ~PWROFF_FLAG; ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); if (ret < 0) diff --git a/plugins/tv/display/key-filter.c b/plugins/tv/display/key-filter.c index 0baf72a..4dd1080 100644 --- a/plugins/tv/display/key-filter.c +++ b/plugins/tv/display/key-filter.c @@ -122,10 +122,6 @@ static void pwroff_popup(void) { int ret; - ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); - if (ret < 0) - _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - pm_status_flag &= ~PWROFF_FLAG; ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); if (ret < 0) diff --git a/plugins/wearable/display/key-filter.c b/plugins/wearable/display/key-filter.c index d66fa9d..6d2b864 100644 --- a/plugins/wearable/display/key-filter.c +++ b/plugins/wearable/display/key-filter.c @@ -133,10 +133,6 @@ static void pwroff_popup(void) { int ret; - ret = vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_POPUP); - if (ret < 0) - _E("Failed to set vconf value for power off status: %d", vconf_get_ext_errno()); - pm_status_flag &= ~PWROFF_FLAG; ret = launch_system_app(APP_POWERKEY, 2, APP_KEY_TYPE, APP_POWERKEY); if (ret < 0) -- 2.7.4 From 62b38d2f864fe28a6e081bd63619abccf50e2a68 Mon Sep 17 00:00:00 2001 From: "sanghyeok.oh" Date: Mon, 12 Aug 2019 12:17:10 +0900 Subject: [PATCH 07/16] dbus: allow GetAll method call for g_dbus_proxy. g_dbus_proxy_new_*() function generate dbus properties related method call. Without allow rule, It makes dbus policy error. Deviced doesn't have any dbus properties. G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is recommended to create g_dbus_proxy for deviced. Change-Id: I095d3df2711c5ef7bf06fc90c5e54d60e4532ffd Signed-off-by: sanghyeok.oh --- conf/org.tizen.system.deviced.conf | 1 + 1 file changed, 1 insertion(+) diff --git a/conf/org.tizen.system.deviced.conf b/conf/org.tizen.system.deviced.conf index 58737c0..53535a8 100644 --- a/conf/org.tizen.system.deviced.conf +++ b/conf/org.tizen.system.deviced.conf @@ -27,6 +27,7 @@ + -- 2.7.4 From faaa711fb7acdd22aee3b626269299dfe3f46898 Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Mon, 12 Aug 2019 14:01:06 +0900 Subject: [PATCH 08/16] Remove Booting_Done signal broadcasted by deviced - Booting_Done is broadcasted by systemd Change-Id: If0607321f3bbe140915744b2283958361d29ea77 Signed-off-by: lokilee73 --- src/power/boot.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/power/boot.c b/src/power/boot.c index 87ff7ce..3302b77 100644 --- a/src/power/boot.c +++ b/src/power/boot.c @@ -30,7 +30,6 @@ #include "display/poll.h" #include "display/display-ops.h" -#define SIGNAL_BOOTING_DONE "BootingDone" #define SYSTEMD_DBUS_SIGNAL_SYSTEM_STARTUP_FINISHED "StartupFinished" #define SYSTEMD_DBUS_SIGNAL_USER_STARTUP_FINISHED "UserSessionStartupFinished" @@ -82,11 +81,6 @@ static void booting_done_received(GDBusConnection *conn, disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); _I("Signal booting done."); - - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_CORE, - DEVICED_INTERFACE_CORE, - SIGNAL_BOOTING_DONE, - NULL, NULL); } void add_booting_done_handler(void *data) -- 2.7.4 From ad194720c0b7988a4528aed2fb197192ba2fc7d5 Mon Sep 17 00:00:00 2001 From: "sanghyeok.oh" Date: Wed, 14 Aug 2019 17:22:50 +0900 Subject: [PATCH 09/16] dbus: modified to use revised api Change-Id: I781eb867a01f460ff9022a3ac59497469b621e47 Signed-off-by: sanghyeok.oh --- plugins/iot/display/core.c | 15 +++++++++------ plugins/iot/display/key-filter.c | 15 +++++++++------ plugins/mobile/display/core.c | 15 +++++++++------ plugins/mobile/display/key-filter.c | 15 +++++++++------ plugins/tv/display/core.c | 15 +++++++++------ plugins/tv/display/key-filter.c | 15 +++++++++------ plugins/tv/display/state-tv.c | 15 ++++++++++----- plugins/wearable/display/core.c | 15 +++++++++------ plugins/wearable/display/enhance.c | 3 ++- plugins/wearable/display/key-filter.c | 15 +++++++++------ src/battery/battery-time.c | 7 +++++-- src/battery/power-supply.c | 13 +++++++++---- src/display/ambient-mode.c | 3 ++- src/dump/dump.c | 6 ++++-- src/extcon/cradle.c | 3 ++- src/extcon/earjack.c | 3 ++- src/extcon/hdmi.c | 3 ++- src/led/torch.c | 3 ++- src/power/power-handler.c | 3 ++- src/time/time-handler.c | 5 +++-- src/usb/usb-dbus.c | 18 ++++++++++++------ src/usbhost/usb-host.c | 9 +++++---- 22 files changed, 134 insertions(+), 80 deletions(-) diff --git a/plugins/iot/display/core.c b/plugins/iot/display/core.c index b9d7d14..7522866 100644 --- a/plugins/iot/display/core.c +++ b/plugins/iot/display/core.c @@ -229,10 +229,11 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal_var(RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + ret = dbus_handle_broadcast_dbus_signal(NULL, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -310,7 +311,8 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); @@ -341,7 +343,8 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); diff --git a/plugins/iot/display/key-filter.c b/plugins/iot/display/key-filter.c index 4dd1080..b55e311 100644 --- a/plugins/iot/display/key-filter.c +++ b/plugins/iot/display/key-filter.c @@ -180,18 +180,20 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, - NULL, NULL); + NULL); } static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, - NULL, NULL); + NULL); } static inline bool switch_on_lcd(void) @@ -402,10 +404,11 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_KEY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, - NULL, NULL); + NULL); } static void process_hardkey_backlight(struct input_event *pinput) diff --git a/plugins/mobile/display/core.c b/plugins/mobile/display/core.c index f252e4e..c2bafa2 100644 --- a/plugins/mobile/display/core.c +++ b/plugins/mobile/display/core.c @@ -230,10 +230,11 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal_var(RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + ret = dbus_handle_broadcast_dbus_signal(NULL, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -311,7 +312,8 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); @@ -342,7 +344,8 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); diff --git a/plugins/mobile/display/key-filter.c b/plugins/mobile/display/key-filter.c index 52010d2..a407b03 100644 --- a/plugins/mobile/display/key-filter.c +++ b/plugins/mobile/display/key-filter.c @@ -180,18 +180,20 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, - NULL, NULL); + NULL); } static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, - NULL, NULL); + NULL); } static inline bool switch_on_lcd(void) @@ -460,10 +462,11 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_KEY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, - NULL, NULL); + NULL); } static void process_hardkey_backlight(struct input_event *pinput) diff --git a/plugins/tv/display/core.c b/plugins/tv/display/core.c index 5f07dde..920245f 100644 --- a/plugins/tv/display/core.c +++ b/plugins/tv/display/core.c @@ -231,10 +231,11 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal_var(RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + ret = dbus_handle_broadcast_dbus_signal(NULL, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -312,7 +313,8 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); @@ -343,7 +345,8 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); diff --git a/plugins/tv/display/key-filter.c b/plugins/tv/display/key-filter.c index 4dd1080..b55e311 100644 --- a/plugins/tv/display/key-filter.c +++ b/plugins/tv/display/key-filter.c @@ -180,18 +180,20 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, - NULL, NULL); + NULL); } static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, - NULL, NULL); + NULL); } static inline bool switch_on_lcd(void) @@ -402,10 +404,11 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_KEY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, - NULL, NULL); + NULL); } static void process_hardkey_backlight(struct input_event *pinput) diff --git a/plugins/tv/display/state-tv.c b/plugins/tv/display/state-tv.c index 8753a8d..e50463c 100644 --- a/plugins/tv/display/state-tv.c +++ b/plugins/tv/display/state-tv.c @@ -129,7 +129,8 @@ static int lcdon_pre(void *data) if (pm_cur_state == S_STANDBY) { _I("send pre state change NORMAL"); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_PRE_CHANGE_STATE, g_variant_new("(s)", states[S_LCDON].name)); @@ -146,7 +147,8 @@ static int lcdon_post(void *data) { int ret; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_CHANGE_STATE, g_variant_new("(s)", states[S_LCDON].name)); @@ -219,7 +221,8 @@ static int lcdoff_post(void *data) int ret; /* broadcast to other application */ - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_CHANGE_STATE, g_variant_new("(s)", states[S_LCDOFF].name)); @@ -298,7 +301,8 @@ static int standby_post(void *data) int ret; /* broadcast to other application */ - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_CHANGE_STATE, g_variant_new("(s)", states[S_STANDBY].name)); @@ -399,7 +403,8 @@ static int suspend_post(void *data) _E("Fail to change state to next_state(%s)", states[cond].name); /* Broadcast pre-wakeup signal */ - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_POWER, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_POWER, DEVICED_INTERFACE_POWER, SIGNAL_PRE_WAKEUP, g_variant_new("(i)", 0)); diff --git a/plugins/wearable/display/core.c b/plugins/wearable/display/core.c index d5e35f9..ea99bab 100644 --- a/plugins/wearable/display/core.c +++ b/plugins/wearable/display/core.c @@ -230,10 +230,11 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal_var(RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + ret = dbus_handle_broadcast_dbus_signal(NULL, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -311,7 +312,8 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); @@ -342,7 +344,8 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, g_variant_new("(s)", str)); diff --git a/plugins/wearable/display/enhance.c b/plugins/wearable/display/enhance.c index a771cb4..51b9c84 100644 --- a/plugins/wearable/display/enhance.c +++ b/plugins/wearable/display/enhance.c @@ -154,7 +154,8 @@ static void enhance_init(void *data) state = enhance_update_state(); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, "Enhance", g_variant_new("(i)", state)); diff --git a/plugins/wearable/display/key-filter.c b/plugins/wearable/display/key-filter.c index 6d2b864..5ae407e 100644 --- a/plugins/wearable/display/key-filter.c +++ b/plugins/wearable/display/key-filter.c @@ -199,18 +199,20 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, - NULL, NULL); + NULL); } static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_DISPLAY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, - NULL, NULL); + NULL); } static inline bool switch_on_lcd(enum device_flags flags) @@ -501,10 +503,11 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_KEY, + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, - NULL, NULL); + NULL); } static void process_hardkey_backlight(struct input_event *pinput) diff --git a/src/battery/battery-time.c b/src/battery/battery-time.c index 75db00d..5b86e63 100644 --- a/src/battery/battery-time.c +++ b/src/battery/battery-time.c @@ -225,8 +225,11 @@ static void broadcast_battery_time(char *signal, int time) if (!signal) return; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, - signal, g_variant_new("(i)", time)); + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_BATTERY, + DEVICED_INTERFACE_BATTERY, + signal, + g_variant_new("(i)", time)); if (ret < 0) _E("Failed to send dbus signal(%s)", signal); } diff --git a/src/battery/power-supply.c b/src/battery/power-supply.c index 3d8bcb1..bbc61e7 100644 --- a/src/battery/power-supply.c +++ b/src/battery/power-supply.c @@ -150,7 +150,8 @@ static int power_supply_broadcast_str(char *sig, char *status) str = status; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_BATTERY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, sig, g_variant_new("(s)", str)); @@ -182,8 +183,11 @@ static void abnormal_popup_timer_init(void) static void health_status_broadcast(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, - SIGNAL_TEMP_GOOD, NULL, NULL); + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_BATTERY, + DEVICED_INTERFACE_BATTERY, + SIGNAL_TEMP_GOOD, + NULL); } @@ -419,7 +423,8 @@ int power_supply_broadcast(char *sig, int status) snprintf(sig_old, sizeof(sig_old), "%s", sig); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_BATTERY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, sig, g_variant_new("(i)", status)); diff --git a/src/display/ambient-mode.c b/src/display/ambient-mode.c index fdec29b..8de1c39 100644 --- a/src/display/ambient-mode.c +++ b/src/display/ambient-mode.c @@ -51,7 +51,8 @@ void broadcast_ambient_state(int state) char *signal; signal = (state == true ? SIGNAL_ALPM_ON : SIGNAL_ALPM_OFF); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_DISPLAY, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, NULL); diff --git a/src/dump/dump.c b/src/dump/dump.c index c082fda..b3c29a1 100644 --- a/src/dump/dump.c +++ b/src/dump/dump.c @@ -39,8 +39,10 @@ static void send_dump_signal(char *signal) pid = getpid(); - ret = dbus_handle_broadcast_dbus_signal_var(DUMP_SERVICE_OBJECT_PATH, - DUMP_SERVICE_INTERFACE_NAME, signal, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DUMP_SERVICE_OBJECT_PATH, + DUMP_SERVICE_INTERFACE_NAME, + signal, g_variant_new("(i)", pid)); if (ret < 0) _E("Failed to send dbus signal(%s)", signal); diff --git a/src/extcon/cradle.c b/src/extcon/cradle.c index 282cd79..1c46ea3 100644 --- a/src/extcon/cradle.c +++ b/src/extcon/cradle.c @@ -44,7 +44,8 @@ static void cradle_send_broadcast(int status) _I("Broadcast cradle status(%d).", status); old = status; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_SYSNOTI, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_CRADLE_STATE, g_variant_new("(i)", status)); diff --git a/src/extcon/earjack.c b/src/extcon/earjack.c index d02aeb0..8f76f88 100644 --- a/src/extcon/earjack.c +++ b/src/extcon/earjack.c @@ -41,7 +41,8 @@ static void earjack_send_broadcast(int status) _I("Broadcast earjack status(%d).", status); old = status; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_SYSNOTI, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_EARJACK_STATE, g_variant_new("(i)", status)); diff --git a/src/extcon/hdmi.c b/src/extcon/hdmi.c index 8ab10e5..e145132 100644 --- a/src/extcon/hdmi.c +++ b/src/extcon/hdmi.c @@ -41,7 +41,8 @@ static void hdmi_send_broadcast(int status) _I("Broadcast hdmi status(%d)", status); old = status; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_SYSNOTI, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_HDMI_STATE, g_variant_new("(i)", status)); diff --git a/src/led/torch.c b/src/led/torch.c index 94acf50..4b1e807 100644 --- a/src/led/torch.c +++ b/src/led/torch.c @@ -46,7 +46,8 @@ static void flash_state_broadcast(int val) { int ret; - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_LED, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_LED, DEVICED_INTERFACE_LED, SIGNAL_FLASH_STATE, g_variant_new("(i)", val)); diff --git a/src/power/power-handler.c b/src/power/power-handler.c index 41aac63..e6ce746 100644 --- a/src/power/power-handler.c +++ b/src/power/power-handler.c @@ -450,7 +450,8 @@ static void poweroff_send_broadcast(int status) old = status; /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangeState signal for POWEROFF_TYPE_DIRECT and POWEROFF_TYPE_RESTART */ - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_POWEROFF, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_POWEROFF, DEVICED_INTERFACE_POWEROFF, SIGNAL_POWEROFF_STATE, g_variant_new("(i)", status)); diff --git a/src/time/time-handler.c b/src/time/time-handler.c index b49e91c..a706aa0 100644 --- a/src/time/time-handler.c +++ b/src/time/time-handler.c @@ -227,8 +227,9 @@ int set_timezone_action(int argc, char **argv) static void time_changed_broadcast(void) { - dbus_handle_broadcast_dbus_signal(DEVICED_PATH_TIME, DEVICED_INTERFACE_TIME, - TIME_CHANGE_SIGNAL, NULL, NULL); + dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_TIME, DEVICED_INTERFACE_TIME, + TIME_CHANGE_SIGNAL, NULL); } static int timerfd_check_start(void) diff --git a/src/usb/usb-dbus.c b/src/usb/usb-dbus.c index fcd9068..eefb98f 100644 --- a/src/usb/usb-dbus.c +++ b/src/usb/usb-dbus.c @@ -76,8 +76,10 @@ void broadcast_usb_config_enabled(int state) _I("USB config(%d) enabled.", state); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_USB, - DEVICED_INTERFACE_USB, SIGNAL_CONFIG_ENABLED, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_USB, + DEVICED_INTERFACE_USB, + SIGNAL_CONFIG_ENABLED, g_variant_new("(i)", state)); if (ret < 0) _E("Failed to send dbus signal."); @@ -96,8 +98,10 @@ void broadcast_usb_state_changed(void) _I("USB state(%u) changed.", state); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_USB, - DEVICED_INTERFACE_USB, SIGNAL_STATE_CHANGED, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_USB, + DEVICED_INTERFACE_USB, + SIGNAL_STATE_CHANGED, g_variant_new("(u)", state)); if (ret < 0) _E("Failed to send dbus signal."); @@ -116,8 +120,10 @@ void broadcast_usb_mode_changed(void) _I("USB mode(%u) changed.", mode); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_USB, - DEVICED_INTERFACE_USB, SIGNAL_MODE_CHANGED, + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_USB, + DEVICED_INTERFACE_USB, + SIGNAL_MODE_CHANGED, g_variant_new("(u)", mode)); if (ret < 0) _E("Failed to send dbus signal(%s)", SIGNAL_MODE_CHANGED); diff --git a/src/usbhost/usb-host.c b/src/usbhost/usb-host.c index d3d46c2..76e7f72 100644 --- a/src/usbhost/usb-host.c +++ b/src/usbhost/usb-host.c @@ -189,10 +189,11 @@ static void broadcast_usbhost_signal(enum usbhost_state state, (usbhost->product ? usbhost->product : ""), (usbhost->serial ? usbhost->serial : "")); - ret = dbus_handle_broadcast_dbus_signal_var(DEVICED_PATH_USBHOST, - DEVICED_INTERFACE_USBHOST, - SIGNAL_USB_HOST_CHANGED, - param); + ret = dbus_handle_broadcast_dbus_signal(NULL, + DEVICED_PATH_USBHOST, + DEVICED_INTERFACE_USBHOST, + SIGNAL_USB_HOST_CHANGED, + param); if (ret < 0) _E("Failed to send dbus signal(%s)", SIGNAL_USB_HOST_CHANGED); } -- 2.7.4 From 65ab172e48078e739daf9f018d83d2e531651c92 Mon Sep 17 00:00:00 2001 From: "sanghyeok.oh" Date: Fri, 16 Aug 2019 10:56:36 +0900 Subject: [PATCH 10/16] dbus: modified to use renamed api change 'dbus_handle_broadcast_dbus_signal' to 'dbus_handle_emit_dbus_signal' Change-Id: If35e9bc2bb52c15585a57a8a012be3bedadd79ff Signed-off-by: sanghyeok.oh --- plugins/iot/display/core.c | 6 +++--- plugins/iot/display/key-filter.c | 6 +++--- plugins/mobile/display/core.c | 6 +++--- plugins/mobile/display/key-filter.c | 6 +++--- plugins/tv/display/core.c | 6 +++--- plugins/tv/display/key-filter.c | 6 +++--- plugins/tv/display/state-tv.c | 10 +++++----- plugins/wearable/display/core.c | 6 +++--- plugins/wearable/display/enhance.c | 2 +- plugins/wearable/display/key-filter.c | 6 +++--- src/battery/battery-time.c | 2 +- src/battery/power-supply.c | 6 +++--- src/display/ambient-mode.c | 2 +- src/dump/dump.c | 2 +- src/extcon/cradle.c | 2 +- src/extcon/earjack.c | 2 +- src/extcon/hdmi.c | 2 +- src/led/torch.c | 2 +- src/power/power-handler.c | 2 +- src/time/time-handler.c | 2 +- src/usb/usb-dbus.c | 6 +++--- src/usbhost/usb-host.c | 2 +- 22 files changed, 46 insertions(+), 46 deletions(-) diff --git a/plugins/iot/display/core.c b/plugins/iot/display/core.c index 7522866..5f08790 100644 --- a/plugins/iot/display/core.c +++ b/plugins/iot/display/core.c @@ -229,7 +229,7 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, RESOURCED_INTERFACE_PROCESS, RESOURCED_METHOD_ACTIVE, @@ -311,7 +311,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, @@ -343,7 +343,7 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, diff --git a/plugins/iot/display/key-filter.c b/plugins/iot/display/key-filter.c index b55e311..8b35f7c 100644 --- a/plugins/iot/display/key-filter.c +++ b/plugins/iot/display/key-filter.c @@ -180,7 +180,7 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, @@ -189,7 +189,7 @@ static inline void broadcast_lcdon_by_powerkey(void) static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, @@ -404,7 +404,7 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, diff --git a/plugins/mobile/display/core.c b/plugins/mobile/display/core.c index c2bafa2..9d3f642 100644 --- a/plugins/mobile/display/core.c +++ b/plugins/mobile/display/core.c @@ -230,7 +230,7 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, RESOURCED_INTERFACE_PROCESS, RESOURCED_METHOD_ACTIVE, @@ -312,7 +312,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, @@ -344,7 +344,7 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, diff --git a/plugins/mobile/display/key-filter.c b/plugins/mobile/display/key-filter.c index a407b03..3462aa7 100644 --- a/plugins/mobile/display/key-filter.c +++ b/plugins/mobile/display/key-filter.c @@ -180,7 +180,7 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, @@ -189,7 +189,7 @@ static inline void broadcast_lcdon_by_powerkey(void) static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, @@ -462,7 +462,7 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, diff --git a/plugins/tv/display/core.c b/plugins/tv/display/core.c index 920245f..79bd919 100644 --- a/plugins/tv/display/core.c +++ b/plugins/tv/display/core.c @@ -231,7 +231,7 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, RESOURCED_INTERFACE_PROCESS, RESOURCED_METHOD_ACTIVE, @@ -313,7 +313,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, @@ -345,7 +345,7 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, diff --git a/plugins/tv/display/key-filter.c b/plugins/tv/display/key-filter.c index b55e311..8b35f7c 100644 --- a/plugins/tv/display/key-filter.c +++ b/plugins/tv/display/key-filter.c @@ -180,7 +180,7 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, @@ -189,7 +189,7 @@ static inline void broadcast_lcdon_by_powerkey(void) static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, @@ -404,7 +404,7 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, diff --git a/plugins/tv/display/state-tv.c b/plugins/tv/display/state-tv.c index e50463c..b99ea0f 100644 --- a/plugins/tv/display/state-tv.c +++ b/plugins/tv/display/state-tv.c @@ -129,7 +129,7 @@ static int lcdon_pre(void *data) if (pm_cur_state == S_STANDBY) { _I("send pre state change NORMAL"); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_PRE_CHANGE_STATE, @@ -147,7 +147,7 @@ static int lcdon_post(void *data) { int ret; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_CHANGE_STATE, @@ -221,7 +221,7 @@ static int lcdoff_post(void *data) int ret; /* broadcast to other application */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_CHANGE_STATE, @@ -301,7 +301,7 @@ static int standby_post(void *data) int ret; /* broadcast to other application */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_CHANGE_STATE, @@ -403,7 +403,7 @@ static int suspend_post(void *data) _E("Fail to change state to next_state(%s)", states[cond].name); /* Broadcast pre-wakeup signal */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_POWER, DEVICED_INTERFACE_POWER, SIGNAL_PRE_WAKEUP, diff --git a/plugins/wearable/display/core.c b/plugins/wearable/display/core.c index ea99bab..3f8c686 100644 --- a/plugins/wearable/display/core.c +++ b/plugins/wearable/display/core.c @@ -230,7 +230,7 @@ static void set_process_active(bool flag, pid_t pid) return; /* Send dbug to resourced */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, RESOURCED_INTERFACE_PROCESS, RESOURCED_METHOD_ACTIVE, @@ -312,7 +312,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) signal = lcdon_sig_lookup[type]; _I("lcdstep : Broadcast signal(%s:%s).", signal, str); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, @@ -344,7 +344,7 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = UNKNOWN_STR; _I("lcdstep : Broadcast signal(%s).", signal); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, diff --git a/plugins/wearable/display/enhance.c b/plugins/wearable/display/enhance.c index 51b9c84..4b60807 100644 --- a/plugins/wearable/display/enhance.c +++ b/plugins/wearable/display/enhance.c @@ -154,7 +154,7 @@ static void enhance_init(void *data) state = enhance_update_state(); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, "Enhance", diff --git a/plugins/wearable/display/key-filter.c b/plugins/wearable/display/key-filter.c index 5ae407e..01e43ff 100644 --- a/plugins/wearable/display/key-filter.c +++ b/plugins/wearable/display/key-filter.c @@ -199,7 +199,7 @@ static inline void check_key_pair(int code, int new, int *old) static inline void broadcast_lcdon_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDON_BY_POWERKEY, @@ -208,7 +208,7 @@ static inline void broadcast_lcdon_by_powerkey(void) static inline void broadcast_lcdoff_by_powerkey(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, SIGNAL_LCDOFF_BY_POWERKEY, @@ -503,7 +503,7 @@ static void sound_vibrate_hardkey(void) /* device notify(vibrator) */ /* sound(dbus) */ /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangedHardKey signal */ - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_KEY, DEVICED_INTERFACE_KEY, SIGNAL_CHANGE_HARDKEY, diff --git a/src/battery/battery-time.c b/src/battery/battery-time.c index 5b86e63..d7bc170 100644 --- a/src/battery/battery-time.c +++ b/src/battery/battery-time.c @@ -225,7 +225,7 @@ static void broadcast_battery_time(char *signal, int time) if (!signal) return; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, signal, diff --git a/src/battery/power-supply.c b/src/battery/power-supply.c index bbc61e7..2bf2db1 100644 --- a/src/battery/power-supply.c +++ b/src/battery/power-supply.c @@ -150,7 +150,7 @@ static int power_supply_broadcast_str(char *sig, char *status) str = status; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, sig, @@ -183,7 +183,7 @@ static void abnormal_popup_timer_init(void) static void health_status_broadcast(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, SIGNAL_TEMP_GOOD, @@ -423,7 +423,7 @@ int power_supply_broadcast(char *sig, int status) snprintf(sig_old, sizeof(sig_old), "%s", sig); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_BATTERY, DEVICED_INTERFACE_BATTERY, sig, diff --git a/src/display/ambient-mode.c b/src/display/ambient-mode.c index 8de1c39..7192f44 100644 --- a/src/display/ambient-mode.c +++ b/src/display/ambient-mode.c @@ -51,7 +51,7 @@ void broadcast_ambient_state(int state) char *signal; signal = (state == true ? SIGNAL_ALPM_ON : SIGNAL_ALPM_OFF); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, diff --git a/src/dump/dump.c b/src/dump/dump.c index b3c29a1..1695628 100644 --- a/src/dump/dump.c +++ b/src/dump/dump.c @@ -39,7 +39,7 @@ static void send_dump_signal(char *signal) pid = getpid(); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DUMP_SERVICE_OBJECT_PATH, DUMP_SERVICE_INTERFACE_NAME, signal, diff --git a/src/extcon/cradle.c b/src/extcon/cradle.c index 1c46ea3..2f37d04 100644 --- a/src/extcon/cradle.c +++ b/src/extcon/cradle.c @@ -44,7 +44,7 @@ static void cradle_send_broadcast(int status) _I("Broadcast cradle status(%d).", status); old = status; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_CRADLE_STATE, diff --git a/src/extcon/earjack.c b/src/extcon/earjack.c index 8f76f88..aa40699 100644 --- a/src/extcon/earjack.c +++ b/src/extcon/earjack.c @@ -41,7 +41,7 @@ static void earjack_send_broadcast(int status) _I("Broadcast earjack status(%d).", status); old = status; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_EARJACK_STATE, diff --git a/src/extcon/hdmi.c b/src/extcon/hdmi.c index e145132..1a3b2f6 100644 --- a/src/extcon/hdmi.c +++ b/src/extcon/hdmi.c @@ -41,7 +41,7 @@ static void hdmi_send_broadcast(int status) _I("Broadcast hdmi status(%d)", status); old = status; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_SYSNOTI, DEVICED_INTERFACE_SYSNOTI, SIGNAL_HDMI_STATE, diff --git a/src/led/torch.c b/src/led/torch.c index 4b1e807..2024ebd 100644 --- a/src/led/torch.c +++ b/src/led/torch.c @@ -46,7 +46,7 @@ static void flash_state_broadcast(int val) { int ret; - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_LED, DEVICED_INTERFACE_LED, SIGNAL_FLASH_STATE, diff --git a/src/power/power-handler.c b/src/power/power-handler.c index e6ce746..4303a4d 100644 --- a/src/power/power-handler.c +++ b/src/power/power-handler.c @@ -450,7 +450,7 @@ static void poweroff_send_broadcast(int status) old = status; /* Need to notify to deviced-vibrator. deviced-vibrator receives ChangeState signal for POWEROFF_TYPE_DIRECT and POWEROFF_TYPE_RESTART */ - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_POWEROFF, DEVICED_INTERFACE_POWEROFF, SIGNAL_POWEROFF_STATE, diff --git a/src/time/time-handler.c b/src/time/time-handler.c index a706aa0..82169e2 100644 --- a/src/time/time-handler.c +++ b/src/time/time-handler.c @@ -227,7 +227,7 @@ int set_timezone_action(int argc, char **argv) static void time_changed_broadcast(void) { - dbus_handle_broadcast_dbus_signal(NULL, + dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_TIME, DEVICED_INTERFACE_TIME, TIME_CHANGE_SIGNAL, NULL); } diff --git a/src/usb/usb-dbus.c b/src/usb/usb-dbus.c index eefb98f..b83e64c 100644 --- a/src/usb/usb-dbus.c +++ b/src/usb/usb-dbus.c @@ -76,7 +76,7 @@ void broadcast_usb_config_enabled(int state) _I("USB config(%d) enabled.", state); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_USB, DEVICED_INTERFACE_USB, SIGNAL_CONFIG_ENABLED, @@ -98,7 +98,7 @@ void broadcast_usb_state_changed(void) _I("USB state(%u) changed.", state); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_USB, DEVICED_INTERFACE_USB, SIGNAL_STATE_CHANGED, @@ -120,7 +120,7 @@ void broadcast_usb_mode_changed(void) _I("USB mode(%u) changed.", mode); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_USB, DEVICED_INTERFACE_USB, SIGNAL_MODE_CHANGED, diff --git a/src/usbhost/usb-host.c b/src/usbhost/usb-host.c index 76e7f72..3f95ea9 100644 --- a/src/usbhost/usb-host.c +++ b/src/usbhost/usb-host.c @@ -189,7 +189,7 @@ static void broadcast_usbhost_signal(enum usbhost_state state, (usbhost->product ? usbhost->product : ""), (usbhost->serial ? usbhost->serial : "")); - ret = dbus_handle_broadcast_dbus_signal(NULL, + ret = dbus_handle_emit_dbus_signal(NULL, DEVICED_PATH_USBHOST, DEVICED_INTERFACE_USBHOST, SIGNAL_USB_HOST_CHANGED, -- 2.7.4 From a7c02a657652b143dea9bedd1061bf9edd30099d Mon Sep 17 00:00:00 2001 From: Yunmi Ha Date: Mon, 26 Aug 2019 19:58:09 +0900 Subject: [PATCH 11/16] Fix svace issue - check return value before refer Change-Id: I085162d37bc94d5df858454323a142bce3c5f0cd Signed-off-by: Yunmi Ha --- src/battery/lowbat-handler.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/battery/lowbat-handler.c b/src/battery/lowbat-handler.c index 226beb3..b2a491a 100644 --- a/src/battery/lowbat-handler.c +++ b/src/battery/lowbat-handler.c @@ -160,6 +160,8 @@ static int power_execute(void *data) static const struct device_ops *ops; FIND_DEVICE_INT(ops, POWER_OPS_NAME); + if (NOT_SUPPORT_OPS(ops)) + return -EINVAL; return ops->execute(data); } @@ -908,6 +910,9 @@ static int lowbat_probe(void *data) int ret = -EINVAL; FIND_DEVICE_INT(ops, "power_supply"); + if (NOT_SUPPORT_OPS(ops)) + return ret; + ret = ops->probe(data); if (ret == 0) _I("Support lowbat handler."); -- 2.7.4 From bf9160eaaae561158273f08316da80c857960286 Mon Sep 17 00:00:00 2001 From: Hyotaek Shim Date: Tue, 27 Aug 2019 10:26:27 +0900 Subject: [PATCH 12/16] Safe umount an sdcard partition (/opt/media/SDCardA1) Change-Id: I7a27f311e1da52a5e8930854ec9fa22f00fbb443 Signed-off-by: Hyotaek Shim --- src/power-shutdown/shutdown.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/power-shutdown/shutdown.c b/src/power-shutdown/shutdown.c index 9c6032d..7e4fa71 100644 --- a/src/power-shutdown/shutdown.c +++ b/src/power-shutdown/shutdown.c @@ -46,6 +46,7 @@ enum { CMD_EXIT, }; +#define UMOUNT_RW_PATH_SDCARD "/opt/media/SDCardA1" #define UMOUNT_RW_PATH_USER "/opt/usr" #define UMOUNT_RW_PATH_SYSTEM "/opt" #define MAX_UMOUNT_KILL_RETRY 4 @@ -60,6 +61,7 @@ static int usage(void) static void umount_partitions(void) { + umount_partition_by_kill(UMOUNT_RW_PATH_SDCARD, MAX_UMOUNT_KILL_RETRY); umount_partition_by_kill(UMOUNT_RW_PATH_USER, MAX_UMOUNT_KILL_RETRY); umount_partition_by_kill(UMOUNT_RW_PATH_SYSTEM, MAX_UMOUNT_KILL_RETRY); } -- 2.7.4 From 85f04968238b4e53653f7b684dde1bc99dce07bd Mon Sep 17 00:00:00 2001 From: Youngjae Cho Date: Mon, 26 Aug 2019 14:39:11 +0900 Subject: [PATCH 13/16] Add critical-log module Change-Id: Ic719ce9f2156bdaebedb5cda60643e7462dce792 Signed-off-by: Youngjae Cho --- CMakeLists.txt | 13 +- conf/critical-log.conf | 13 ++ packaging/deviced.spec | 3 + src/core/device-notifier.h | 1 + src/core/log.c | 14 ++ src/core/log.h | 4 + src/critical-log/critical-log.c | 474 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 520 insertions(+), 2 deletions(-) create mode 100644 conf/critical-log.conf create mode 100644 src/critical-log/critical-log.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 072b6c6..e68f5bb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -153,8 +153,13 @@ IF(TIZEN_FEATURE_USBHOST_TEST STREQUAL on) ENDIF() IF(DEVICE_BOARD_MODULE STREQUAL on) - ADD_SOURCE(src/board PRODUCT_BOARD_SRCS) - SET(SRCS ${SRCS} ${PRODUCT_BOARD_SRCS}) + ADD_SOURCE(src/board BOARD_SRCS) + SET(SRCS ${SRCS} ${BOARD_SRCS}) +ENDIF() + +IF(CRITICAL_LOG_MODULE STREQUAL on) + ADD_SOURCE(src/critical-log CRITICAL_LOG_SRCS) + SET(SRCS ${SRCS} ${CRITICAL_LOG_SRCS}) ENDIF() INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) @@ -265,6 +270,10 @@ IF(TIZEN_FEATURE_CPU_MODULE STREQUAL on) INSTALL_CONF(conf cpu) ENDIF() +IF(CRITICAL_LOG_MODULE STREQUAL on) + INSTALL_CONF(conf critical-log) +ENDIF() + CONFIGURE_FILE(${PROJECT_NAME}.pc.in ${PROJECT_NAME}.pc @ONLY) INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) diff --git a/conf/critical-log.conf b/conf/critical-log.conf new file mode 100644 index 0000000..0f76445 --- /dev/null +++ b/conf/critical-log.conf @@ -0,0 +1,13 @@ +#Critical Log will be saved under the /var/log/ghost/boot/#booting_count +#Critical Log Format is "Section|String Value" +#Limit means Last Critical Log Logging Count +[Common] +Limit=100 +[Battery] +Limit=20 +[BatteryHealth] +Limit=10 +[PowerHandle] +Limit=10 +[CoolDown] +Limit=10 diff --git a/packaging/deviced.spec b/packaging/deviced.spec index f56037b..ea01b19 100644 --- a/packaging/deviced.spec +++ b/packaging/deviced.spec @@ -163,6 +163,7 @@ Plugin libraries for IoT devices -DTOUCH_SENSITIVITY_MODULE=on \ -DDUMP_MODULE=on \ -DDEVICE_BOARD_MODULE=on \ + -DCRITICAL_LOG_MODULE=on \ #eol %build @@ -286,6 +287,7 @@ mv %{_libdir}/iot-display.so %{_libdir}/deviced/display.so %license LICENSE.Apache-2.0 %defattr(-,root,root,-) %config %{_sysconfdir}/deviced/mobile-display.conf +%config %{_sysconfdir}/deviced/critical-log.conf %{_libdir}/mobile-display.so %files plugin-profile-wearable @@ -293,6 +295,7 @@ mv %{_libdir}/iot-display.so %{_libdir}/deviced/display.so %license LICENSE.Apache-2.0 %defattr(-,root,root,-) %config %{_sysconfdir}/deviced/wearable-display.conf +%config %{_sysconfdir}/deviced/critical-log.conf %{_libdir}/wearable-display.so %files plugin-profile-tv diff --git a/src/core/device-notifier.h b/src/core/device-notifier.h index 3196468..fe89950 100644 --- a/src/core/device-notifier.h +++ b/src/core/device-notifier.h @@ -72,6 +72,7 @@ enum device_notifier_type { DEVICE_NOTIFIER_BEZEL_WAKEUP, DEVICE_NOTIFIER_LONGKEY_RESTORE, DEVICE_NOTIFIER_ULTRAPOWERSAVING, + DEVICE_NOTIFIER_CRITICAL_LOG, DEVICE_NOTIFIER_MAX, }; diff --git a/src/core/log.c b/src/core/log.c index 86310cd..bd629a8 100644 --- a/src/core/log.c +++ b/src/core/log.c @@ -17,7 +17,9 @@ */ #include +#include #include "log.h" +#include "device-notifier.h" #ifdef DEBUG void __cyg_profile_func_enter(void *, void *) @@ -37,3 +39,15 @@ void __cyg_profile_func_exit(void *func, void *caller) g_trace_depth--; } #endif + +void critical_log_internal(const char *func, const char *fmt, ...) +{ + va_list ap; + char buf[256]; + + va_start(ap, fmt); + vsnprintf(buf, 256, fmt, ap); + va_end(ap); + _I("%s:%s", func, buf); + device_notify(DEVICE_NOTIFIER_CRITICAL_LOG, (void *)buf); +} diff --git a/src/core/log.h b/src/core/log.h index 9684f38..915e4a9 100644 --- a/src/core/log.h +++ b/src/core/log.h @@ -31,3 +31,7 @@ #define LOG_TAG "DEVICED" #include "shared/log-macro.h" #endif + +void critical_log_internal(const char *caller, const char *fmt, ...); + +#define critical_log(fmt, arg...) critical_log_internal(__func__, fmt, ##arg) diff --git a/src/critical-log/critical-log.c b/src/critical-log/critical-log.c new file mode 100644 index 0000000..154859a --- /dev/null +++ b/src/critical-log/critical-log.c @@ -0,0 +1,474 @@ +/* + * deviced + * + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include +#include +#include +#include + +#include "core/log.h" +#include "core/devices.h" +#include "core/common.h" +#include "core/config-parser.h" +#include "core/device-notifier.h" +#include "battery/power-supply.h" +#include "power/power-handler.h" + +#define CLOG_SAVE_FILE "/var/log/critical-log.log" +#define CLOG_BACKUP_FILE "/var/log/critical-log.1.log" +#define CLOG_CONF_FILE "/etc/deviced/critical-log.conf" +#define CLOG_TIME_FORMAT "%y-%m-%d/%H:%M:%S" +#define CLOG_MIN_SIZE 3 +#define CLOG_MSG_MAX 512 +#define CLOG_PATH_MAX 256 +#define BOOT_REASON_PATH "/sys/class/system_stats/rbrs" +#define CLOG_FILE_MAX 51200 + +#define CLOG_INDENTED_TAG "%*s" + +struct clog_tag_info { + char *name; + int name_len; + int type; + int count; + int limit; +}; + +struct clog_msg_info { + int type; + char *log; +}; + +static dd_list *clog_tags; +static dd_list *clog_msgs; +static int max_name_len; + +static void free_clog_data(void) +{ + dd_list *n, *next; + struct clog_tag_info *tag; + struct clog_msg_info *msg; + + DD_LIST_FOREACH_SAFE(clog_tags, n, next, tag) { + DD_LIST_REMOVE(clog_tags, tag); + if (tag->name) { + free(tag->name); + tag->name = NULL; + } + free(tag); + tag = NULL; + } + DD_LIST_FOREACH_SAFE(clog_msgs, n, next, msg) { + DD_LIST_REMOVE(clog_msgs, msg); + if (msg->log) { + free(msg->log); + msg->log = NULL; + } + free(msg); + msg = NULL; + } +} + +static int clog_load_config(struct parse_result *result, void *user_data) +{ + static int type; + struct clog_tag_info *tag = NULL; + int ret; + + if (!result || !result->section) { + _E("There is no section."); + ret = -EINVAL; + goto out; + } + + tag = calloc(1, sizeof(struct clog_tag_info)); + if (!tag) { + _E("Failed to allocate memory."); + ret = -ENOMEM; + goto out; + } + + tag->name = strdup(result->section); + if (!tag->name) { + _E("Failed to allocate memory."); + ret = -ENOMEM; + goto out; + } + type++; + tag->type = type; + tag->name_len = strlen(tag->name); + if (max_name_len < tag->name_len) + max_name_len = tag->name_len; + if (result->name && result->value && MATCH(result->name, "Limit")) + tag->limit = strtol(result->value, NULL, 10); + else + tag->limit = CLOG_MIN_SIZE; + + DD_LIST_APPEND(clog_tags, tag); + + _D("[%d]%s count %d limit %d.", tag->type, tag->name, tag->count, tag->limit); + return 0; +out: + if (tag) + free(tag); + free_clog_data(); + return ret; +} + +static int clog_execute(void *data) +{ + dd_list *n, *next; + struct clog_tag_info *tag; + struct clog_msg_info *msg; + char *input, *check, *tag_name, *name = NULL; + int name_len, ret; + struct timespec tspec; + struct tm tm_now; + char str_buff[CLOG_MSG_MAX] = {0,}; + char str_time[32] = {0,}; + char str_msec[6] = {0,}; + + if (!data) + return -EINVAL; + + msg = calloc(1, sizeof(struct clog_msg_info)); + if (!msg) { + _E("Failed to allocate memory."); + return -EINVAL; + } + + input = (char *)data; + check = strchr(input, '|'); + if (!check) { + _E("There is no tag name separator(|)."); + ret = -EINVAL; + goto out; + } + + *check = '\0'; + tag_name = input; + while (*tag_name == ' ') + tag_name++; + name = strdup(tag_name); + if (!name) { + _E("Failed to allocate memory."); + ret = -ENOMEM; + goto out; + } + *check = '|'; + + name_len = strlen(name); + DD_LIST_FOREACH_SAFE(clog_tags, n, next, tag) { + if (tag->name_len != name_len) + continue; + if (strncmp(tag->name, name, name_len)) + continue; + break; + } + if (!tag) { + _E("There is no matched tag name."); + ret = -EINVAL; + goto out; + } + + clock_gettime(CLOCK_REALTIME, &tspec); + localtime_r((time_t *)&tspec.tv_sec, &tm_now); + strftime(str_time, sizeof(str_time), CLOG_TIME_FORMAT, &tm_now); + snprintf(str_msec, sizeof(str_msec), ":%03ld|", tspec.tv_nsec / 1000000); + snprintf(str_buff, sizeof(str_buff), "%s%s[%d]%s BAT(P:%s S:%s C:%d M:%d Chg_ON:%d)\n", + str_time, str_msec, getpid(), input, + battery.power_source_s, + battery.status_s, + battery.capacity, + battery.misc, + battery.charger_charging); + _D("%s", str_buff); + msg->log = strdup(str_buff); + msg->type = tag->type; + DD_LIST_APPEND(clog_msgs, msg); + tag->count++; + + if (tag->count > tag->limit) { + DD_LIST_FOREACH_SAFE(clog_msgs, n, next, msg) { + if (tag->type != msg->type) + continue; + DD_LIST_REMOVE(clog_msgs, msg); + if (msg->log) + free(msg->log); + free(msg); + tag->count--; + break; + } + } + if (name) + free(name); + return 0; +out: + if (name) + free(name); + if (msg) { + if (msg->log) + free(msg->log); + free(msg); + } + return ret; +} + +static int clog_battery_health(void *data) +{ + char clog[CLOG_MSG_MAX] = {0,}; + static int old = HEALTH_GOOD; + int health; + + if (!data) { + _E("There is no data."); + return -EINVAL; + } + + health = *(int *)data; + if (old == health) + return 0; + + old = health; + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|%s", max_name_len, "BatteryHealth", battery.health_s); + + return clog_execute((void *)clog); +} + +static int clog_battery_present(void *data) +{ + char clog[CLOG_MSG_MAX] = {0,}; + static int old = PRESENT_NORMAL; + int present; + + if (!data) { + _E("There is no data."); + return -EINVAL; + } + + present = *(int *)data; + if (old == present) + return 0; + + old = present; + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|%s", max_name_len, "Battery", (present == PRESENT_ABNORMAL) ? "CFOpened" : "CFNormal"); + + return clog_execute((void *)clog); +} + +static void clog_save_log(void) +{ + dd_list *n, *next; + struct clog_tag_info *tag; + struct clog_msg_info *msg; + struct stat st; + int fd; + int ret; + + fd = open(CLOG_SAVE_FILE, O_RDONLY); + if (fd != -1) { + if (fstat(fd, &st) >= 0 && st.st_size > CLOG_FILE_MAX) { + if (remove(CLOG_BACKUP_FILE) < 0) + _E("Failed to remove %d.", errno); + if (rename(CLOG_SAVE_FILE, CLOG_BACKUP_FILE) < 0) + _E("Failed to backup %d.", errno); + } + close(fd); + } + + fd = open(CLOG_SAVE_FILE, O_CREAT | O_EXCL | O_WRONLY, 0644); + if (fd == -1) { + fd = open(CLOG_SAVE_FILE, O_APPEND | O_WRONLY); + if (fd == -1) { + _E("Fail to open clog file."); + return; + } + } + DD_LIST_FOREACH_SAFE(clog_msgs, n, next, msg) { + ret = write(fd, msg->log, strlen(msg->log)); + if (ret < 0) + _E("Failed to write %d", errno); + } + close(fd); + + DD_LIST_FOREACH_SAFE(clog_tags, n, next, tag) + tag->count = 0; + DD_LIST_FOREACH_SAFE(clog_msgs, n, next, msg) { + DD_LIST_REMOVE(clog_msgs, msg); + if (msg->log) { + free(msg->log); + msg->log = NULL; + } + free(msg); + msg = NULL; + } +} + +static int clog_common_log(void *data) +{ + char clog[CLOG_MSG_MAX] = {0,}; + + if (data) + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|%s", max_name_len, "Common", (char *)data); + else + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|LogDump", max_name_len, "Common"); + + clog_execute((void *)clog); + + if (!data) + clog_save_log(); + return 0; +} + +static int clog_power_off(void *data) +{ + char clog[CLOG_MSG_MAX] = {0,}; + struct power_option *opt = (struct power_option *)data; + + if (!opt || (opt->type != POWEROFF_TYPE_DIRECT && opt->type != POWEROFF_TYPE_RESTART)) + goto save_log; + + if (opt->type == POWEROFF_TYPE_DIRECT) + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|%s ", max_name_len, "PowerHandle", "PowerOff"); + else + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|%s with %s ", max_name_len, "PowerHandle", + "Reboot", (opt->option) ? opt->option : "NULL"); + + clog_execute((void *)clog); + +save_log: + clog_save_log(); + return 0; +} + +static int clog_booting_done(void *data) +{ + DIR *dir; + struct dirent *result; + static int done; + char clog[CLOG_MSG_MAX] = {0,}; + char node[CLOG_PATH_MAX] = {0,}; + char val[CLOG_PATH_MAX] = {0,}; + char elem; + int prefix; + int fd; + unsigned int cnt; + int ret; + + if (data == NULL) + return done; + done = *(int *)data; + if (done == 0) + return 0; + + snprintf(clog, CLOG_MSG_MAX, CLOG_INDENTED_TAG"|Boot", max_name_len, "PowerHandle"); + + dir = opendir(BOOT_REASON_PATH); + if (!dir) { + _E("Failed to opendir %s.", BOOT_REASON_PATH); + goto out; + } + + prefix = strlen(clog); + while ((result = readdir(dir))) { + if (strncmp(result->d_name, "summary", 7) != 0) + continue; + snprintf(node, sizeof(node), BOOT_REASON_PATH"/%s", result->d_name); + fd = open(node, O_RDONLY); + if (fd < 0) + continue; + ret = 0; + cnt = 0; + while (read(fd, &elem, 1) != 0) { + if (cnt >= 4 || ret >= CLOG_PATH_MAX - 1) + break; + if (elem != '\n') { + val[ret++] = elem; + } else { + val[ret++] = ' '; + cnt++; + } + } + val[ret] = '\0'; + snprintf(clog + prefix, CLOG_MSG_MAX - prefix, "|%s(%s) ", result->d_name, val); + close(fd); + closedir(dir); + goto out; + } + + while ((result = readdir(dir))) { + if (result->d_name[0] == '.' || + result->d_type == DT_DIR || + strncmp(result->d_name, "uevent", 6) == 0 || + strncmp(result->d_name, "power", 5) == 0 || + strncmp(result->d_name, "subsystem", 9) == 0) + continue; + snprintf(node, sizeof(node), BOOT_REASON_PATH"/%s", result->d_name); + fd = open(node, O_RDONLY); + if (fd < 0) + continue; + ret = read(fd, val, CLOG_PATH_MAX); + if (ret < 0 || ret >= CLOG_PATH_MAX) { + cnt = UINT_MAX; + } else { + val[ret] = '\0'; + cnt = strtoul(val, NULL, 10); + } + snprintf(clog + prefix, CLOG_MSG_MAX - prefix, "|%s%u ", result->d_name, cnt); + close(fd); + prefix = strlen(clog); + } + if (dir) + closedir(dir); +out: + clog_execute((void *)clog); + clog_save_log(); + unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, clog_booting_done); + return done; +} + +static void clog_init(void *none) +{ + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, clog_booting_done); + register_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, clog_battery_health); + register_notifier(DEVICE_NOTIFIER_BATTERY_PRESENT, clog_battery_present); + register_notifier(DEVICE_NOTIFIER_CRITICAL_LOG, clog_common_log); + register_notifier(DEVICE_NOTIFIER_POWEROFF, clog_power_off); + if (config_parse(CLOG_CONF_FILE, clog_load_config, NULL) < 0) + _E("Fail to init configuration."); +} + +static void clog_exit(void *data) +{ + unregister_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, clog_battery_health); + unregister_notifier(DEVICE_NOTIFIER_BATTERY_PRESENT, clog_battery_present); + unregister_notifier(DEVICE_NOTIFIER_CRITICAL_LOG, clog_common_log); + unregister_notifier(DEVICE_NOTIFIER_POWEROFF, clog_power_off); + free_clog_data(); +} + +static const struct device_ops clog_device_ops = { + .name = "clog", + .init = clog_init, + .exit = clog_exit, + .execute = clog_execute, +}; + +DEVICE_OPS_REGISTER(&clog_device_ops) -- 2.7.4 From ce471ec18f19bb184848f4c84e813b834ef4bdee Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Fri, 23 Aug 2019 17:28:08 +0900 Subject: [PATCH 14/16] Apply MCD display Change-Id: I3ee82aafab34390d6907239c2ab6542540f3abf7 Signed-off-by: lokilee73 --- plugins/iot/display/core.c | 1027 +++++++++++++++++++------- plugins/iot/display/device-interface.c | 500 +++++++++++-- plugins/iot/display/key-filter.c | 322 ++++++-- plugins/mobile/display/core.c | 1025 +++++++++++++++++++------- plugins/mobile/display/device-interface.c | 500 +++++++++++-- plugins/mobile/display/display-info.h | 50 ++ plugins/mobile/display/key-filter.c | 262 +++++-- plugins/mobile/display/proximity.c | 47 ++ plugins/mobile/display/proximity.h | 35 + plugins/tv/display/core.c | 1035 +++++++++++++++++++------- plugins/tv/display/device-interface.c | 500 +++++++++++-- plugins/tv/display/key-filter.c | 324 +++++++-- plugins/wearable/display/bezel.c | 2 +- plugins/wearable/display/core.c | 1052 ++++++++++++++++++++------- plugins/wearable/display/device-interface.c | 464 ++++++++++-- plugins/wearable/display/display-info.h | 50 ++ plugins/wearable/display/enhance.c | 7 +- plugins/wearable/display/key-filter.c | 230 ++++-- plugins/wearable/display/swim.c | 53 +- src/battery/battery-time.c | 1 - src/battery/lowbat-handler.c | 7 +- src/battery/power-supply.c | 2 +- src/board/board-info.c | 9 +- src/control/control.c | 2 +- src/core/common.c | 171 ++++- src/core/common.h | 37 +- src/core/config-parser.c | 7 +- src/core/device-notifier.c | 112 ++- src/core/device-notifier.h | 36 +- src/core/devices.c | 28 +- src/core/devices.h | 10 +- src/core/event-handler.c | 2 +- src/core/launch.c | 14 +- src/core/log.h | 7 + src/core/sig-handler.c | 2 +- src/core/udev.c | 2 +- src/core/udev.h | 9 + src/cpu/pmqos.c | 2 +- src/display/ambient-mode.c | 19 +- src/display/auto-brightness.c | 7 +- src/display/core.h | 26 +- src/display/device-interface.h | 41 +- src/display/display-dbus.c | 245 +++++-- src/display/display-ops.h | 11 + src/display/input.c | 54 +- src/display/lock-detector.c | 237 ++++-- src/display/lock-detector.h | 9 +- src/display/poll.h | 10 +- src/display/setting.c | 64 +- src/display/setting.h | 11 + src/display/slave-logging.c | 94 +++ src/dump/dump.c | 2 +- src/extcon/extcon.c | 2 +- src/extcon/extcon.h | 5 - src/ir/ir.c | 2 +- src/led/rgb.c | 2 +- src/led/torch.c | 2 +- src/led/touch-key.c | 2 +- src/power/power-handler.c | 2 +- src/shared/common.h | 6 + src/shared/deviced-systemd.c | 43 +- src/shared/deviced-systemd.h | 3 +- src/thermal/thermal.c | 2 +- src/touchscreen/sensitivity.c | 2 +- src/touchscreen/touchscreen.c | 2 +- src/tzip/tzip.c | 2 +- src/usb-host-test/usb-host-test.c | 2 +- 67 files changed, 6892 insertions(+), 1962 deletions(-) create mode 100644 plugins/mobile/display/display-info.h create mode 100644 plugins/mobile/display/proximity.c create mode 100644 plugins/mobile/display/proximity.h create mode 100644 plugins/wearable/display/display-info.h create mode 100644 src/display/slave-logging.c diff --git a/plugins/iot/display/core.c b/plugins/iot/display/core.c index 5f08790..87ceda1 100644 --- a/plugins/iot/display/core.c +++ b/plugins/iot/display/core.c @@ -35,10 +35,9 @@ #include #include #include +#include #include #include -#include -#include #include "ambient-mode.h" #include "util.h" @@ -53,13 +52,13 @@ #include "core/common.h" #include "core/config-parser.h" #include "core/launch.h" +#include "apps/apps.h" #include "extcon/extcon.h" +#include "battery/power-supply.h" #include "power/power-handler.h" #include "dd-display.h" #include "display/display-dpms.h" -#include "battery/battery.h" -#define PM_STATE_LOG_FILE tzplatform_mkpath(TZ_SYS_ALLLOGS, "pm_state.log") #define DISPLAY_CONF_FILE "/etc/deviced/display.conf" /** @@ -70,18 +69,28 @@ #define SET_BRIGHTNESS_IN_BOOTLOADER "/usr/bin/save_blenv SLP_LCD_BRIGHT" #define LOCK_SCREEN_INPUT_TIMEOUT 10000 #define LOCK_SCREEN_CONTROL_TIMEOUT 5000 -#define DD_LCDOFF_INPUT_TIMEOUT 3000 -#define ALWAYS_ON_TIMEOUT 3600000 //3600000 = 1 hour +#define ALWAYS_ON_TIMEOUT 3600000 +#define LATE_LCD_TRANSIT 1 + +#define PID_MAX 6 #define GESTURE_STR "gesture" #define POWER_KEY_STR "powerkey" #define TOUCH_STR "touch" #define EVENT_STR "event" #define TIMEOUT_STR "timeout" +#define PROXI_STR "proximity" +#define PALM_STR "palm" #define UNKNOWN_STR "unknown" +#define METHOD_APP_STATUS "CheckAppStatus" + +#define PM_WAKEUP 0 +#define PM_SUSPEND 1 + extern void init_pm_internal(); extern int get_charging_status(int *val); +extern void init_save_userlock(void); unsigned int pm_status_flag; static int trans_condition; @@ -92,6 +101,7 @@ static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT; int pm_cur_state; int pm_old_state; guint timeout_src_id; +int system_wakeup_flag = false; static unsigned int custom_normal_timeout = 0; static unsigned int custom_dim_timeout = 0; static int custom_holdkey_block = false; @@ -99,13 +109,21 @@ static int custom_change_pid = -1; static char *custom_change_name; static bool hallic_open = true; static guint lock_timeout_id; +static guint transit_timer; static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT; +static long displayoff_time; static struct timeval lcdon_tv; static int lcd_paneloff_mode = false; static int stay_touchscreen_off = false; +dd_list *lcdon_ops; +/* + * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial + * state because it should be sent from previous state at booting time. + */ static bool lcdon_broadcast = true; +static int pmstate_suspend = PM_SUSPEND; + static bool touch_blocked = false; -dd_list *lcdon_ops; /* default transition, action fuctions */ static int default_trans(int evt); @@ -116,6 +134,10 @@ static gboolean del_normal_cond(void *data); static gboolean del_dim_cond(void *data); static gboolean del_off_cond(void *data); +static gboolean pmlock_normal_check(void *data); +static gboolean pmlock_dim_check(void *data); +static gboolean pmlock_off_check(void *data); + static int default_proc_change_state(unsigned int cond, pid_t pid); static int (*proc_change_state)(unsigned int cond, pid_t pid) = default_proc_change_state; @@ -140,6 +162,10 @@ static int trans_table[S_END][EVENT_END] = { { S_POWEROFF, S_POWEROFF }, /* S_POWEROFF */ }; +static GSourceFunc warning_cb[S_END] = { + NULL, pmlock_normal_check, pmlock_dim_check, pmlock_off_check, +}; + enum signal_type { SIGNAL_INVALID = 0, SIGNAL_PRE, @@ -147,6 +173,11 @@ enum signal_type { SIGNAL_MAX, }; +enum platform_control { + PLATFORM_DISPLAY_OFF, + PLATFORM_DISPLAY_ON, +}; + static const char *lcdon_sig_lookup[SIGNAL_MAX] = { [SIGNAL_PRE] = "LCDOn", [SIGNAL_POST] = "LCDOnCompleted", @@ -178,7 +209,7 @@ static const char *lcdoff_sig_lookup[SIGNAL_MAX] = { #define LONG_PRESS_INTERVAL 2 /* 2 seconds */ #define SAMPLING_INTERVAL 1 /* 1 sec */ #define BRIGHTNESS_CHANGE_STEP 10 -#define LCD_ALWAYS_ON 1 +#define LCD_ALWAYS_ON 0 #define ACCEL_SENSOR_ON 1 #define CONTINUOUS_SAMPLING 1 #define LCDOFF_TIMEOUT 500 /* milli second */ @@ -195,13 +226,18 @@ struct display_config display_conf = { .lcdoff_timeout = LCDOFF_TIMEOUT, .brightness_change_step = BRIGHTNESS_CHANGE_STEP, .lcd_always_on = LCD_ALWAYS_ON, - .framerate_app = {1, 0, 0, 0}, - .control_display = 1, + .dimming = 1, + .framerate_app = {0, 0, 0, 0}, + .control_display = 0, .powerkey_doublepress = 0, .accel_sensor_on = ACCEL_SENSOR_ON, .continuous_sampling = CONTINUOUS_SAMPLING, - .timeout_enable = false, + .timeout_enable = true, .input_support = true, + .lockcheck_timeout = 600, + .aod_enter_level = 40, + .aod_tsp = true, + .touch_wakeup = false, }; struct display_function_info display_info = { @@ -214,9 +250,11 @@ struct display_function_info display_info = { typedef struct _pm_lock_node { pid_t pid; guint timeout_id; + guint warning_id; time_t time; bool holdkey_block; bool background; + bool broadcast_warning; } PmLockNode; static dd_list *cond_head[S_END]; @@ -231,9 +269,9 @@ static void set_process_active(bool flag, pid_t pid) /* Send dbug to resourced */ ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -287,17 +325,64 @@ void change_proc_change_state(int (*func)(unsigned int cond, pid_t pid)) proc_change_state = func; } +static inline long clock_gettime_to_long(void) +{ + struct timespec now; + int ret; + + ret = clock_gettime(CLOCK_REALTIME, &now); + + if (ret < 0) { + _E("Failed to clock gettime!"); + return 0; + } + + return SEC_TO_MSEC(now.tv_sec) + NSEC_TO_MSEC(now.tv_nsec); +} + +static int display_brightness_changed(void *data) +{ + int brt, ret; + + brt = DATA_VALUE_INT(data); + + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "Brightness", + g_variant_new("(i)", brt)); + if (ret < 0) + _E("Failed to send dbus signal Brightness."); + + return 0; +} + +static int display_auto_brightness_sensing(void *data) +{ + if (!transit_timer) + return 0; + + g_source_remove(transit_timer); + transit_timer = 0; + + return 0; +} + static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) { const char *str; const char *signal; int ret; + long diff = 0; if (type <= SIGNAL_INVALID || type >= SIGNAL_MAX) { _E("Invalid signal type(%d).", type); return; } + if (type == SIGNAL_PRE && displayoff_time != 0) + diff = clock_gettime_to_long() - displayoff_time; + if (flags & LCD_ON_BY_GESTURE) str = GESTURE_STR; else if (flags & LCD_ON_BY_POWER_KEY) @@ -315,7 +400,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, - g_variant_new("(s)", str)); + g_variant_new("(si)", str, diff)); if (ret < 0) _E("Failed to send dbus signal(%s)", signal); } @@ -331,6 +416,9 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) return; } + if (type == SIGNAL_PRE) + displayoff_time = clock_gettime_to_long(); + signal = lcdoff_sig_lookup[type]; if (flags & LCD_OFF_BY_POWER_KEY) @@ -369,9 +457,6 @@ static unsigned long get_lcd_on_flags(void) if (lcd_paneloff_mode) flags |= LCD_PANEL_OFF_MODE; - if (stay_touchscreen_off) - flags |= TOUCH_SCREEN_OFF_MODE; - if (ambient_get_condition() == true) { flags |= AMBIENT_MODE; flags |= LCD_PHASED_TRANSIT_MODE; @@ -385,6 +470,18 @@ bool touch_event_blocked(void) return touch_blocked; } +static gboolean late_transit_on(void *data) +{ + if (!transit_timer) + return G_SOURCE_REMOVE; + + g_source_remove(transit_timer); + transit_timer = 0; + + backlight_ops.transit_state(DPMS_ON); + return G_SOURCE_REMOVE; +} + void lcd_on_procedure(int state, enum device_flags flag) { dd_list *l = NULL; @@ -392,19 +489,29 @@ void lcd_on_procedure(int state, enum device_flags flag) unsigned long flags = get_lcd_on_flags(); flags |= flag; - /* send LCDOn dbus signal */ - if (!lcdon_broadcast) { - broadcast_lcd_on(SIGNAL_PRE, flags); - lcdon_broadcast = true; - } + /* + * Display on procedure + * step 1. broadcast lcd on signal with cause + * step 2. set brightness + * step 3. set pmstate of vconf + * step 4. display on operate + * - a. display on + * - b. TSP(touch screen) and touchkey enable + * step 5. broadcast lcd on complete siganl + * step 6. key backlight enable + */ + _I("[lcdstep] %lu", flags); if (flags & AMBIENT_MODE) { - if (ambient_get_state() == false && - backlight_ops.get_lcd_power() == DPMS_ON) + if (ambient_get_state() == false && backlight_ops.get_lcd_power() == DPMS_ON) return; ambient_set_state(false); } + /* send LCDOn dbus signal */ + if (!lcdon_broadcast) + broadcast_lcd_on(SIGNAL_PRE, flags); + if (!(flags & LCD_PHASED_TRANSIT_MODE)) { /* Update brightness level */ if (state == LCD_DIM) @@ -421,7 +528,13 @@ void lcd_on_procedure(int state, enum device_flags flag) DD_LIST_FOREACH(lcdon_ops, l, ops) ops->start(flags); + if (!lcdon_broadcast) { broadcast_lcd_on(SIGNAL_POST, flags); + if (flags & LCD_PHASED_TRANSIT_MODE) + transit_timer = g_timeout_add_seconds(LATE_LCD_TRANSIT, + late_transit_on, NULL); + lcdon_broadcast = true; + } if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(true); @@ -429,7 +542,7 @@ void lcd_on_procedure(int state, enum device_flags flag) touch_blocked = false; } -static inline unsigned long get_lcd_off_flags(void) +static unsigned long get_lcd_off_flags(void) { unsigned long flags = NORMAL_MODE; @@ -438,10 +551,12 @@ static inline unsigned long get_lcd_off_flags(void) flags |= LCD_PHASED_TRANSIT_MODE; } + if (stay_touchscreen_off) + flags |= TOUCH_SCREEN_OFF_MODE; + return flags; } - inline void lcd_off_procedure(enum device_flags flag) { dd_list *l = NULL; @@ -449,6 +564,20 @@ inline void lcd_off_procedure(enum device_flags flag) unsigned long flags = get_lcd_off_flags(); flags |= flag; + /* + * Display off procedure + * step 0. enhance mode off using nofity (e.g mdnie, HBM, LBM) + * step 1. broadcast lcd off signal with cause + * step 2. set pmstate of vconf + * step 3. display off operate + * - a. display off + * - b. TSP(touch screen) and touchkey disable + * step 4. broadcast lcd off complete siganl + */ + _I("[lcdstep] %lu", flags); + + device_notify(DEVICE_NOTIFIER_LCD_OFF, NULL); + touch_blocked = true; if (flags & AMBIENT_MODE) { @@ -461,18 +590,23 @@ inline void lcd_off_procedure(enum device_flags flag) broadcast_lcd_off(SIGNAL_PRE, flags); lcdon_broadcast = false; } + set_setting_pmstate(S_LCDOFF); + if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(false); - set_setting_pmstate(S_LCDOFF); + if (transit_timer) { + g_source_remove(transit_timer); + transit_timer = 0; + } + + if (flags & LCD_PHASED_TRANSIT_MODE) + backlight_ops.transit_state(DPMS_OFF); DD_LIST_FOREACH(lcdon_ops, l, ops) ops->stop(flags); if (flags & AMBIENT_MODE) - /* Do not broadcast the post signal here. - * The signal will be broadcasted - * after showing Ambient clock */ broadcast_lcd_off_late(flags); else broadcast_lcd_off(SIGNAL_POST, flags); @@ -480,20 +614,20 @@ inline void lcd_off_procedure(enum device_flags flag) void set_stay_touchscreen_off(int val) { - _D("stay touch screen off: %d", val); + _I("Stay touch screen off: %d", val); stay_touchscreen_off = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } void set_lcd_paneloff_mode(int val) { - _D("lcd paneloff mode: %d", val); + _I("Lcd paneloff mode: %d", val); lcd_paneloff_mode = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } int low_battery_state(int val) @@ -537,7 +671,7 @@ static void makeup_trans_condition(void) static PmLockNode *find_node(enum state_t s_index, pid_t pid) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; DD_LIST_FOREACH(cond_head[s_index], elem, t) { if (t->pid == pid) @@ -550,21 +684,28 @@ static PmLockNode *find_node(enum state_t s_index, pid_t pid) static PmLockNode *add_node(enum state_t s_index, pid_t pid, guint timeout_id, bool holdkey_block) { + guint warning_id = 0; PmLockNode *n; time_t now; n = (PmLockNode *) malloc(sizeof(PmLockNode)); if (n == NULL) { - _E("Failed to add cond. Not enough memory."); + _E("Not enough memory, add cond. fail"); return NULL; } + if (pid < INTERNAL_LOCK_BASE) + warning_id = g_timeout_add_seconds(display_conf.lightsensor_interval, + warning_cb[s_index], (void *)((intptr_t)pid)); + time(&now); n->pid = pid; n->timeout_id = timeout_id; + n->warning_id = warning_id; n->time = now; n->holdkey_block = holdkey_block; n->background = false; + n->broadcast_warning = true; DD_LIST_APPEND(cond_head[s_index], n); refresh_app_cond(); @@ -583,6 +724,11 @@ static int del_node(enum state_t s_index, PmLockNode *n) g_source_remove(n->timeout_id); n->timeout_id = 0; } + if (n->warning_id) { + g_source_remove(n->warning_id); + n->warning_id = 0; + } + free(n); refresh_app_cond(); return 0; @@ -590,6 +736,7 @@ static int del_node(enum state_t s_index, PmLockNode *n) static void print_node(int next) { + int ret; dd_list *elem; PmLockNode *n; char buf[30]; @@ -604,10 +751,20 @@ static void print_node(int next) diff = difftime(now, n->time); ctime_r(&n->time, buf); - if (diff > LOCK_TIME_WARNING) - _W("over=%.0f s pid=%5d locktime=%s", diff, n->pid, buf); - else - _I("pid=%5d locktime=%s", n->pid, buf); + if (diff > LOCK_TIME_WARNING) { + if (diff > LOCK_TIME_WARNING * 60 && n->pid < INTERNAL_LOCK_BASE && n->broadcast_warning) { + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_over", + g_variant_new("(i)", n->pid)); + if (ret < 0) + _E("Failed to send dbus signal pmlock_over."); + n->broadcast_warning = false; + } + _W("Over(%.0f s) pid( %5d) lock time(%s)", diff, n->pid, buf); + } else + _I("Pid(%5d) lock time(%s)", n->pid, buf); } } @@ -640,7 +797,6 @@ void get_pname(pid_t pid, char *pname) static void del_state_cond(void *data, enum state_t state) { PmLockNode *tmp = NULL; - char pname[PATH_MAX]; pid_t pid; if (!data) @@ -648,18 +804,20 @@ static void del_state_cond(void *data, enum state_t state) /* A passed data is a pid_t type data, not a 64bit data. */ pid = (pid_t)((intptr_t)data); - _I("Delete process(%d)'s prohibit dim condition by timeout.", pid); + _I("delete prohibit dim condition by timeout (%d)", pid); + + if (pid == INTERNAL_LOCK_AMBIENT) + ambient_check_invalid_state(pid); tmp = find_node(state, pid); del_node(state, tmp); - get_pname(pid, pname); - set_unlock_time(pname, state); + set_unlock_time(pid, state); if (!timeout_src_id) states[pm_cur_state].trans(EVENT_TIMEOUT); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); } static gboolean del_normal_cond(void *data) @@ -680,23 +838,91 @@ static gboolean del_off_cond(void *data) return G_SOURCE_REMOVE; } -/* timeout handler */ -gboolean timeout_handler(void *data) +static void pmlock_check_cb(GVariant *var, void *user_data, GError *err) { - int run_timeout; + pid_t pid; + int ret, state; + char *app_id; - _I("Time out state %s.\n", states[pm_cur_state].name); - /* default setting */ - get_run_timeout(&run_timeout); + if (!var) + return; - /* for sdk - * if the run_timeout is zero, it regards AlwaysOn state + if (!dh_get_param_from_var(var, "(iis)", &pid, &state, &app_id)) { + _E("Failed to notify low: no message(%s)", g_variant_get_type_string(var)); + goto out; + } + + _W("%s(%d) was requested pmlock for a long time.", app_id, pid); + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_expired", + g_variant_new("(i)", pid)); + if (ret < 0) + _E("Failed to send dbus pmlock_expired"); + +out: + g_variant_unref(var); +} + +/* + * Any process is possible many time lock, deviced can not know malicious + * or good process. so infinity or more then 1 min lock process, deviced + * will be checked it to resoured. And then, it will be asked quit or maintain to user. */ - if (pm_cur_state == S_NORMAL && (run_timeout == 0 || display_conf.lcd_always_on)) { - _D("'run_timeout' is always on."); - return G_SOURCE_CONTINUE; +static void pmlock_check(void *data, char *st) +{ + const char *arr[2]; + char chr_pid[PID_MAX]; + pid_t pid; + int ret; + + if (!data || !st) + return; + + if (!strncmp(st, "lcdoff", 4) && backlight_ops.get_lcd_power() == DPMS_ON) { + _D("Lcd state is PM_LCD_POWER_ON"); + return; } + pid = (pid_t)((intptr_t)data); + snprintf(chr_pid, sizeof(chr_pid), "%d", pid); + + arr[0] = chr_pid; + arr[1] = st; + + ret = dbus_handle_method_async_with_reply(RESOURCED_BUS_NAME, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + METHOD_APP_STATUS, + "is", arr, pmlock_check_cb, -1, NULL); + if (ret < 0) + _E("Failed to call dbus method"); +} + +static gboolean pmlock_normal_check(void *data) +{ + pmlock_check(data, "normal"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_dim_check(void *data) +{ + pmlock_check(data, "lcddim"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_off_check(void *data) +{ + pmlock_check(data, "lcdoff"); + return G_SOURCE_CONTINUE; +} + +/* timeout handler */ +gboolean timeout_handler(void *data) +{ + _I("Time out state %s", states[pm_cur_state].name); + if (timeout_src_id) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -711,7 +937,7 @@ void reset_timeout(int timeout) if (!display_conf.timeout_enable) return; - _I("Reset timeout(%d ms)", timeout); + _I("Reset timeout(%d ms).", timeout); if (timeout_src_id != 0) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -752,7 +978,7 @@ static int get_lcd_timeout_from_settings(void) if (val > 0) states[i].timeout = val; - _I("state=%s timeout=%d ms", states[i].name, + _I("State(%s) timeout(%d) ms", states[i].name, states[i].timeout); } @@ -775,7 +1001,7 @@ static void update_display_time(void) if (custom_normal_timeout > 0) { states[S_NORMAL].timeout = custom_normal_timeout; states[S_LCDDIM].timeout = custom_dim_timeout; - _I("CUSTOM: Timeout(%d ms) and dim(%d ms) are set by normal.", + _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)", custom_normal_timeout, custom_dim_timeout); return; } @@ -806,7 +1032,8 @@ static void update_display_time(void) get_dim_timeout(&val); states[S_LCDDIM].timeout = val; - _I("Normal: timeout(%d ms) and dim(%d ms) are set.", states[S_NORMAL].timeout, states[S_LCDDIM].timeout); + _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout); + _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout); } static void update_display_locktime(int time) @@ -815,7 +1042,6 @@ static void update_display_locktime(int time) update_display_time(); } - void set_dim_state(bool on) { _I("Dim state is %d.", on); @@ -823,31 +1049,58 @@ void set_dim_state(bool on) states[pm_cur_state].trans(EVENT_INPUT); } +static void broadcast_pm_suspend(void) +{ + int ret; -void lcd_on_direct(enum device_flags flags) + if (pmstate_suspend) + return; + + _D("PM will be changed to sleep."); + + pmstate_suspend = PM_SUSPEND; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "sleep", + NULL); + if (ret < 0) + _E("Failed to send dbus signal sleep."); +} + +static void broadcast_pm_wakeup(void) { - int ret, call_state; + int ret; + + if (!pmstate_suspend) + return; + + _D("PM is changed to wakeup."); + + pmstate_suspend = PM_WAKEUP; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "wakeup", + NULL); + if (ret < 0) + _E("Failed to send dbus signal wakeup."); +} + +void lcd_on_direct(enum device_flags flags) +{ if (power_ops.get_power_lock_support() - && pm_cur_state == S_SLEEP) + && pm_cur_state == S_SLEEP) { + broadcast_pm_wakeup(); power_ops.power_lock(); + pm_cur_state = S_NORMAL; + } -#ifdef MICRO_DD - _D("Lcd is on directly."); + _D("lcd is on directly"); gettimeofday(&lcdon_tv, NULL); lcd_on_procedure(LCD_NORMAL, flags); - reset_timeout(DD_LCDOFF_INPUT_TIMEOUT); -#else - ret = vconf_get_int(VCONFKEY_CALL_STATE, &call_state); - if ((ret >= 0 && call_state != VCONFKEY_CALL_OFF) || - (__get_lock_screen_state() == VCONFKEY_IDLE_LOCK)) { - _D("LOCK state, lcd is on directly."); - lcd_on_procedure(LCD_NORMAL, flags); - } else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - reset_timeout(display_conf.lcdoff_timeout); -#endif + update_display_locktime(LOCK_SCREEN_INPUT_TIMEOUT); } @@ -859,6 +1112,41 @@ static inline bool check_lcd_is_on(void) return true; } +static int check_lock_condition(enum state_t state) +{ + dd_list *elem; + PmLockNode *t = NULL; + int ret = false; + pid_t owner = getpid(); + + _D("check holdkey block : state of %s", states[state].name); + + DD_LIST_FOREACH(cond_head[state], elem, t) { + if (t->pid != owner && t->background == false) { + ret = true; + _I("state change was blocked by pid(%d)!", t->pid); + break; + } + } + + return ret; +} + +static gboolean timer_refresh_cb(gpointer data) +{ + struct state *st; + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + if (st->action) + st->action(st->timeout); + + return 0; +} + int custom_lcdon(int timeout) { struct state *st; @@ -882,9 +1170,157 @@ int custom_lcdon(int timeout) if (st->action) st->action(st->timeout); + g_idle_add(timer_refresh_cb, NULL); + + return 0; +} + +int custom_lcdoff(enum device_flags flag) +{ + struct state *st; + + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + /* + * When another proccess is normal lock, device is received call then, + * call app can be changed to lcd state by proximity. + * If proximity is near then normal lock will be unlocked. + */ + if (flag & LCD_OFF_BY_PROXIMITY) { + _I("custom lcd off by proximity, delete normal lock"); + delete_condition(S_NORMAL); + } else { + _I("skip custom lcd off"); + return -ECANCELED; + } + } + + _I("custom lcd off by flag(%d)", flag); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + if (set_custom_lcdon_timeout(0) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_on(char *reason, int timeout) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) + flag = LCD_ON_BY_GESTURE; + else if (!strncmp(reason, EVENT_STR, str_len)) + flag = LCD_ON_BY_EVENT; + else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + if (timeout <= 0) { + _E("Cannot setting timeout %d", timeout); + return -EINVAL; + } + + if (check_lcd_is_on() == false) + lcd_on_direct(flag); + + _I("platform lcd on by %s (%d ms)", reason, timeout); + if (set_custom_lcdon_timeout(timeout) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_off(char *reason) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) { + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + _I("skip platform lcd off by gesture"); + return -ECANCELED; + } + flag = LCD_OFF_BY_GESTURE; + } else if (!strncmp(reason, PALM_STR, str_len)) { + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); + + flag = LCD_OFF_BY_PALM; + } else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + _I("platform lcd off by %s", reason); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + return 0; } +int display_platform_control(int type, char *reason, int timeout) +{ + int ret; + + switch (type) { + case PLATFORM_DISPLAY_ON: + ret = display_platform_on(reason, timeout); + break; + case PLATFORM_DISPLAY_OFF: + ret = display_platform_off(reason); + break; + default: + _E("Unkown type(%d)", type); + ret = -EINVAL; + } + + return ret; +} + static void default_proc_change_state_action(enum state_t next, int timeout) { struct state *st; @@ -920,7 +1356,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) default_proc_change_state_action(next, -1); break; case S_LCDOFF: - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_EVENT); if (set_custom_lcdon_timeout(0)) update_display_time(); @@ -931,7 +1367,14 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) /* at first LCD_OFF and then goto sleep */ /* state transition */ default_proc_change_state_action(S_LCDOFF, TIMEOUT_NONE); + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); delete_condition(S_LCDOFF); + if (lcdon_broadcast) { + _I("broadcast lcd off signal at non-lcd device"); + broadcast_lcd_off(SIGNAL_PRE, 0); + broadcast_lcd_off(SIGNAL_POST, 0); + } default_proc_change_state_action(S_SLEEP, TIMEOUT_NONE); break; @@ -966,15 +1409,18 @@ static void proc_condition_lock(PMMsg *data) pid_t pid = data->pid; enum state_t state; int holdkey_block; + bool value = true; + unsigned int flags; state = GET_COND_STATE(data->cond); - if (!state) + if (state == S_START) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); - if (state == S_LCDOFF && - pm_cur_state == S_SLEEP) + if (state == S_LCDOFF && pm_cur_state == S_SLEEP && + power_ops.get_power_lock() == POWER_UNLOCK) proc_change_state(data->cond, INTERNAL_LOCK_PM); if (data->timeout > 0) { @@ -1000,14 +1446,15 @@ static void proc_condition_lock(PMMsg *data) } if (state == S_LCDOFF) - set_process_active(TRUE, pid); + set_process_active(true, pid); + _I("[%s] locked by %5d with %u ms", states[state].name, pid, data->timeout); /* for debug */ - _SD("[%s] Locked by pid=%d process=%s holdkeyblock=%d\n", - states[state].name, pid, pname, holdkey_block); - set_lock_time(pname, state); + _SD("be requested LOCK info pname(%s), holdkeyblock(%d) flags(%d)", + pname, holdkey_block, flags); + set_lock_time(pid, pname, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)true); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static void proc_condition_unlock(PMMsg *data) @@ -1016,27 +1463,28 @@ static void proc_condition_unlock(PMMsg *data) enum state_t state; PmLockNode *tmp; char pname[PATH_MAX]; + bool value = false; + unsigned int flags; state = GET_COND_STATE(data->cond); if (!state) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); tmp = find_node(state, pid); del_node(state, tmp); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); - if (ambient_get_state()) - ambient_check_invalid_state(pid); - - _SD("[%s] Unlocked by pid=%d process=%s\n", - states[state].name, pid, pname); - set_unlock_time(pname, state); + _I("[%s] unlocked by %5d", states[state].name, pid); + /* for debug */ + _SD("be requested UNLOCK info pname(%s) flag(%d)", pname, flags); + set_unlock_time(pid, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)false); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static int proc_condition(PMMsg *data) @@ -1055,15 +1503,11 @@ static int proc_condition(PMMsg *data) flags = GET_COND_FLAG(data->cond); if (flags == 0) { /* guard time for suspend */ - if (pm_cur_state == S_LCDOFF) { + if (pm_cur_state == S_LCDOFF) reset_timeout(states[S_LCDOFF].timeout); - _I("Margin timeout(%d ms)", states[S_LCDOFF].timeout); - } } else { - if (flags & PM_FLAG_RESET_TIMER) { + if (flags & PM_FLAG_RESET_TIMER) reset_timeout(states[pm_cur_state].timeout); - _I("Reset timeout(%d ms)", states[pm_cur_state].timeout); - } } if (!timeout_src_id) @@ -1076,13 +1520,13 @@ static int proc_condition(PMMsg *data) int check_processes(enum state_t prohibit_state) { dd_list *elem, *next; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; DD_LIST_FOREACH_SAFE(cond_head[prohibit_state], elem, next, t) { if (t->pid < INTERNAL_LOCK_BASE && kill(t->pid, 0) == -1) { - _E("Process(%d) does not exist, delete the REQ" - " - prohibit state=%d.", + _E("%d process does not exist, delete the REQ" + " - prohibit state %d ", t->pid, prohibit_state); if (t->pid == custom_change_pid) { get_lcd_timeout_from_settings(); @@ -1090,6 +1534,7 @@ int check_processes(enum state_t prohibit_state) custom_change_pid = -1; } ret = 1; + set_unlock_time(t->pid, prohibit_state); del_node(prohibit_state, t); } } @@ -1100,7 +1545,7 @@ int check_processes(enum state_t prohibit_state) int check_holdkey_block(enum state_t state) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; _I("Check holdkey block: state of %s", states[state].name); @@ -1125,11 +1570,9 @@ int check_holdkey_block(enum state_t state) int delete_condition(enum state_t state) { dd_list *elem, *next; - PmLockNode *t; - pid_t pid; - char pname[PATH_MAX]; + PmLockNode *t = NULL; - _I("Delete condition: state of %s", states[state].name); + _I("delete condition : state of %s", states[state].name); if (!cond_head[state]) return 0; @@ -1139,13 +1582,11 @@ int delete_condition(enum state_t state) g_source_remove(t->timeout_id); t->timeout_id = 0; } - pid = t->pid; if (state == S_LCDOFF) - set_process_active(FALSE, pid); - _I("Delete node of pid(%d).", pid); + set_process_active(false, t->pid); + _I("delete node of pid(%d)", t->pid); + set_unlock_time(t->pid, state); del_node(state, t); - get_pname(pid, pname); - set_unlock_time(pname, state-1); } DD_LIST_FREE_LIST(cond_head[state]); @@ -1187,8 +1628,9 @@ static pm_history pm_history_log[MAX_LOG_COUNT] = {{0, }, }; static int history_count = 0; static const char history_string[PM_LOG_MAX][15] = { - "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON FAIL", - "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF FAIL", "SLEEP"}; + "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON COMPL", "LCD ON FAIL", + "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF COMPL", "LCD OFF FAIL", + "LCD FAIL", "SLEEP"}; void pm_history_init() { @@ -1241,7 +1683,7 @@ void pm_history_print(int fd, int count) time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } #endif @@ -1265,13 +1707,13 @@ void print_info(int fd) "===========================\n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Timeout Info: Run[%dms] Dim[%dms] Off[%dms]\n", states[S_NORMAL].timeout, states[S_LCDDIM].timeout, states[S_LCDOFF].timeout); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Tran. Locked : %s %s %s\n", (trans_condition & MASK_NORMAL) ? states[S_NORMAL].name : "-", @@ -1279,18 +1721,18 @@ void print_info(int fd) (trans_condition & MASK_OFF) ? states[S_LCDOFF].name : "-"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current State: %s\n", states[pm_cur_state].name); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current Lock Conditions: \n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); for (s_index = S_NORMAL; s_index < S_END; s_index++) { DD_LIST_FOREACH(cond_head[s_index], elem, t) { @@ -1301,7 +1743,7 @@ void print_info(int fd) i++, states[s_index].name, t->pid, pname, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } @@ -1312,37 +1754,39 @@ void print_info(int fd) #endif } -void save_display_log(void) +void save_display_log(char *path) { int fd, ret; char buf[255]; time_t now_time; char time_buf[30]; - _D("Internal state is saved."); + _D("internal state is saved!"); time(&now_time); ctime_r(&now_time, time_buf); - fd = open(PM_STATE_LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, 0644); + fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0644); if (fd != -1) { snprintf(buf, sizeof(buf), "\npm_state_log now-time : %d(s) %s\n\n", (int)now_time, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); snprintf(buf, sizeof(buf), "pm_status_flag: %x\n", pm_status_flag); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); - snprintf(buf, sizeof(buf), "screen lock status : %d\n", - __get_lock_screen_state()); - ret = write(fd, buf, strlen(buf)); - if (ret < 0) - _E("write() failed: %d", errno); + if (disp_plgn.get_lock_screen_state ) { + snprintf(buf, sizeof(buf), "screen lock status : %d\n", + disp_plgn.get_lock_screen_state()); + ret = write(fd, buf, strlen(buf)); + if (ret < 0) + _E("write() failed (%d)", errno); + } print_info(fd); close(fd); } @@ -1359,7 +1803,9 @@ void save_display_log(void) */ static void sig_hup(int signo) { - save_display_log(); + _I("received sig hub %d", signo); + + pm_save_logdump(); } int check_lcdoff_direct(void) @@ -1373,6 +1819,9 @@ int check_lcdoff_direct(void) if (pm_cur_state != S_LCDDIM) return false; + if (!display_conf.dimming) + return true; + lock = __get_lock_screen_state(); if (lock != VCONFKEY_IDLE_LOCK && hallic_open) return false; @@ -1387,7 +1836,7 @@ int check_lcdoff_direct(void) else if (ret < 0) _E("Failed to get vconf value for cradle status: %d", vconf_get_ext_errno()); - _D("Goto LCDOFF direct(lock=%d hdmi=%d cradle=%d).", lock, hdmi_state, cradle); + _D("Goto LCDOFF direct: lock(%d) hdmi(%d) cradle(%d).", lock, hdmi_state, cradle); return true; } @@ -1481,22 +1930,10 @@ static inline void stop_lock_timer(void) static void check_lock_screen(void) { - int lock_setting, lock_state, app_state, ret; + int lock_state, ret; stop_lock_timer(); - ret = vconf_get_int(VCONFKEY_CALL_STATE, &app_state); - if (ret >= 0 && app_state != VCONFKEY_CALL_OFF) - goto lcd_on; - else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - /* check setting of lock screen is enabled. */ - ret = vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, - &lock_setting); - if (ret < 0) - _E("Failed to get vconf value for screen lock type: %d", vconf_get_ext_errno()); - /* check state of lock */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); if (ret < 0 || lock_state == VCONFKEY_IDLE_LOCK) { @@ -1551,10 +1988,12 @@ static int default_action(int timeout) } if (pm_cur_state != pm_old_state && pm_cur_state != S_SLEEP) { - if (power_ops.get_power_lock_support()) + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); power_ops.power_lock(); + } set_setting_pmstate(pm_cur_state); - device_notify(DEVICE_NOTIFIER_LCD, &pm_cur_state); + device_notify(DEVICE_NOTIFIER_LCD, (void *)&pm_cur_state); } if (pm_old_state == S_NORMAL && pm_cur_state != S_NORMAL) { @@ -1594,11 +2033,11 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) { stop_lock_timer(); /* lcd off state : turn off the backlight */ - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); } - if (backlight_ops.get_lcd_power() != DPMS_OFF + if (backlight_ops.get_lcd_power() == DPMS_ON || lcd_paneloff_mode) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); break; @@ -1607,7 +2046,7 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) stop_lock_timer(); - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); if (!power_ops.get_power_lock_support()) { @@ -1634,6 +2073,7 @@ go_suspend: #ifdef ENABLE_PM_LOG pm_history_save(PM_LOG_SLEEP, pm_cur_state); #endif + broadcast_pm_suspend(); if (power_ops.get_power_lock_support()) { if (power_ops.enable_autosleep) power_ops.enable_autosleep(); @@ -1641,24 +2081,9 @@ go_suspend: if (power_ops.power_unlock() < 0) _E("Power unlock state error."); } else { - dd_list *elem, *elem_n; - const struct device_ops *dev; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } - power_ops.suspend(); - - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } - - _I("System wakeup."); - disp_plgn.system_wakeup_flag = true; + _I("system wakeup!!"); + system_wakeup_flag = true; /* Resume !! */ if (power_ops.check_wakeup_src() == EVENT_DEVICE) /* system waked up by devices */ @@ -1739,7 +2164,7 @@ static int poll_callback(int condition, PMMsg *data) if (condition == INPUT_POLL_EVENT) { if (pm_cur_state == S_LCDOFF || pm_cur_state == S_SLEEP) - _I("Power key input."); + _I("Input event signal at Display Off"); time(&now); if (last_t != now || pm_cur_state == S_LCDOFF || @@ -1800,11 +2225,13 @@ static int update_setting(int key_idx, int val) } pm_status_flag |= CHRGR_FLAG; } else { - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { power_saving_func(true); pm_status_flag |= LOWBT_FLAG; @@ -1877,9 +2304,9 @@ static void check_seed_status(void) { int ret = -1; int tmp = 0; - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; int brt = 0; - int lock_state = -1; + int lock_state; /* Charging check */ if ((get_charging_status(&tmp) == 0) && (tmp > 0)) @@ -1898,10 +2325,13 @@ static void check_seed_status(void) } _I("Set brightness(%d) from setting app.", tmp); backlight_ops.set_default_brt(tmp); + backlight_ops.set_brightness(tmp); ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { if (!(pm_status_flag & CHRGR_FLAG)) { power_saving_func(true); @@ -1911,9 +2341,10 @@ static void check_seed_status(void) /* lock screen check */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); - if (ret < 0) + if (ret < 0) { + lock_state = -1; _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno()); - + } set_lock_screen_state(lock_state); if (lock_state == VCONFKEY_IDLE_LOCK) { states[S_NORMAL].timeout = lock_screen_timeout; @@ -2043,36 +2474,20 @@ void reset_lcd_timeout(GDBusConnection *conn, static int booting_done(void *data) { - static int done; - - if (!data) - return done; + static bool done = false; + if (data != NULL) { done = *(int*)data; - if (!done) - return done; - - _I("Booting done. Release display and power lock."); - if (disp_plgn.pm_unlock_internal) { - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + if (done) + return 0; + _I("booting done, unlock LCD_OFF"); + if (disp_plgn.pm_unlock_internal) { + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); + } } - return done; -} - -int device_poweroff(void *data) -{ - static int off; - - if (!data) - return off; - - off = *(int *)data; - if (off) - _I("Poweroff"); - - return off; + return 0; } static int process_background(void *data) @@ -2085,7 +2500,7 @@ static int process_background(void *data) node = find_node(S_NORMAL, pid); if (node) { node->background = true; - _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); + _I("%d pid is background, then PM will be unlocked LCD_NORMAL", pid); } return 0; @@ -2101,9 +2516,29 @@ static int process_foreground(void *data) node = find_node(S_NORMAL, pid); if (node) { node->background = false; - _I("Process(%d) is foreground, then PM will be maintained locked LCD_NORMAL.", pid); + _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); + } + + return 0; +} + +static int battery_health_changed(void *data) +{ + int health = DATA_VALUE_INT(data); + + _I("battery health change %d", health); + + if (health == HEALTH_GOOD) { + pm_status_flag &= ~BATTERY_FLAG; + pm_status_flag &= ~DIMSTAY_FLAG; + } else if (health == HEALTH_LOW || health == HEALTH_HIGH || health == HEALTH_OVP) { + pm_status_flag |= BATTERY_FLAG; + pm_status_flag |= DIMSTAY_FLAG; } + if (backlight_ops.get_lcd_power() == DPMS_ON) + backlight_ops.update(); + return 0; } @@ -2121,49 +2556,58 @@ static int display_load_config(struct parse_result *result, void *user_data) if (MATCH(result->name, "LockScreenWaitingTime")) { SET_CONF(c->lock_wait_time, atof(result->value)); - _D("'lock wait time' is %.3f.", c->lock_wait_time); + _D("lock wait time is %.3f", c->lock_wait_time); } else if (MATCH(result->name, "LongPressInterval")) { SET_CONF(c->longpress_interval, atof(result->value)); - _D("'long press interval' is %.3f.", c->longpress_interval); + _D("long press interval is %.3f", c->longpress_interval); } else if (MATCH(result->name, "LightSensorSamplingInterval")) { SET_CONF(c->lightsensor_interval, atof(result->value)); - _D("'lightsensor interval' is %.3f.", c->lightsensor_interval); + _D("lightsensor interval is %.3f", c->lightsensor_interval); } else if (MATCH(result->name, "LCDOffTimeout")) { SET_CONF(c->lcdoff_timeout, atoi(result->value)); - _D("'lcdoff timeout' is %d ms.", c->lcdoff_timeout); + _D("lcdoff timeout is %d ms", c->lcdoff_timeout); } else if (MATCH(result->name, "BrightnessChangeStep")) { SET_CONF(c->brightness_change_step, atoi(result->value)); - _D("'brightness change step' is %d.", c->brightness_change_step); + _D("brightness change step is %d", c->brightness_change_step); } else if (MATCH(result->name, "LCDAlwaysOn")) { c->lcd_always_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'LCD always on' is %d.", c->lcd_always_on); + _D("LCD always on is %d", c->lcd_always_on); + } else if (MATCH(result->name, "Dimming")) { + c->dimming = (MATCH(result->value, "yes") ? 1 : 0); + _D("Dimming is %d", c->dimming); } else if (MATCH(result->name, "ChangedFrameRateAllowed")) { if (strstr(result->value, "setting")) { c->framerate_app[REFRESH_SETTING] = 1; - _D("'framerate app' is setting"); + _D("framerate app is Setting"); } if (strstr(result->value, "all")) { memset(c->framerate_app, 1, sizeof(c->framerate_app)); - _D("'framerate app' is all"); + _D("framerate app is All"); } } else if (MATCH(result->name, "ControlDisplay")) { c->control_display = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ControlDisplay' is %d.", c->control_display); + _D("ControlDisplay is %d", c->control_display); } else if (MATCH(result->name, "PowerKeyDoublePressSupport")) { c->powerkey_doublepress = (MATCH(result->value, "yes") ? 1 : 0); - _D("'PowerKeyDoublePressSupport' is %d.", c->powerkey_doublepress); + _D("PowerKeyDoublePressSupport is %d", c->powerkey_doublepress); } else if (MATCH(result->name, "AccelSensorOn")) { c->accel_sensor_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'AccelSensorOn' is %d.", c->accel_sensor_on); + _D("AccelSensorOn is %d", c->accel_sensor_on); } else if (MATCH(result->name, "ContinuousSampling")) { c->continuous_sampling = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ContinuousSampling' is %d.", c->continuous_sampling); + _D("ContinuousSampling is %d", c->continuous_sampling); } else if (MATCH(result->name, "TimeoutEnable")) { c->timeout_enable = (MATCH(result->value, "yes") ? true : false); - _D("'Timeout' is %s.", c->timeout_enable ? "enalbed" : "disabled"); + _D("Timeout is %s", c->timeout_enable ? "enalbed" : "disabled"); } else if (MATCH(result->name, "InputSupport")) { c->input_support = (MATCH(result->value, "yes") ? true : false); - _D("'Input' is %s.", c->input_support ? "supported" : "NOT supported"); + _D("Input is %s", c->input_support ? "supported" : "NOT supported"); + } else if (MATCH(result->name, "LockCheckTimeout")) { + SET_CONF(c->lockcheck_timeout, atoi(result->value)); + _D("LockCheckTimeout is %d", c->lockcheck_timeout); + } else if (MATCH(result->name, "AODTSP")) { + c->aod_tsp = (MATCH(result->value, "yes") ? true : false); + _D("TSP control at is %d at aod", c->aod_tsp); } return 0; @@ -2226,9 +2670,58 @@ static int display_probe(void *data) return 0; } +static int input_init_handler(void) +{ + if (!display_conf.input_support) + return 0; + + g_idle_add(init_input, NULL); + + return 0; +} + +static void esd_action(void) +{ + const struct device_ops *touchscreen_ops = NULL; + + _I("ESD on"); + + touchscreen_ops = find_device("touchscreen"); + + if (!check_default(touchscreen_ops)) + touchscreen_ops->stop(NORMAL_MODE); + backlight_ops.off(NORMAL_MODE); + backlight_ops.on(NORMAL_MODE); + if (!check_default(touchscreen_ops)) + touchscreen_ops->start(NORMAL_MODE); +} + +static void lcd_uevent_changed(struct udev_device *dev) +{ + const char *devpath; + const char *action; + + devpath = udev_device_get_devpath(dev); + if (!devpath) + return; + + if (!fnmatch(LCD_ESD_PATH, devpath, 0)) { + action = udev_device_get_action(dev); + if (!strcmp(action, UDEV_CHANGE)) + esd_action(); + } +} + +static const struct uevent_handler lcd_uevent_ops = { + .subsystem = LCD_EVENT_SUBSYSTEM, + .uevent_func = lcd_uevent_changed, + .data = NULL, +}; + static void display_init(void *data) { int ret, i; + unsigned int flags = (WITHOUT_STARTNOTI | FLAG_X_DPMS); int timeout = 0; bool wm_ready; @@ -2244,10 +2737,16 @@ static void display_init(void *data) _W("Failed to load '%s', use default value: %d", DISPLAY_CONF_FILE, ret); + register_kernel_uevent_control(&lcd_uevent_ops); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); register_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); register_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - register_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); + register_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + register_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); + register_notifier(DEVICE_NOTIFIER_LCD_AUTOBRT_SENSING, display_auto_brightness_sensing); + + init_save_userlock(); for (i = INIT_SETTING; i < INIT_END; i++) { switch (i) { @@ -2257,15 +2756,14 @@ static void display_init(void *data) case INIT_INTERFACE: if (display_conf.timeout_enable) get_lcd_timeout_from_settings(); - ret = init_sysfs(); + ret = init_sysfs(flags); break; case INIT_POLL: - _I("Input init."); + _I("input init"); pm_callback = poll_callback; - if (display_conf.input_support) - ret = init_input(); - else - ret = 0; + ret = input_init_handler(); + + pm_lock_detector_init(); break; case INIT_DBUS: _I("Dbus init."); @@ -2286,6 +2784,13 @@ static void display_init(void *data) init_lcd_operation(); check_seed_status(); + /* In smd test, TSP should be turned off if display panel is not existed. */ + if (backlight_ops.get_lcd_power() == -ENOENT) { + _I("Display panel is not existed."); + lcd_direct_control(DPMS_OFF, NORMAL_MODE); + exit_lcd_operation(); + } + /* wm_ready needs to be checked * since display manager can be launched later than deviced. * In the case, display cannot be turned on at the first booting */ @@ -2300,33 +2805,35 @@ static void display_init(void *data) trans_table[S_NORMAL][EVENT_TIMEOUT] = S_NORMAL; } - _I("Start Power managing without noti."); - if (power_ops.get_power_lock_support()) + if (flags & WITHOUT_STARTNOTI) { /* start without noti */ + _I("Start Power managing without noti"); + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); power_ops.power_lock(); + } + pm_cur_state = S_NORMAL; + vconf_set_int(VCONFKEY_PM_STATE, pm_cur_state); + + status = DEVICE_OPS_STATUS_START; + if (display_conf.timeout_enable) { + timeout = states[S_NORMAL].timeout; + /* check minimun lcd on time */ + if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) + timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); + + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, + STAY_CUR_STATE, timeout); + } - pm_cur_state = S_NORMAL; - set_setting_pmstate(pm_cur_state); - - if (display_conf.timeout_enable) { - timeout = states[S_NORMAL].timeout; - /* check minimun lcd on time */ - if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) - timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); - - reset_timeout(timeout); - } - - status = DEVICE_OPS_STATUS_START; - /* - * Lock lcd off until booting is done. - * deviced guarantees all booting script is executing. - * Last script of booting unlocks this suspend blocking state. - */ - if (disp_plgn.pm_lock_internal) { - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); + /* + * Lock lcd off until booting is done. + * deviced guarantees all booting script is executing. + * Last script of booting unlocks this suspend blocking state. + */ + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, + STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); } if (display_conf.input_support) @@ -2350,6 +2857,8 @@ static void display_exit(void *data) if (CHECK_OPS(keyfilter_ops, exit)) keyfilter_ops->exit(); + unregister_kernel_uevent_control(&lcd_uevent_ops); + display_ops_exit(NULL); for (i = i - 1; i >= INIT_SETTING; i--) { @@ -2364,7 +2873,8 @@ static void display_exit(void *data) unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); unregister_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); unregister_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - unregister_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); + unregister_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + unregister_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); exit_input(); break; @@ -2390,6 +2900,7 @@ static int display_start(enum device_flags flags) else /* normal lcd on */ backlight_ops.on(flags); + return 0; } @@ -2411,7 +2922,7 @@ static int display_start(enum device_flags flags) static int display_stop(enum device_flags flags) { /* NORMAL MODE */ - if (flags & NORMAL_MODE) { + if (flags & NORMAL_MODE || flags & FORCE_OFF_MODE) { backlight_ops.off(flags); return 0; } @@ -2435,7 +2946,7 @@ static int display_status(void) static const struct device_ops display_device_ops = { .priority = DEVICE_PRIORITY_HIGH, - .name = "display", + DECLARE_NAME_LEN("display"), .probe = display_probe, .init = display_init, .exit = display_exit, diff --git a/plugins/iot/display/device-interface.c b/plugins/iot/display/device-interface.c index 01b98ac..37a86cb 100644 --- a/plugins/iot/display/device-interface.c +++ b/plugins/iot/display/device-interface.c @@ -29,19 +29,21 @@ #include #include #include -#include +#include #include "ambient-mode.h" #include "core/log.h" #include "core/devices.h" -#include "core/list.h" #include "core/common.h" -#include "display/display-dpms.h" +#include "core/device-notifier.h" #include "util.h" #include "device-interface.h" #include "vconf.h" #include "core.h" #include "device-node.h" +#include "display/display-dpms.h" + +#define SET_SUSPEND_TIME 0.5 #define TOUCH_ON 1 #define TOUCH_OFF 0 @@ -49,7 +51,8 @@ #define LCD_PHASED_MIN_BRIGHTNESS 1 #define LCD_PHASED_MAX_BRIGHTNESS 100 #define LCD_PHASED_CHANGE_STEP 5 -#define LCD_PHASED_DELAY 35000 /* microsecond */ +#define LCD_PHASED_DELAY 10000 /* microsecond */ +#define DUMP_MODE_WAITING_TIME 600000 /* microsecond */ #define POWER_AUTOSLEEP_PATH "/sys/power/autosleep" #define POWER_LOCK_PATH "/sys/power/wake_lock" @@ -57,24 +60,57 @@ #define POWER_WAKEUP_PATH "/sys/power/wakeup_count" #define POWER_STATE_PATH "/sys/power/state" -enum { - POWER_UNLOCK = 0, - POWER_LOCK, -}; +#define DISPLAY_HAL_LIB_PATH "/usr/lib/libdisplay-hal.so" + +#define GESTURE_STR "gesture" +#define POWERKEY_STR "powerkey" +#define EVENT_STR "event" +#define TOUCH_STR "touch" +#define TIMEOUT_STR "timeout" +#define PROXIMITY_STR "proximity" +#define PALM_STR "palm" +#define UNKNOWN_STR "unknown" + +#define FREEZER_VITAL_WAKEUP_CGROUP "/sys/fs/cgroup/freezer/vital_wakeup/freezer.state" struct _backlight_ops backlight_ops; struct _power_ops power_ops; +static int mainlock_status = POWER_UNLOCK; static bool custom_status; static int custom_brightness; static int force_brightness; static int default_brightness; - +static int vital_support = -2; +static int vital_service; +static bool vital_sleep; +static int dpms_running_state = DPMS_SETTING_DONE; static struct display_device *display_dev; +static guint release_timer; -static int bl_onoff(int on) +struct display_device *display_dev_get(void) +{ + return display_dev; +} + +void dpms_set_running_state(int val) +{ + dpms_running_state = val; +} + +static int bl_onoff(int on, enum device_flags flags) { dpms_set_state(on); + +#ifdef ENABLE_PM_LOG + if (on == DPMS_ON) + pm_history_save(PM_LOG_LCD_ON_COMPLETE, pm_cur_state); + else if (on == DPMS_OFF || on == DPMS_FORCE_OFF) + pm_history_save(PM_LOG_LCD_OFF_COMPLETE, pm_cur_state); + else + pm_history_save(PM_LOG_LCD_CONTROL_FAIL, on); +#endif + return 0; } @@ -85,12 +121,6 @@ static int bl_brt(int brightness, int delay) if (delay > 0) usleep(delay); - if (force_brightness > 0) { - _I("brightness=%d force brightness=%d", - brightness, force_brightness); - brightness = force_brightness; - } - /* Update device brightness */ ret = backlight_ops.set_brightness(brightness); @@ -115,39 +145,96 @@ static int system_enable_autosleep(void) return sys_set_str(POWER_AUTOSLEEP_PATH, "mem"); } -static int system_power_lock(void) +static int vital_mode_support(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; - int ret; + if (vital_support < 0) { + FILE *fp; + + fp = fopen(FREEZER_VITAL_WAKEUP_CGROUP, "r"); + if (fp == NULL) { + _E("%s open failed", FREEZER_VITAL_WAKEUP_CGROUP); + /* read max 2 times to check if this file exist */ + vital_support++; + return 0; + } + vital_support = 1; + fclose(fp); + } + return vital_support; +} - _I("system power lock."); - ret = sys_set_str(POWER_LOCK_PATH, "mainlock"); +static int suspend_other_process(int type) +{ + int ret = 0; + char buf[8]; + const char *command[1]; - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } + if (vital_service == type) + return ret; + + if (type == VITAL_WAKEUP && vital_service > VITAL_SLEEP) + return ret; + + vital_service = type; + + if (!vital_mode_support()) + return ret; + if (type == VITAL_SLEEP) { + snprintf(buf, sizeof(buf), "%s", "sleep"); + command[0] = buf; + dbus_handle_method_sync_timeout(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", + command, + SET_SUSPEND_TIME*1000); + vital_sleep = true; + } else if (type == VITAL_WAKEUP) { + snprintf(buf, sizeof(buf), "%s", "wakeup"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + } else if (type == VITAL_EXIT) { + snprintf(buf, sizeof(buf), "%s", "exit"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + vital_sleep = false; + } return ret; } -static int system_power_unlock(void) +static int system_power_lock(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; + _I("system power lock"); + suspend_other_process(VITAL_WAKEUP); + mainlock_status = POWER_LOCK; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } + return sys_set_str(POWER_LOCK_PATH, "mainlock"); +} + +static int system_power_unlock(void) +{ + _I("system power unlock"); + suspend_other_process(VITAL_SLEEP); + mainlock_status = POWER_UNLOCK; - _I("system power unlock."); return sys_set_str(POWER_UNLOCK_PATH, "mainlock"); } +static int system_get_power_lock(void) +{ + return mainlock_status; +} + static int system_get_power_lock_support(void) { static int power_lock_support = -1; @@ -162,7 +249,7 @@ static int system_get_power_lock_support(void) else power_lock_support = true; - _I("system power lock: %s", + _I("System power lock: %s", (power_lock_support ? "support" : "not support")); out: @@ -174,9 +261,6 @@ static int get_lcd_power(void) enum display_state val; int ret; - if (ambient_get_state()) - return DPMS_OFF; - if (!display_dev || !display_dev->get_state) { _E("There is no display device."); return -ENOENT; @@ -186,6 +270,12 @@ static int get_lcd_power(void) if (ret < 0) return ret; + if (val == DISPLAY_ON && ambient_get_state()) + return DPMS_OFF; + + if (dpms_running_state != DPMS_SETTING_DONE) + return dpms_running_state; + switch (val) { case DISPLAY_ON: return DPMS_ON; @@ -202,13 +292,16 @@ static int get_lcd_power(void) bool display_dimstay_check(void) { + if (pm_status_flag & DIM_FLAG) + return true; + if ((pm_status_flag & PWRSV_FLAG) && !(pm_status_flag & BRTCH_FLAG)) return true; return false; } -void change_brightness(int start, int end, int step) +static void change_brightness(int start, int end, int step) { int diff, val; int ret = -1; @@ -226,7 +319,20 @@ void change_brightness(int start, int end, int step) if (prev == end) return; - _D("start=%d end=%d step=%d", start, end, step); + if (pm_status_flag & DIM_MASK) + end = 0; + + _I("start %d end %d step %d", start, end, step); + + if (display_dev && display_dev->set_multi_brightness) { + ret = display_dev->set_multi_brightness(end, step, LCD_PHASED_DELAY); + if (ret < 0) + _E("Failed to set_multi_brightness (%d)", ret); + + backlight_ops.set_brightness(end); + + return; + } diff = end - start; @@ -250,16 +356,15 @@ void change_brightness(int start, int end, int step) static int backlight_on(enum device_flags flags) { int ret = -1; + static int cnt; - _D("LCD on %x", flags); + _I("[DPMS XLIB Backlight] LCD on %x cnt:%d", flags, cnt); - ret = bl_onoff(DPMS_ON); - if (ret < 0) - _E("Failed to turn on backlight."); - - if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(LCD_PHASED_MIN_BRIGHTNESS, - default_brightness, LCD_PHASED_CHANGE_STEP); + cnt++; + ret = bl_onoff(DPMS_ON, flags); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_ON, pm_cur_state); +#endif return ret; } @@ -267,19 +372,30 @@ static int backlight_on(enum device_flags flags) static int backlight_off(enum device_flags flags) { int ret = -1; + static int cnt, ambient_cnt; + + if (flags & AMBIENT_MODE) { + _I("[DPMS XLIB Backlight] LCD suspend %x cnt:%d", flags, ambient_cnt); + ambient_cnt++; + + return 0; + } - _D("LCD off %x", flags); + _I("[DPMS XLIB Backlight] LCD off %x cnt:%d", flags, cnt); + cnt++; if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(default_brightness, + backlight_ops.transit_brt(default_brightness, LCD_PHASED_MIN_BRIGHTNESS, LCD_PHASED_CHANGE_STEP); - if (flags & AMBIENT_MODE) - return 0; + if (flags & FORCE_OFF_MODE) + ret = bl_onoff(DPMS_FORCE_OFF, flags); + else + ret = bl_onoff(DPMS_OFF, flags); - ret = bl_onoff(DPMS_OFF); - if (ret < 0) - _E("Failed to turn off backlight."); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_OFF, pm_cur_state); +#endif return ret; } @@ -287,15 +403,8 @@ static int backlight_off(enum device_flags flags) static int backlight_dim(void) { int ret; - int brightness; - ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_DIM_BRIGHTNESS, &brightness); - if (ret < 0) { - _E("Failed to get vconf value for lcd dim brightness: %d", vconf_get_ext_errno()); - return -EPERM; - } - - ret = bl_brt(brightness, 0); + ret = backlight_ops.set_brightness(PM_DIM_BRIGHTNESS); #ifdef ENABLE_PM_LOG if (!ret) pm_history_save(PM_LOG_LCD_DIM, pm_cur_state); @@ -335,11 +444,11 @@ static int custom_backlight_update(void) custom_brightness > PM_MAX_BRIGHTNESS) return -EINVAL; - if (display_dimstay_check()) { + if (display_dimstay_check()) ret = backlight_dim(); - } else { - _I("Custom brightness(%d) restored.", custom_brightness); - ret = bl_brt(custom_brightness, 0); + else { + _I("custom brightness restored! %d", custom_brightness); + ret = backlight_ops.set_brightness(custom_brightness); } return ret; @@ -358,16 +467,18 @@ static int set_force_brightness(int level) static int backlight_update(void) { int ret = 0; + int brt; if (get_custom_status()) { - _I("Custom brightness mode. brt no updated."); + _I("custom brightness mode! brt no updated"); return 0; } if (display_dimstay_check()) ret = backlight_dim(); - else - ret = bl_brt(default_brightness, 0); - + else { + brt = backlight_ops.get_default_brt(); + ret = backlight_ops.set_brightness(brt); + } return ret; } @@ -377,7 +488,7 @@ static int backlight_standby(int force) if ((get_lcd_power() == DPMS_ON) || force) { _I("LCD standby"); - ret = bl_onoff(DPMS_STANDBY); + ret = bl_onoff(DPMS_STANDBY, 0); } return ret; @@ -393,6 +504,11 @@ static int set_default_brt(int level) return 0; } +static int get_default_brt(void) +{ + return default_brightness; +} + static int check_wakeup_src(void) { /* TODO if nedded. @@ -470,10 +586,22 @@ static int set_brightness(int val) return max; } + if (force_brightness > 0 && val != PM_DIM_BRIGHTNESS) { + _I("brightness(%d), force brightness(%d)", + val, force_brightness); + val = force_brightness; + } + + if (pm_status_flag & DIM_MASK) + val = 0; + /* Maximum Brightness to users is 100. * Thus real brightness need to be calculated */ val = val * max / 100; + _I("set brightness %d (default:%d)", val, default_brightness); + device_notify(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, (void *)&val); + return display_dev->set_brightness(val); } @@ -544,6 +672,84 @@ static int get_brightness_by_light_sensor(float lmax, float lmin, float light, i return 0; } +static int get_image_effect(enum display_image_effect *effect) +{ + int ret; + enum display_image_effect val; + + if (!display_dev || !display_dev->get_image_effect) { + _E("There is no display device."); + return -ENOENT; + } + + ret = display_dev->get_image_effect(&val); + if (ret < 0) { + _E("Failed to get image effect: %d", ret); + return ret; + } + + *effect = val; + + return 0; +} + +static int set_image_effect(enum display_image_effect effect) +{ + int ret; + + if (!display_dev || !display_dev->set_image_effect) { + _E("There is no display device."); + return -ENOENT; + } + + ret = display_dev->set_image_effect(effect); + if (ret < 0) { + _E("Failed to set image effect: %d", ret); + return ret; + } + + return 0; +} + +static int get_panel_mode(enum display_panel_mode *mode) +{ + int ret; + enum display_panel_mode val; + + if (!display_dev || !display_dev->get_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->get_panel_mode(&val); + if (ret < 0) { + _E("failed to get panel mode(%d)", ret); + return ret; + } + + *mode = val; + + return 0; +} + +static int set_panel_mode(enum display_panel_mode mode) +{ + int ret; + + if (!display_dev || !display_dev->set_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->set_panel_mode(mode); + if (ret < 0) { + _E("failed to set panel mode(%d)", ret); + return ret; + } + + return 0; +} + static int get_frame_rate(int *rate) { if (!rate) @@ -595,6 +801,101 @@ static int set_frame_rate(int rate) return display_dev->set_frame_rate(rate); } +/* It was operated only AOD enter & leave */ +static int backlight_transit_state(int state) +{ + int brt, val; + int start, end; + + backlight_ops.get_brightness(&brt); + + if (state == DPMS_OFF) { + start = brt; + end = display_conf.aod_enter_level; + + /* + * The value of backlight_ops.get_brightness is system brightness. + * But when device is LBM, the value is not same with real brightness. + * So it should be read exactly value for transit smooth effect + */ + get_brightness(&val); + + if (val > display_conf.aod_enter_level) + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } else { + /* prevent transit effect when another effect is already executed */ + if (brt != display_conf.aod_enter_level) { + _W("effect is already executed brt(%d) aod_level(%d)", + brt, display_conf.aod_enter_level); + return 0; + } + + start = display_conf.aod_enter_level; + end = default_brightness; + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } + + return 0; +} + +static gboolean blink_cb(gpointer data) +{ + static bool flag; + + set_brightness(flag ? PM_MAX_BRIGHTNESS : PM_MIN_BRIGHTNESS); + + flag = !flag; + + return G_SOURCE_CONTINUE; +} + +static void blink(int timeout) +{ + static guint timer; + + if (timer) { + g_source_remove(timer); + timer = 0; + } + + if (timeout < 0) { + _E("timeout value is invalid %d", timeout); + return; + } + + if (timeout == 0) { + backlight_update(); + return; + } + + timer = g_timeout_add(timeout, blink_cb, NULL); +} + +static gboolean release_blink_cb(gpointer data) +{ + blink(0); + + release_timer = 0; + return G_SOURCE_REMOVE; +} + +static void release_blink(void) +{ + if (release_timer) { + g_source_remove(release_timer); + release_timer = 0; + } + + release_timer = g_timeout_add(DUMP_MODE_WAITING_TIME, release_blink_cb, NULL); +} + +static void restore_brightness_func(void) +{ + backlight_ops.set_brightness = set_brightness; + backlight_ops.get_brightness = get_brightness; + backlight_ops.transit_brt = change_brightness; +} + static void _init_ops(void) { backlight_ops.off = backlight_off; @@ -603,6 +904,7 @@ static void _init_ops(void) backlight_ops.update = backlight_update; backlight_ops.standby = backlight_standby; backlight_ops.set_default_brt = set_default_brt; + backlight_ops.get_default_brt = get_default_brt; backlight_ops.get_lcd_power = get_lcd_power; backlight_ops.set_custom_status = set_custom_status; backlight_ops.get_custom_status = get_custom_status; @@ -611,14 +913,24 @@ static void _init_ops(void) backlight_ops.set_force_brightness = set_force_brightness; backlight_ops.set_brightness = set_brightness; backlight_ops.get_brightness = get_brightness; + backlight_ops.restore_brightness_func = restore_brightness_func; backlight_ops.get_brightness_by_light_sensor = get_brightness_by_light_sensor; + backlight_ops.get_image_effect = get_image_effect; + backlight_ops.set_image_effect = set_image_effect; + backlight_ops.get_panel_mode = get_panel_mode; + backlight_ops.set_panel_mode = set_panel_mode; backlight_ops.get_frame_rate = get_frame_rate; backlight_ops.set_frame_rate = set_frame_rate; + backlight_ops.transit_state = backlight_transit_state; + backlight_ops.transit_brt = change_brightness; + backlight_ops.blink = blink; + backlight_ops.release_blink = release_blink; power_ops.suspend = system_suspend; power_ops.enable_autosleep = system_enable_autosleep; power_ops.power_lock = system_power_lock; power_ops.power_unlock = system_power_unlock; + power_ops.get_power_lock = system_get_power_lock; power_ops.get_power_lock_support = system_get_power_lock_support; power_ops.check_wakeup_src = check_wakeup_src; power_ops.get_wakeup_count = get_wakeup_count; @@ -636,12 +948,12 @@ int display_service_load(void) r = hw_get_info(DISPLAY_HARDWARE_DEVICE_ID, (const struct hw_info **)&info); if (r < 0) { - _I("Display shared library is not supported: %d", r); - return -ENODEV; + _I("display shared library is not supported: %d", r); + return 0; } if (!info->open) { - _E("Failed to open display device: open(NULL)"); + _E("Failed to open display device: open(NULL)."); return -EPERM; } @@ -672,17 +984,44 @@ int display_service_free(void) return 0; } -int init_sysfs() +bool vital_mode(void) +{ + return vital_sleep; +} + +static int vital_state_changed(void *data) +{ + int type; + + assert(data); + + type = *(int *)data; + if (type == VITAL_EXIT) + suspend_other_process(VITAL_EXIT); + + return 0; +} + +int init_sysfs(unsigned int flags) { _init_ops(); + register_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } int exit_sysfs(void) { + int fd; const struct device_ops *ops = NULL; + fd = open("/tmp/sem.pixmap_1", O_RDONLY); + if (fd == -1) { + _E("X server disable"); + backlight_on(NORMAL_MODE); + } + backlight_update(); disconnect_interface_with_dpms(); @@ -694,5 +1033,10 @@ int exit_sysfs(void) if (!check_default(ops)) ops->start(NORMAL_MODE); + if (fd != -1) + close(fd); + + unregister_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } diff --git a/plugins/iot/display/key-filter.c b/plugins/iot/display/key-filter.c index 8b35f7c..5d16df7 100644 --- a/plugins/iot/display/key-filter.c +++ b/plugins/iot/display/key-filter.c @@ -25,6 +25,7 @@ #include #include #include +#include #include "ambient-mode.h" #include "util.h" @@ -36,11 +37,11 @@ #include "core/common.h" #include "core/devices.h" #include "core/device-notifier.h" +#include "shared/common.h" #include "power/power-handler.h" #include "led/touch-key.h" #include "apps/apps.h" -#include #ifndef KEY_SCREENLOCK #define KEY_SCREENLOCK 0x98 #endif @@ -50,21 +51,24 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" +#define PWROFF_POPUP_ACT "pwroff_popup" #define USEC_PER_SEC 1000000 +#define CSC_CONFIG_MODE_RUNNING 1 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ +#define TORCH_COMBINATION_INTERVAL 0.1 /* 0.1 second */ +#define DEFAULT_COMBINATION_INTERVAL 0.1 /* 0.1 second */ -#define KEY_MAX_DELAY_TIME 700 /* ms */ +#define LONGKEY_PRESSED_TIME 4 /* 4 second */ -#define KEY_RELEASED 0 -#define KEY_PRESSED 1 -#define KEY_BEING_PRESSED 2 +#define KEY_MAX_DELAY_TIME 700 /* ms */ #define SIGNAL_CHANGE_HARDKEY "ChangeHardkey" #define SIGNAL_LCDON_BY_POWERKEY "LCDOnByPowerkey" #define SIGNAL_LCDOFF_BY_POWERKEY "LCDOffByPowerkey" -#define TOUCH_RELEASE (-1) +#define NORMAL_POWER 0 +#define KEY_TEST_MODE_POWER 2 #define GLOVE_MODE 1 @@ -72,39 +76,30 @@ enum key_combination_flags { KEY_COMBINATION_STOP = 0, KEY_COMBINATION_POWERKEY = BIT(0), KEY_COMBINATION_MENUKEY = BIT(1), + KEY_COMBINATION_VOLUMEUP = BIT(2), + KEY_COMBINATION_VOLUMEDOWN = BIT(3), }; enum combination_process { COMBINATION_STOP = KEY_COMBINATION_STOP, COMBINATION_SCREENCAPTURE = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_MENUKEY, + COMBINATION_TORCH = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEUP, + COMBINATION_QUICKTALK = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEDOWN, }; -int __WEAK__ get_glove_state(void); -void __WEAK__ switch_glove_key(int val); - static struct timeval pressed_time; static guint longkey_timeout_id = 0; +static guint longkey_restore_id = 0; +static guint displayon_by_powerkey_timeout_id = 0; static int cancel_lcdoff; static int key_combination = KEY_COMBINATION_STOP; static double combination_pressed_time; static bool touch_pressed = false; static int skip_lcd_off = false; static int skip_combination = false; +static int bezel_wakeup = true; static const struct device_ops *touchled; - -static int booting_done(void *data) -{ - static int done = 0; - - if (!data) - return done; - - done = *(int *)data; - - _I("Booting done(%d)", done); - - return done; -} +static int booting_check = true; static inline int current_state_in_on(void) { @@ -128,7 +123,7 @@ static void pwroff_popup(void) _E("Failed to launch power off popup."); } -static void longkey_pressed() +static void longkey_pressed(void) { unsigned int caps; @@ -152,6 +147,14 @@ static void longkey_pressed() pwroff_popup(); } +static gboolean longkey_restore_cb(void *data) +{ + device_notify(DEVICE_NOTIFIER_LONGKEY_RESTORE, (void *)NULL); + longkey_restore_id = 0; + + return G_SOURCE_REMOVE; +} + static gboolean longkey_pressed_cb(void *data) { longkey_pressed(); @@ -196,7 +199,7 @@ static inline void broadcast_lcdoff_by_powerkey(void) NULL); } -static inline bool switch_on_lcd(void) +static inline bool switch_on_lcd(enum device_flags flags) { if (current_state_in_on()) return false; @@ -206,9 +209,12 @@ static inline bool switch_on_lcd(void) return false; } - broadcast_lcdon_by_powerkey(); + if (flags & LCD_ON_BY_POWER_KEY) + broadcast_lcdon_by_powerkey(); + else if (flags & LCD_ON_BY_TOUCH) + _I("Display on by Touch_wakeup event"); - lcd_on_direct(LCD_ON_BY_POWER_KEY); + lcd_on_direct(flags); return true; } @@ -230,15 +236,37 @@ static void check_key_combination(struct input_event *pinput) { double press_time, diff_time; press_time = (pinput->time).tv_sec + USEC_TO_SEC((pinput->time).tv_usec); + diff_time = press_time - combination_pressed_time; switch (key_combination) { case COMBINATION_SCREENCAPTURE: - diff_time = press_time - combination_pressed_time; if (diff_time <= CAPTURE_COMBINATION_INTERVAL) { _I("Combination key : SCREENCAPTURE mode"); skip_combination = true; } break; + case COMBINATION_TORCH: + if (diff_time <= TORCH_COMBINATION_INTERVAL) { + /* When torch combination, display control should be not change. */ + if (displayon_by_powerkey_timeout_id) { + g_source_remove(displayon_by_powerkey_timeout_id); + displayon_by_powerkey_timeout_id = 0; + } + _I("Combination key : TORCH mode"); + skip_combination = true; + } else + key_combination = COMBINATION_STOP; + break; + case COMBINATION_QUICKTALK: + if (diff_time <= DEFAULT_COMBINATION_INTERVAL) { + _I("Combination key : QUICK-TALK mode"); + skip_combination = true; + if (longkey_timeout_id) { + g_source_remove(longkey_timeout_id); + longkey_timeout_id = 0; + } + } + break; default: combination_pressed_time = press_time; return; @@ -255,6 +283,12 @@ static void start_key_combination(struct input_event *pinput) case KEY_MENU: key_combination |= KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination |= KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination |= KEY_COMBINATION_VOLUMEDOWN; + break; default: return; } @@ -276,8 +310,14 @@ static void stop_key_combination(struct input_event *pinput) case KEY_MENU: key_combination &= ~KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination &= ~KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination &= ~KEY_COMBINATION_VOLUMEDOWN; + break; default: - _E("Thid code(%d) is not combination type", pinput->code); + _E("This code(%d) is not combination type.", pinput->code); break; } } @@ -301,24 +341,118 @@ static int process_menu_key(struct input_event *pinput) return false; _D("No lcd-on capability!"); return true; - } else if (pinput->value == KEY_PRESSED) { - switch_on_lcd(); - } + } else if (pinput->value == KEY_PRESSED) + switch_on_lcd(LCD_ON_BY_POWER_KEY); return false; } -static bool release_short_powerkey(void) +static int decide_lcdoff(void) { -// tv d - no, a - yes - if (!display_conf.powerkey_doublepress && display_conf.lcd_always_on) { - longkey_pressed(); + /* It's not needed if it's already LCD off state */ + if (!current_state_in_on() && + backlight_ops.get_lcd_power() != DPMS_ON) + return false; + + /* + * This flag is set at the moment + * that LCD is turned on by power key + * LCD has not to turned off in the situation. + */ + if (skip_lcd_off) + return false; + + /* LCD is not turned off when powerkey is pressed,not released */ + if (key_combination == KEY_COMBINATION_POWERKEY) + return false; + + /* LCD-off is blocked at the moment poweroff popup shows */ + if (cancel_lcdoff) + return false; + + /* LCD-off is blocked when powerkey and volmedown key are pressed */ + if (skip_combination) + return false; + + /* At booting time, display must do not turn off */ + if (booting_check) + return false; + + return true; +} + +static int lcdoff_powerkey(void) +{ + int ignore = true; + + if (decide_lcdoff() == true) { + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + if (!check_holdkey_block(S_NORMAL) && + !check_holdkey_block(S_LCDDIM)) { + if (display_info.update_auto_brightness) + display_info.update_auto_brightness(false); + switch_off_lcd(); + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); + update_lcdoff_source(VCONFKEY_PM_LCDOFF_BY_POWERKEY); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_POWERKEY, LCD_OFF); + } + } else { + ignore = false; + skip_combination = false; + } + cancel_lcdoff = 0; + + return ignore; +} + +static bool key_check_display_on(void) +{ + if (current_state_in_on()) + return false; + + if (backlight_ops.get_lcd_power() == DPMS_ON) { + _W("display power was on"); return false; } return true; } +static gboolean display_on_cb(void *data) +{ + if (displayon_by_powerkey_timeout_id == 0) + return G_SOURCE_REMOVE; + + displayon_by_powerkey_timeout_id = 0; + if (backlight_ops.get_lcd_power() != DPMS_ON || + current_state_in_on() == false) { + broadcast_lcdon_by_powerkey(); + lcd_on_direct(LCD_ON_BY_POWER_KEY); + + if (pm_callback) + (*pm_callback) (INPUT_POLL_EVENT, NULL); + } + + return G_SOURCE_REMOVE; +} + +static int process_back_key(struct input_event *pinput) +{ + int ignore = true; + + if (pinput->value == KEY_PRESSED) { + switch_on_lcd(LCD_ON_BY_POWER_KEY); + _I("back key pressed"); + ignore = false; + } + + return ignore; +} + static int process_power_key(struct input_event *pinput) { int ignore = true; @@ -331,7 +465,13 @@ static int process_power_key(struct input_event *pinput) case KEY_RELEASED: check_key_pair(pinput->code, pinput->value, &value); - ignore = release_short_powerkey(); + if (!display_conf.powerkey_doublepress) { + if (display_has_caps(caps, DISPLAY_CAPA_LCDOFF)) + lcdoff_powerkey(); + else + _D("No lcdoff capability!"); + } else if (skip_lcd_off) + ignore = false; if (!display_has_caps(caps, DISPLAY_CAPA_LCDON)) ignore = true; @@ -341,10 +481,32 @@ static int process_power_key(struct input_event *pinput) longkey_timeout_id = 0; } + if (longkey_restore_id > 0) { + g_source_remove(longkey_restore_id); + longkey_restore_id = 0; + } + break; case KEY_PRESSED: if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) { - skip_lcd_off = switch_on_lcd(); + if (wearable_mode()) + skip_lcd_off = switch_on_lcd(LCD_ON_BY_POWER_KEY); + else { + /* + * LCD does not turn on immediately at mobile. + * It will be turned on after 0.1 second because of torch concept. + */ + skip_lcd_off = key_check_display_on(); + ignore = true; + + if (!displayon_by_powerkey_timeout_id && + backlight_ops.get_lcd_power() != DPMS_ON && + key_combination != COMBINATION_TORCH) { + displayon_by_powerkey_timeout_id = g_timeout_add( + 100, + display_on_cb, NULL); + } + } } else { _D("No lcdon capability!"); skip_lcd_off = false; @@ -358,9 +520,11 @@ static int process_power_key(struct input_event *pinput) longkey_timeout_id = g_timeout_add_seconds( display_conf.longpress_interval, longkey_pressed_cb, NULL); + /* add long key restore timer */ + longkey_restore_id = g_timeout_add_seconds( + LONGKEY_PRESSED_TIME, + longkey_restore_cb, NULL); } - if (skip_lcd_off) - ignore = false; cancel_lcdoff = 0; break; @@ -421,10 +585,12 @@ static void process_hardkey_backlight(struct input_event *pinput) _I("Touch is pressed, then hard key is not working!"); return; } + if (!wearable_mode()) { /* Sound & Vibrate only in unlock state */ if (__get_lock_screen_state() == VCONFKEY_IDLE_UNLOCK || get_lock_screen_bg_state()) sound_vibrate_hardkey(); + } if (touchled && touchled->execute) { opt = TOUCHLED_PRESS; @@ -444,6 +610,23 @@ static void process_hardkey_backlight(struct input_event *pinput) } } +static void update_vital_state(struct input_event *pinput) +{ + int type; + + /* Change vital state to VITAL_EXIT only if vital mode is active */ + if (!vital_mode()) + return; + + /* Touch or Menu Key Release Event */ + if (pinput->type == EV_ABS || (pinput->type == EV_KEY && + pinput->value == KEY_RELEASED && pinput->code == KEY_MENU)) { + /* Enable all services upon receiving user input, else maintain same state */ + type = VITAL_EXIT; + device_notify(DEVICE_NOTIFIER_VITAL_STATE, &type); + } +} + static int check_key(struct input_event *pinput, int fd) { int ignore = true; @@ -462,6 +645,13 @@ static int check_key(struct input_event *pinput, int fd) ignore = process_screenlock_key(pinput); break; case KEY_BACK: + ignore = process_back_key(pinput); + stop_key_combination(NULL); + if (current_state_in_on()) { + process_hardkey_backlight(pinput); + ignore = false; + } + break; case KEY_PHONE: stop_key_combination(NULL); if (current_state_in_on()) { @@ -471,6 +661,9 @@ static int check_key(struct input_event *pinput, int fd) break; case KEY_VOLUMEUP: case KEY_VOLUMEDOWN: + if (current_state_in_on()) + ignore = false; + break; case KEY_CAMERA: case KEY_EXIT: case KEY_CONFIG: @@ -536,34 +729,36 @@ static int check_key_filter(void *data, int fd) code = pinput->code; value = pinput->value; + update_vital_state(pinput); ignore = check_key(pinput, fd); restore_custom_brightness(); break; case EV_REL: + if (pm_cur_state == S_LCDOFF && bezel_wakeup) { + switch_on_lcd(LCD_ON_BY_BEZEL); ignore = false; + } else if (pm_cur_state != S_LCDOFF) + ignore = false; break; case EV_ABS: - if (current_state_in_on()) + update_vital_state(pinput); + if (pinput->value == KEY_PRESSED) { + switch_on_lcd(LCD_ON_BY_TOUCH); ignore = false; + } - if (ambient_get_condition() == true) { - switch_on_lcd(); + if (current_state_in_on()) ignore = false; - } restore_custom_brightness(); - touch_pressed = - (pinput->value == TOUCH_RELEASE ? false : true); + if (pinput->value == KEY_PRESSED) + touch_pressed = true; + else if (pinput->value == KEY_RELEASED) + touch_pressed = false; break; case EV_SW: - if (!get_glove_state || !switch_glove_key) - break; - if (pinput->code == SW_GLOVE && - get_glove_state() == GLOVE_MODE) { - switch_glove_key(pinput->value); - } break; } @@ -573,6 +768,20 @@ static int check_key_filter(void *data, int fd) return 0; } +static int booting_done_cb(void *data) +{ + booting_check = 0; + + return 0; +} + +static int bezel_wakeup_cb(void *data) +{ + bezel_wakeup = (int)data; + + return 0; +} + /* * Default capability * powerkey := LCDON | LCDOFF | POWEROFF @@ -597,12 +806,8 @@ static void keyfilter_init(void) touchled = find_device(TOUCHLED_NAME); - register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); -} - -static void keyfilter_exit(void) -{ - unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb); + register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb); } static void key_backlight_enable(bool enable) @@ -622,7 +827,6 @@ static void key_backlight_enable(bool enable) static const struct display_keyfilter_ops normal_keyfilter_ops = { .init = keyfilter_init, - .exit = keyfilter_exit, .check = check_key_filter, .set_powerkey_ignore = NULL, .powerkey_lcdoff = NULL, diff --git a/plugins/mobile/display/core.c b/plugins/mobile/display/core.c index 9d3f642..30ca2bd 100644 --- a/plugins/mobile/display/core.c +++ b/plugins/mobile/display/core.c @@ -35,10 +35,9 @@ #include #include #include +#include #include #include -#include -#include #include "ambient-mode.h" #include "util.h" @@ -53,14 +52,15 @@ #include "core/common.h" #include "core/config-parser.h" #include "core/launch.h" +#include "apps/apps.h" #include "extcon/extcon.h" +#include "battery/power-supply.h" #include "power/power-handler.h" #include "dd-display.h" #include "display/display-dpms.h" -#include "battery/battery.h" -#include "battery/power-supply.h" +#include "proximity.h" +#include "display-info.h" -#define PM_STATE_LOG_FILE tzplatform_mkpath(TZ_SYS_ALLLOGS, "pm_state.log") #define DISPLAY_CONF_FILE "/etc/deviced/display.conf" /** @@ -71,18 +71,28 @@ #define SET_BRIGHTNESS_IN_BOOTLOADER "/usr/bin/save_blenv SLP_LCD_BRIGHT" #define LOCK_SCREEN_INPUT_TIMEOUT 10000 #define LOCK_SCREEN_CONTROL_TIMEOUT 5000 -#define DD_LCDOFF_INPUT_TIMEOUT 3000 -#define ALWAYS_ON_TIMEOUT 3600000 //3600000 = 1 hour +#define ALWAYS_ON_TIMEOUT 3600000 +#define LATE_LCD_TRANSIT 1 + +#define PID_MAX 6 #define GESTURE_STR "gesture" #define POWER_KEY_STR "powerkey" #define TOUCH_STR "touch" #define EVENT_STR "event" #define TIMEOUT_STR "timeout" +#define PROXI_STR "proximity" +#define PALM_STR "palm" #define UNKNOWN_STR "unknown" +#define METHOD_APP_STATUS "CheckAppStatus" + +#define PM_WAKEUP 0 +#define PM_SUSPEND 1 + extern void init_pm_internal(); extern int get_charging_status(int *val); +extern void init_save_userlock(void); unsigned int pm_status_flag; static int trans_condition; @@ -93,6 +103,7 @@ static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT; int pm_cur_state; int pm_old_state; guint timeout_src_id; +int system_wakeup_flag = false; static unsigned int custom_normal_timeout = 0; static unsigned int custom_dim_timeout = 0; static int custom_holdkey_block = false; @@ -100,13 +111,21 @@ static int custom_change_pid = -1; static char *custom_change_name; static bool hallic_open = true; static guint lock_timeout_id; +static guint transit_timer; static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT; +static long displayoff_time; static struct timeval lcdon_tv; static int lcd_paneloff_mode = false; static int stay_touchscreen_off = false; +dd_list *lcdon_ops; +/* + * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial + * state because it should be sent from previous state at booting time. + */ static bool lcdon_broadcast = true; +static int pmstate_suspend = PM_SUSPEND; + static bool touch_blocked = false; -dd_list *lcdon_ops; /* default transition, action fuctions */ static int default_trans(int evt); @@ -117,6 +136,10 @@ static gboolean del_normal_cond(void *data); static gboolean del_dim_cond(void *data); static gboolean del_off_cond(void *data); +static gboolean pmlock_normal_check(void *data); +static gboolean pmlock_dim_check(void *data); +static gboolean pmlock_off_check(void *data); + static int default_proc_change_state(unsigned int cond, pid_t pid); static int (*proc_change_state)(unsigned int cond, pid_t pid) = default_proc_change_state; @@ -141,6 +164,10 @@ static int trans_table[S_END][EVENT_END] = { { S_POWEROFF, S_POWEROFF }, /* S_POWEROFF */ }; +static GSourceFunc warning_cb[S_END] = { + NULL, pmlock_normal_check, pmlock_dim_check, pmlock_off_check, +}; + enum signal_type { SIGNAL_INVALID = 0, SIGNAL_PRE, @@ -148,6 +175,11 @@ enum signal_type { SIGNAL_MAX, }; +enum platform_control { + PLATFORM_DISPLAY_OFF, + PLATFORM_DISPLAY_ON, +}; + static const char *lcdon_sig_lookup[SIGNAL_MAX] = { [SIGNAL_PRE] = "LCDOn", [SIGNAL_POST] = "LCDOnCompleted", @@ -179,7 +211,7 @@ static const char *lcdoff_sig_lookup[SIGNAL_MAX] = { #define LONG_PRESS_INTERVAL 2 /* 2 seconds */ #define SAMPLING_INTERVAL 1 /* 1 sec */ #define BRIGHTNESS_CHANGE_STEP 10 -#define LCD_ALWAYS_ON 1 +#define LCD_ALWAYS_ON 0 #define ACCEL_SENSOR_ON 1 #define CONTINUOUS_SAMPLING 1 #define LCDOFF_TIMEOUT 500 /* milli second */ @@ -196,13 +228,18 @@ struct display_config display_conf = { .lcdoff_timeout = LCDOFF_TIMEOUT, .brightness_change_step = BRIGHTNESS_CHANGE_STEP, .lcd_always_on = LCD_ALWAYS_ON, - .framerate_app = {1, 0, 0, 0}, - .control_display = 1, + .dimming = 1, + .framerate_app = {0, 0, 0, 0}, + .control_display = 0, .powerkey_doublepress = 0, .accel_sensor_on = ACCEL_SENSOR_ON, .continuous_sampling = CONTINUOUS_SAMPLING, - .timeout_enable = false, + .timeout_enable = true, .input_support = true, + .lockcheck_timeout = 600, + .aod_enter_level = 40, + .aod_tsp = true, + .touch_wakeup = false, }; struct display_function_info display_info = { @@ -215,9 +252,11 @@ struct display_function_info display_info = { typedef struct _pm_lock_node { pid_t pid; guint timeout_id; + guint warning_id; time_t time; bool holdkey_block; bool background; + bool broadcast_warning; } PmLockNode; static dd_list *cond_head[S_END]; @@ -232,9 +271,9 @@ static void set_process_active(bool flag, pid_t pid) /* Send dbug to resourced */ ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -288,17 +327,64 @@ void change_proc_change_state(int (*func)(unsigned int cond, pid_t pid)) proc_change_state = func; } +static inline long clock_gettime_to_long(void) +{ + struct timespec now; + int ret; + + ret = clock_gettime(CLOCK_REALTIME, &now); + + if (ret < 0) { + _E("Failed to clock gettime!"); + return 0; + } + + return SEC_TO_MSEC(now.tv_sec) + NSEC_TO_MSEC(now.tv_nsec); +} + +static int display_brightness_changed(void *data) +{ + int brt, ret; + + brt = DATA_VALUE_INT(data); + + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "Brightness", + g_variant_new("(i)", brt)); + if (ret < 0) + _E("Failed to send dbus signal Brightness."); + + return 0; +} + +static int display_auto_brightness_sensing(void *data) +{ + if (!transit_timer) + return 0; + + g_source_remove(transit_timer); + transit_timer = 0; + + return 0; +} + static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) { const char *str; const char *signal; int ret; + long diff = 0; if (type <= SIGNAL_INVALID || type >= SIGNAL_MAX) { _E("Invalid signal type(%d).", type); return; } + if (type == SIGNAL_PRE && displayoff_time != 0) + diff = clock_gettime_to_long() - displayoff_time; + if (flags & LCD_ON_BY_GESTURE) str = GESTURE_STR; else if (flags & LCD_ON_BY_POWER_KEY) @@ -316,7 +402,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, - g_variant_new("(s)", str)); + g_variant_new("(si)", str, diff)); if (ret < 0) _E("Failed to send dbus signal(%s)", signal); } @@ -332,6 +418,9 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) return; } + if (type == SIGNAL_PRE) + displayoff_time = clock_gettime_to_long(); + signal = lcdoff_sig_lookup[type]; if (flags & LCD_OFF_BY_POWER_KEY) @@ -340,6 +429,12 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = TIMEOUT_STR; else if (flags & LCD_OFF_BY_EVENT) str = EVENT_STR; + else if (flags & LCD_OFF_BY_PROXIMITY) + str = PROXI_STR; + else if (flags & LCD_OFF_BY_PALM) + str = PALM_STR; + else if (flags & LCD_OFF_BY_GESTURE) + str = GESTURE_STR; else str = UNKNOWN_STR; @@ -370,9 +465,6 @@ static unsigned long get_lcd_on_flags(void) if (lcd_paneloff_mode) flags |= LCD_PANEL_OFF_MODE; - if (stay_touchscreen_off) - flags |= TOUCH_SCREEN_OFF_MODE; - if (ambient_get_condition() == true) { flags |= AMBIENT_MODE; flags |= LCD_PHASED_TRANSIT_MODE; @@ -386,6 +478,18 @@ bool touch_event_blocked(void) return touch_blocked; } +static gboolean late_transit_on(void *data) +{ + if (!transit_timer) + return G_SOURCE_REMOVE; + + g_source_remove(transit_timer); + transit_timer = 0; + + backlight_ops.transit_state(DPMS_ON); + return G_SOURCE_REMOVE; +} + void lcd_on_procedure(int state, enum device_flags flag) { dd_list *l = NULL; @@ -393,19 +497,29 @@ void lcd_on_procedure(int state, enum device_flags flag) unsigned long flags = get_lcd_on_flags(); flags |= flag; - /* send LCDOn dbus signal */ - if (!lcdon_broadcast) { - broadcast_lcd_on(SIGNAL_PRE, flags); - lcdon_broadcast = true; - } + /* + * Display on procedure + * step 1. broadcast lcd on signal with cause + * step 2. set brightness + * step 3. set pmstate of vconf + * step 4. display on operate + * - a. display on + * - b. TSP(touch screen) and touchkey enable + * step 5. broadcast lcd on complete siganl + * step 6. key backlight enable + */ + _I("[lcdstep] %lu", flags); if (flags & AMBIENT_MODE) { - if (ambient_get_state() == false && - backlight_ops.get_lcd_power() == DPMS_ON) + if (ambient_get_state() == false && backlight_ops.get_lcd_power() == DPMS_ON) return; ambient_set_state(false); } + /* send LCDOn dbus signal */ + if (!lcdon_broadcast) + broadcast_lcd_on(SIGNAL_PRE, flags); + if (!(flags & LCD_PHASED_TRANSIT_MODE)) { /* Update brightness level */ if (state == LCD_DIM) @@ -422,7 +536,13 @@ void lcd_on_procedure(int state, enum device_flags flag) DD_LIST_FOREACH(lcdon_ops, l, ops) ops->start(flags); + if (!lcdon_broadcast) { broadcast_lcd_on(SIGNAL_POST, flags); + if (flags & LCD_PHASED_TRANSIT_MODE) + transit_timer = g_timeout_add_seconds(LATE_LCD_TRANSIT, + late_transit_on, NULL); + lcdon_broadcast = true; + } if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(true); @@ -430,7 +550,7 @@ void lcd_on_procedure(int state, enum device_flags flag) touch_blocked = false; } -static inline unsigned long get_lcd_off_flags(void) +static unsigned long get_lcd_off_flags(void) { unsigned long flags = NORMAL_MODE; @@ -439,10 +559,12 @@ static inline unsigned long get_lcd_off_flags(void) flags |= LCD_PHASED_TRANSIT_MODE; } + if (stay_touchscreen_off) + flags |= TOUCH_SCREEN_OFF_MODE; + return flags; } - inline void lcd_off_procedure(enum device_flags flag) { dd_list *l = NULL; @@ -450,6 +572,20 @@ inline void lcd_off_procedure(enum device_flags flag) unsigned long flags = get_lcd_off_flags(); flags |= flag; + /* + * Display off procedure + * step 0. enhance mode off using nofity (e.g mdnie, HBM, LBM) + * step 1. broadcast lcd off signal with cause + * step 2. set pmstate of vconf + * step 3. display off operate + * - a. display off + * - b. TSP(touch screen) and touchkey disable + * step 4. broadcast lcd off complete siganl + */ + _I("[lcdstep] %lu", flags); + + device_notify(DEVICE_NOTIFIER_LCD_OFF, NULL); + touch_blocked = true; if (flags & AMBIENT_MODE) { @@ -462,18 +598,23 @@ inline void lcd_off_procedure(enum device_flags flag) broadcast_lcd_off(SIGNAL_PRE, flags); lcdon_broadcast = false; } + set_setting_pmstate(S_LCDOFF); + if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(false); - set_setting_pmstate(S_LCDOFF); + if (transit_timer) { + g_source_remove(transit_timer); + transit_timer = 0; + } + + if (flags & LCD_PHASED_TRANSIT_MODE) + backlight_ops.transit_state(DPMS_OFF); DD_LIST_FOREACH(lcdon_ops, l, ops) ops->stop(flags); if (flags & AMBIENT_MODE) - /* Do not broadcast the post signal here. - * The signal will be broadcasted - * after showing Ambient clock */ broadcast_lcd_off_late(flags); else broadcast_lcd_off(SIGNAL_POST, flags); @@ -481,20 +622,20 @@ inline void lcd_off_procedure(enum device_flags flag) void set_stay_touchscreen_off(int val) { - _D("stay touch screen off: %d", val); + _I("Stay touch screen off: %d", val); stay_touchscreen_off = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } void set_lcd_paneloff_mode(int val) { - _D("lcd paneloff mode: %d", val); + _I("Lcd paneloff mode: %d", val); lcd_paneloff_mode = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } int low_battery_state(int val) @@ -538,7 +679,7 @@ static void makeup_trans_condition(void) static PmLockNode *find_node(enum state_t s_index, pid_t pid) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; DD_LIST_FOREACH(cond_head[s_index], elem, t) { if (t->pid == pid) @@ -551,21 +692,28 @@ static PmLockNode *find_node(enum state_t s_index, pid_t pid) static PmLockNode *add_node(enum state_t s_index, pid_t pid, guint timeout_id, bool holdkey_block) { + guint warning_id = 0; PmLockNode *n; time_t now; n = (PmLockNode *) malloc(sizeof(PmLockNode)); if (n == NULL) { - _E("Failed to add cond. Not enough memory."); + _E("Not enough memory, add cond. fail"); return NULL; } + if (pid < INTERNAL_LOCK_BASE) + warning_id = g_timeout_add_seconds(display_conf.lightsensor_interval, + warning_cb[s_index], (void *)((intptr_t)pid)); + time(&now); n->pid = pid; n->timeout_id = timeout_id; + n->warning_id = warning_id; n->time = now; n->holdkey_block = holdkey_block; n->background = false; + n->broadcast_warning = true; DD_LIST_APPEND(cond_head[s_index], n); refresh_app_cond(); @@ -584,6 +732,11 @@ static int del_node(enum state_t s_index, PmLockNode *n) g_source_remove(n->timeout_id); n->timeout_id = 0; } + if (n->warning_id) { + g_source_remove(n->warning_id); + n->warning_id = 0; + } + free(n); refresh_app_cond(); return 0; @@ -591,6 +744,7 @@ static int del_node(enum state_t s_index, PmLockNode *n) static void print_node(int next) { + int ret; dd_list *elem; PmLockNode *n; char buf[30]; @@ -605,10 +759,20 @@ static void print_node(int next) diff = difftime(now, n->time); ctime_r(&n->time, buf); - if (diff > LOCK_TIME_WARNING) - _W("over=%.0f s pid=%5d locktime=%s", diff, n->pid, buf); - else - _I("pid=%5d locktime=%s", n->pid, buf); + if (diff > LOCK_TIME_WARNING) { + if (diff > LOCK_TIME_WARNING * 60 && n->pid < INTERNAL_LOCK_BASE && n->broadcast_warning) { + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_over", + g_variant_new("(i)", n->pid)); + if (ret < 0) + _E("Failed to send dbus signal pmlock_over."); + n->broadcast_warning = false; + } + _W("Over(%.0f s) pid( %5d) lock time(%s)", diff, n->pid, buf); + } else + _I("Pid(%5d) lock time(%s)", n->pid, buf); } } @@ -641,7 +805,6 @@ void get_pname(pid_t pid, char *pname) static void del_state_cond(void *data, enum state_t state) { PmLockNode *tmp = NULL; - char pname[PATH_MAX]; pid_t pid; if (!data) @@ -649,18 +812,20 @@ static void del_state_cond(void *data, enum state_t state) /* A passed data is a pid_t type data, not a 64bit data. */ pid = (pid_t)((intptr_t)data); - _I("Delete process(%d)'s prohibit dim condition by timeout.", pid); + _I("delete prohibit dim condition by timeout (%d)", pid); + + if (pid == INTERNAL_LOCK_AMBIENT) + ambient_check_invalid_state(pid); tmp = find_node(state, pid); del_node(state, tmp); - get_pname(pid, pname); - set_unlock_time(pname, state); + set_unlock_time(pid, state); if (!timeout_src_id) states[pm_cur_state].trans(EVENT_TIMEOUT); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); } static gboolean del_normal_cond(void *data) @@ -681,23 +846,91 @@ static gboolean del_off_cond(void *data) return G_SOURCE_REMOVE; } -/* timeout handler */ -gboolean timeout_handler(void *data) +static void pmlock_check_cb(GVariant *var, void *user_data, GError *err) { - int run_timeout; + pid_t pid; + int ret, state; + char *app_id; - _I("Time out state %s.\n", states[pm_cur_state].name); - /* default setting */ - get_run_timeout(&run_timeout); + if (!var) + return; - /* for sdk - * if the run_timeout is zero, it regards AlwaysOn state + if (!dh_get_param_from_var(var, "(iis)", &pid, &state, &app_id)) { + _E("Failed to notify low: no message(%s)", g_variant_get_type_string(var)); + goto out; + } + + _W("%s(%d) was requested pmlock for a long time.", app_id, pid); + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_expired", + g_variant_new("(i)", pid)); + if (ret < 0) + _E("Failed to send dbus pmlock_expired"); + +out: + g_variant_unref(var); +} + +/* + * Any process is possible many time lock, deviced can not know malicious + * or good process. so infinity or more then 1 min lock process, deviced + * will be checked it to resoured. And then, it will be asked quit or maintain to user. */ - if (pm_cur_state == S_NORMAL && (run_timeout == 0 || display_conf.lcd_always_on)) { - _D("'run_timeout' is always on."); - return G_SOURCE_CONTINUE; +static void pmlock_check(void *data, char *st) +{ + const char *arr[2]; + char chr_pid[PID_MAX]; + pid_t pid; + int ret; + + if (!data || !st) + return; + + if (!strncmp(st, "lcdoff", 4) && backlight_ops.get_lcd_power() == DPMS_ON) { + _D("Lcd state is PM_LCD_POWER_ON"); + return; } + pid = (pid_t)((intptr_t)data); + snprintf(chr_pid, sizeof(chr_pid), "%d", pid); + + arr[0] = chr_pid; + arr[1] = st; + + ret = dbus_handle_method_async_with_reply(RESOURCED_BUS_NAME, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + METHOD_APP_STATUS, + "is", arr, pmlock_check_cb, -1, NULL); + if (ret < 0) + _E("Failed to call dbus method"); +} + +static gboolean pmlock_normal_check(void *data) +{ + pmlock_check(data, "normal"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_dim_check(void *data) +{ + pmlock_check(data, "lcddim"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_off_check(void *data) +{ + pmlock_check(data, "lcdoff"); + return G_SOURCE_CONTINUE; +} + +/* timeout handler */ +gboolean timeout_handler(void *data) +{ + _I("Time out state %s", states[pm_cur_state].name); + if (timeout_src_id) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -712,7 +945,7 @@ void reset_timeout(int timeout) if (!display_conf.timeout_enable) return; - _I("Reset timeout(%d ms)", timeout); + _I("Reset timeout(%d ms).", timeout); if (timeout_src_id != 0) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -753,7 +986,7 @@ static int get_lcd_timeout_from_settings(void) if (val > 0) states[i].timeout = val; - _I("state=%s timeout=%d ms", states[i].name, + _I("State(%s) timeout(%d) ms", states[i].name, states[i].timeout); } @@ -776,7 +1009,7 @@ static void update_display_time(void) if (custom_normal_timeout > 0) { states[S_NORMAL].timeout = custom_normal_timeout; states[S_LCDDIM].timeout = custom_dim_timeout; - _I("CUSTOM: Timeout(%d ms) and dim(%d ms) are set by normal.", + _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)", custom_normal_timeout, custom_dim_timeout); return; } @@ -807,7 +1040,8 @@ static void update_display_time(void) get_dim_timeout(&val); states[S_LCDDIM].timeout = val; - _I("Normal: timeout(%d ms) and dim(%d ms) are set.", states[S_NORMAL].timeout, states[S_LCDDIM].timeout); + _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout); + _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout); } static void update_display_locktime(int time) @@ -816,7 +1050,6 @@ static void update_display_locktime(int time) update_display_time(); } - void set_dim_state(bool on) { _I("Dim state is %d.", on); @@ -824,31 +1057,58 @@ void set_dim_state(bool on) states[pm_cur_state].trans(EVENT_INPUT); } +static void broadcast_pm_suspend(void) +{ + int ret; -void lcd_on_direct(enum device_flags flags) + if (pmstate_suspend) + return; + + _D("PM will be changed to sleep."); + + pmstate_suspend = PM_SUSPEND; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "sleep", + NULL); + if (ret < 0) + _E("Failed to send dbus signal sleep."); +} + +static void broadcast_pm_wakeup(void) { - int ret, call_state; + int ret; + + if (!pmstate_suspend) + return; + + _D("PM is changed to wakeup."); + + pmstate_suspend = PM_WAKEUP; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "wakeup", + NULL); + if (ret < 0) + _E("Failed to send dbus signal wakeup."); +} + +void lcd_on_direct(enum device_flags flags) +{ if (power_ops.get_power_lock_support() - && pm_cur_state == S_SLEEP) + && pm_cur_state == S_SLEEP) { + broadcast_pm_wakeup(); power_ops.power_lock(); + pm_cur_state = S_NORMAL; + } -#ifdef MICRO_DD - _D("Lcd is on directly."); + _D("lcd is on directly"); gettimeofday(&lcdon_tv, NULL); lcd_on_procedure(LCD_NORMAL, flags); - reset_timeout(DD_LCDOFF_INPUT_TIMEOUT); -#else - ret = vconf_get_int(VCONFKEY_CALL_STATE, &call_state); - if ((ret >= 0 && call_state != VCONFKEY_CALL_OFF) || - (__get_lock_screen_state() == VCONFKEY_IDLE_LOCK)) { - _D("LOCK state, lcd is on directly."); - lcd_on_procedure(LCD_NORMAL, flags); - } else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - reset_timeout(display_conf.lcdoff_timeout); -#endif + update_display_locktime(LOCK_SCREEN_INPUT_TIMEOUT); } @@ -860,6 +1120,41 @@ static inline bool check_lcd_is_on(void) return true; } +static int check_lock_condition(enum state_t state) +{ + dd_list *elem; + PmLockNode *t = NULL; + int ret = false; + pid_t owner = getpid(); + + _D("check holdkey block : state of %s", states[state].name); + + DD_LIST_FOREACH(cond_head[state], elem, t) { + if (t->pid != owner && t->background == false) { + ret = true; + _I("state change was blocked by pid(%d)!", t->pid); + break; + } + } + + return ret; +} + +static gboolean timer_refresh_cb(gpointer data) +{ + struct state *st; + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + if (st->action) + st->action(st->timeout); + + return 0; +} + int custom_lcdon(int timeout) { struct state *st; @@ -883,9 +1178,157 @@ int custom_lcdon(int timeout) if (st->action) st->action(st->timeout); + g_idle_add(timer_refresh_cb, NULL); + return 0; } +int custom_lcdoff(enum device_flags flag) +{ + struct state *st; + + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + /* + * When another proccess is normal lock, device is received call then, + * call app can be changed to lcd state by proximity. + * If proximity is near then normal lock will be unlocked. + */ + if (flag & LCD_OFF_BY_PROXIMITY) { + _I("custom lcd off by proximity, delete normal lock"); + delete_condition(S_NORMAL); + } else { + _I("skip custom lcd off"); + return -ECANCELED; + } + } + + _I("custom lcd off by flag(%d)", flag); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + if (set_custom_lcdon_timeout(0) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_on(char *reason, int timeout) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) + flag = LCD_ON_BY_GESTURE; + else if (!strncmp(reason, EVENT_STR, str_len)) + flag = LCD_ON_BY_EVENT; + else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + if (timeout <= 0) { + _E("Cannot setting timeout %d", timeout); + return -EINVAL; + } + + if (check_lcd_is_on() == false) + lcd_on_direct(flag); + + _I("platform lcd on by %s (%d ms)", reason, timeout); + if (set_custom_lcdon_timeout(timeout) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_off(char *reason) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) { + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + _I("skip platform lcd off by gesture"); + return -ECANCELED; + } + flag = LCD_OFF_BY_GESTURE; + } else if (!strncmp(reason, PALM_STR, str_len)) { + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); + + flag = LCD_OFF_BY_PALM; + } else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + _I("platform lcd off by %s", reason); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +int display_platform_control(int type, char *reason, int timeout) +{ + int ret; + + switch (type) { + case PLATFORM_DISPLAY_ON: + ret = display_platform_on(reason, timeout); + break; + case PLATFORM_DISPLAY_OFF: + ret = display_platform_off(reason); + break; + default: + _E("Unkown type(%d)", type); + ret = -EINVAL; + } + + return ret; +} + static void default_proc_change_state_action(enum state_t next, int timeout) { struct state *st; @@ -921,8 +1364,12 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) default_proc_change_state_action(next, -1); break; case S_LCDOFF: - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) { + if (get_proximity_state() == SENSOR_PROXIMITY_NEAR) + lcd_off_procedure(LCD_OFF_BY_PROXIMITY); + else lcd_off_procedure(LCD_OFF_BY_EVENT); + } if (set_custom_lcdon_timeout(0)) update_display_time(); default_proc_change_state_action(next, -1); @@ -932,7 +1379,14 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) /* at first LCD_OFF and then goto sleep */ /* state transition */ default_proc_change_state_action(S_LCDOFF, TIMEOUT_NONE); + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); delete_condition(S_LCDOFF); + if (lcdon_broadcast) { + _I("broadcast lcd off signal at non-lcd device"); + broadcast_lcd_off(SIGNAL_PRE, 0); + broadcast_lcd_off(SIGNAL_POST, 0); + } default_proc_change_state_action(S_SLEEP, TIMEOUT_NONE); break; @@ -967,15 +1421,18 @@ static void proc_condition_lock(PMMsg *data) pid_t pid = data->pid; enum state_t state; int holdkey_block; + bool value = true; + unsigned int flags; state = GET_COND_STATE(data->cond); - if (!state) + if (state == S_START) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); - if (state == S_LCDOFF && - pm_cur_state == S_SLEEP) + if (state == S_LCDOFF && pm_cur_state == S_SLEEP && + power_ops.get_power_lock() == POWER_UNLOCK) proc_change_state(data->cond, INTERNAL_LOCK_PM); if (data->timeout > 0) { @@ -1001,14 +1458,15 @@ static void proc_condition_lock(PMMsg *data) } if (state == S_LCDOFF) - set_process_active(TRUE, pid); + set_process_active(true, pid); + _I("[%s] locked by %5d with %u ms", states[state].name, pid, data->timeout); /* for debug */ - _SD("[%s] Locked by pid=%d process=%s holdkeyblock=%d\n", - states[state].name, pid, pname, holdkey_block); - set_lock_time(pname, state); + _SD("be requested LOCK info pname(%s), holdkeyblock(%d) flags(%d)", + pname, holdkey_block, flags); + set_lock_time(pid, pname, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)true); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static void proc_condition_unlock(PMMsg *data) @@ -1017,27 +1475,28 @@ static void proc_condition_unlock(PMMsg *data) enum state_t state; PmLockNode *tmp; char pname[PATH_MAX]; + bool value = false; + unsigned int flags; state = GET_COND_STATE(data->cond); if (!state) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); tmp = find_node(state, pid); del_node(state, tmp); if (state == S_LCDOFF) - set_process_active(FALSE, pid); - - if (ambient_get_state()) - ambient_check_invalid_state(pid); + set_process_active(false, pid); - _SD("[%s] Unlocked by pid=%d process=%s\n", - states[state].name, pid, pname); - set_unlock_time(pname, state); + _I("[%s] unlocked by %5d", states[state].name, pid); + /* for debug */ + _SD("be requested UNLOCK info pname(%s) flag(%d)", pname, flags); + set_unlock_time(pid, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)false); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static int proc_condition(PMMsg *data) @@ -1056,15 +1515,11 @@ static int proc_condition(PMMsg *data) flags = GET_COND_FLAG(data->cond); if (flags == 0) { /* guard time for suspend */ - if (pm_cur_state == S_LCDOFF) { + if (pm_cur_state == S_LCDOFF) reset_timeout(states[S_LCDOFF].timeout); - _I("Margin timeout(%d ms)", states[S_LCDOFF].timeout); - } } else { - if (flags & PM_FLAG_RESET_TIMER) { + if (flags & PM_FLAG_RESET_TIMER) reset_timeout(states[pm_cur_state].timeout); - _I("Reset timeout(%d ms)", states[pm_cur_state].timeout); - } } if (!timeout_src_id) @@ -1077,13 +1532,13 @@ static int proc_condition(PMMsg *data) int check_processes(enum state_t prohibit_state) { dd_list *elem, *next; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; DD_LIST_FOREACH_SAFE(cond_head[prohibit_state], elem, next, t) { if (t->pid < INTERNAL_LOCK_BASE && kill(t->pid, 0) == -1) { - _E("Process(%d) does not exist, delete the REQ" - " - prohibit state=%d.", + _E("%d process does not exist, delete the REQ" + " - prohibit state %d ", t->pid, prohibit_state); if (t->pid == custom_change_pid) { get_lcd_timeout_from_settings(); @@ -1091,6 +1546,7 @@ int check_processes(enum state_t prohibit_state) custom_change_pid = -1; } ret = 1; + set_unlock_time(t->pid, prohibit_state); del_node(prohibit_state, t); } } @@ -1101,7 +1557,7 @@ int check_processes(enum state_t prohibit_state) int check_holdkey_block(enum state_t state) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; _I("Check holdkey block: state of %s", states[state].name); @@ -1126,11 +1582,9 @@ int check_holdkey_block(enum state_t state) int delete_condition(enum state_t state) { dd_list *elem, *next; - PmLockNode *t; - pid_t pid; - char pname[PATH_MAX]; + PmLockNode *t = NULL; - _I("Delete condition: state of %s", states[state].name); + _I("delete condition : state of %s", states[state].name); if (!cond_head[state]) return 0; @@ -1140,13 +1594,11 @@ int delete_condition(enum state_t state) g_source_remove(t->timeout_id); t->timeout_id = 0; } - pid = t->pid; if (state == S_LCDOFF) - set_process_active(FALSE, pid); - _I("Delete node of pid(%d).", pid); + set_process_active(false, t->pid); + _I("delete node of pid(%d)", t->pid); + set_unlock_time(t->pid, state); del_node(state, t); - get_pname(pid, pname); - set_unlock_time(pname, state-1); } DD_LIST_FREE_LIST(cond_head[state]); @@ -1188,8 +1640,9 @@ static pm_history pm_history_log[MAX_LOG_COUNT] = {{0, }, }; static int history_count = 0; static const char history_string[PM_LOG_MAX][15] = { - "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON FAIL", - "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF FAIL", "SLEEP"}; + "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON COMPL", "LCD ON FAIL", + "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF COMPL", "LCD OFF FAIL", + "LCD FAIL", "SLEEP"}; void pm_history_init() { @@ -1242,7 +1695,7 @@ void pm_history_print(int fd, int count) time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } #endif @@ -1266,13 +1719,13 @@ void print_info(int fd) "===========================\n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Timeout Info: Run[%dms] Dim[%dms] Off[%dms]\n", states[S_NORMAL].timeout, states[S_LCDDIM].timeout, states[S_LCDOFF].timeout); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Tran. Locked : %s %s %s\n", (trans_condition & MASK_NORMAL) ? states[S_NORMAL].name : "-", @@ -1280,18 +1733,18 @@ void print_info(int fd) (trans_condition & MASK_OFF) ? states[S_LCDOFF].name : "-"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current State: %s\n", states[pm_cur_state].name); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current Lock Conditions: \n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); for (s_index = S_NORMAL; s_index < S_END; s_index++) { DD_LIST_FOREACH(cond_head[s_index], elem, t) { @@ -1302,7 +1755,7 @@ void print_info(int fd) i++, states[s_index].name, t->pid, pname, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } @@ -1313,37 +1766,39 @@ void print_info(int fd) #endif } -void save_display_log(void) +void save_display_log(char *path) { int fd, ret; char buf[255]; time_t now_time; char time_buf[30]; - _D("Internal state is saved."); + _D("internal state is saved!"); time(&now_time); ctime_r(&now_time, time_buf); - fd = open(PM_STATE_LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, 0644); + fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0644); if (fd != -1) { snprintf(buf, sizeof(buf), "\npm_state_log now-time : %d(s) %s\n\n", (int)now_time, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); snprintf(buf, sizeof(buf), "pm_status_flag: %x\n", pm_status_flag); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); - snprintf(buf, sizeof(buf), "screen lock status : %d\n", - __get_lock_screen_state()); - ret = write(fd, buf, strlen(buf)); - if (ret < 0) - _E("write() failed: %d", errno); + if (disp_plgn.get_lock_screen_state ) { + snprintf(buf, sizeof(buf), "screen lock status : %d\n", + disp_plgn.get_lock_screen_state()); + ret = write(fd, buf, strlen(buf)); + if (ret < 0) + _E("write() failed (%d)", errno); + } print_info(fd); close(fd); } @@ -1360,7 +1815,9 @@ void save_display_log(void) */ static void sig_hup(int signo) { - save_display_log(); + _I("received sig hub %d", signo); + + pm_save_logdump(); } int check_lcdoff_direct(void) @@ -1374,6 +1831,9 @@ int check_lcdoff_direct(void) if (pm_cur_state != S_LCDDIM) return false; + if (!display_conf.dimming) + return true; + lock = __get_lock_screen_state(); if (lock != VCONFKEY_IDLE_LOCK && hallic_open) return false; @@ -1388,7 +1848,7 @@ int check_lcdoff_direct(void) else if (ret < 0) _E("Failed to get vconf value for cradle status: %d", vconf_get_ext_errno()); - _D("Goto LCDOFF direct(lock=%d hdmi=%d cradle=%d).", lock, hdmi_state, cradle); + _D("Goto LCDOFF direct: lock(%d) hdmi(%d) cradle(%d).", lock, hdmi_state, cradle); return true; } @@ -1482,22 +1942,10 @@ static inline void stop_lock_timer(void) static void check_lock_screen(void) { - int lock_setting, lock_state, app_state, ret; + int lock_state, ret; stop_lock_timer(); - ret = vconf_get_int(VCONFKEY_CALL_STATE, &app_state); - if (ret >= 0 && app_state != VCONFKEY_CALL_OFF) - goto lcd_on; - else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - /* check setting of lock screen is enabled. */ - ret = vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, - &lock_setting); - if (ret < 0) - _E("Failed to get vconf value for screen lock type: %d", vconf_get_ext_errno()); - /* check state of lock */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); if (ret < 0 || lock_state == VCONFKEY_IDLE_LOCK) { @@ -1552,10 +2000,12 @@ static int default_action(int timeout) } if (pm_cur_state != pm_old_state && pm_cur_state != S_SLEEP) { - if (power_ops.get_power_lock_support()) + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); power_ops.power_lock(); + } set_setting_pmstate(pm_cur_state); - device_notify(DEVICE_NOTIFIER_LCD, &pm_cur_state); + device_notify(DEVICE_NOTIFIER_LCD, (void *)&pm_cur_state); } if (pm_old_state == S_NORMAL && pm_cur_state != S_NORMAL) { @@ -1595,11 +2045,11 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) { stop_lock_timer(); /* lcd off state : turn off the backlight */ - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); } - if (backlight_ops.get_lcd_power() != DPMS_OFF + if (backlight_ops.get_lcd_power() == DPMS_ON || lcd_paneloff_mode) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); break; @@ -1608,7 +2058,7 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) stop_lock_timer(); - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); if (!power_ops.get_power_lock_support()) { @@ -1635,6 +2085,7 @@ go_suspend: #ifdef ENABLE_PM_LOG pm_history_save(PM_LOG_SLEEP, pm_cur_state); #endif + broadcast_pm_suspend(); if (power_ops.get_power_lock_support()) { if (power_ops.enable_autosleep) power_ops.enable_autosleep(); @@ -1642,24 +2093,9 @@ go_suspend: if (power_ops.power_unlock() < 0) _E("Power unlock state error."); } else { - dd_list *elem, *elem_n; - const struct device_ops *dev; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } - power_ops.suspend(); - - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } - - _I("System wakeup."); - disp_plgn.system_wakeup_flag = true; + _I("system wakeup!!"); + system_wakeup_flag = true; /* Resume !! */ if (power_ops.check_wakeup_src() == EVENT_DEVICE) /* system waked up by devices */ @@ -1740,7 +2176,7 @@ static int poll_callback(int condition, PMMsg *data) if (condition == INPUT_POLL_EVENT) { if (pm_cur_state == S_LCDOFF || pm_cur_state == S_SLEEP) - _I("Power key input."); + _I("Input event signal at Display Off"); time(&now); if (last_t != now || pm_cur_state == S_LCDOFF || @@ -1801,11 +2237,13 @@ static int update_setting(int key_idx, int val) } pm_status_flag |= CHRGR_FLAG; } else { - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { power_saving_func(true); pm_status_flag |= LOWBT_FLAG; @@ -1878,9 +2316,9 @@ static void check_seed_status(void) { int ret = -1; int tmp = 0; - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; int brt = 0; - int lock_state = -1; + int lock_state; /* Charging check */ if ((get_charging_status(&tmp) == 0) && (tmp > 0)) @@ -1899,10 +2337,13 @@ static void check_seed_status(void) } _I("Set brightness(%d) from setting app.", tmp); backlight_ops.set_default_brt(tmp); + backlight_ops.set_brightness(tmp); ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { if (!(pm_status_flag & CHRGR_FLAG)) { power_saving_func(true); @@ -1912,9 +2353,10 @@ static void check_seed_status(void) /* lock screen check */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); - if (ret < 0) + if (ret < 0) { + lock_state = -1; _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno()); - + } set_lock_screen_state(lock_state); if (lock_state == VCONFKEY_IDLE_LOCK) { states[S_NORMAL].timeout = lock_screen_timeout; @@ -2044,36 +2486,20 @@ void reset_lcd_timeout(GDBusConnection *conn, static int booting_done(void *data) { - static int done; - - if (!data) - return done; + static bool done = false; + if (data != NULL) { done = *(int*)data; - if (!done) - return done; - - _I("Booting done. Release display and power lock."); - if (disp_plgn.pm_unlock_internal) { - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + if (done) + return 0; + _I("booting done, unlock LCD_OFF"); + if (disp_plgn.pm_unlock_internal) { + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); + } } - return done; -} - -int device_poweroff(void *data) -{ - static int off; - - if (!data) - return off; - - off = *(int *)data; - if (off) - _I("Poweroff"); - - return off; + return 0; } static int process_background(void *data) @@ -2086,7 +2512,7 @@ static int process_background(void *data) node = find_node(S_NORMAL, pid); if (node) { node->background = true; - _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); + _I("%d pid is background, then PM will be unlocked LCD_NORMAL", pid); } return 0; @@ -2102,7 +2528,7 @@ static int process_foreground(void *data) node = find_node(S_NORMAL, pid); if (node) { node->background = false; - _I("Process(%d) is foreground, then PM will be maintained locked LCD_NORMAL.", pid); + _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); } return 0; @@ -2142,49 +2568,58 @@ static int display_load_config(struct parse_result *result, void *user_data) if (MATCH(result->name, "LockScreenWaitingTime")) { SET_CONF(c->lock_wait_time, atof(result->value)); - _D("'lock wait time' is %.3f.", c->lock_wait_time); + _D("lock wait time is %.3f", c->lock_wait_time); } else if (MATCH(result->name, "LongPressInterval")) { SET_CONF(c->longpress_interval, atof(result->value)); - _D("'long press interval' is %.3f.", c->longpress_interval); + _D("long press interval is %.3f", c->longpress_interval); } else if (MATCH(result->name, "LightSensorSamplingInterval")) { SET_CONF(c->lightsensor_interval, atof(result->value)); - _D("'lightsensor interval' is %.3f.", c->lightsensor_interval); + _D("lightsensor interval is %.3f", c->lightsensor_interval); } else if (MATCH(result->name, "LCDOffTimeout")) { SET_CONF(c->lcdoff_timeout, atoi(result->value)); - _D("'lcdoff timeout' is %d ms.", c->lcdoff_timeout); + _D("lcdoff timeout is %d ms", c->lcdoff_timeout); } else if (MATCH(result->name, "BrightnessChangeStep")) { SET_CONF(c->brightness_change_step, atoi(result->value)); - _D("'brightness change step' is %d.", c->brightness_change_step); + _D("brightness change step is %d", c->brightness_change_step); } else if (MATCH(result->name, "LCDAlwaysOn")) { c->lcd_always_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'LCD always on' is %d.", c->lcd_always_on); + _D("LCD always on is %d", c->lcd_always_on); + } else if (MATCH(result->name, "Dimming")) { + c->dimming = (MATCH(result->value, "yes") ? 1 : 0); + _D("Dimming is %d", c->dimming); } else if (MATCH(result->name, "ChangedFrameRateAllowed")) { if (strstr(result->value, "setting")) { c->framerate_app[REFRESH_SETTING] = 1; - _D("'framerate app' is setting"); + _D("framerate app is Setting"); } if (strstr(result->value, "all")) { memset(c->framerate_app, 1, sizeof(c->framerate_app)); - _D("'framerate app' is all"); + _D("framerate app is All"); } } else if (MATCH(result->name, "ControlDisplay")) { c->control_display = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ControlDisplay' is %d.", c->control_display); + _D("ControlDisplay is %d", c->control_display); } else if (MATCH(result->name, "PowerKeyDoublePressSupport")) { c->powerkey_doublepress = (MATCH(result->value, "yes") ? 1 : 0); - _D("'PowerKeyDoublePressSupport' is %d.", c->powerkey_doublepress); + _D("PowerKeyDoublePressSupport is %d", c->powerkey_doublepress); } else if (MATCH(result->name, "AccelSensorOn")) { c->accel_sensor_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'AccelSensorOn' is %d.", c->accel_sensor_on); + _D("AccelSensorOn is %d", c->accel_sensor_on); } else if (MATCH(result->name, "ContinuousSampling")) { c->continuous_sampling = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ContinuousSampling' is %d.", c->continuous_sampling); + _D("ContinuousSampling is %d", c->continuous_sampling); } else if (MATCH(result->name, "TimeoutEnable")) { c->timeout_enable = (MATCH(result->value, "yes") ? true : false); - _D("'Timeout' is %s.", c->timeout_enable ? "enalbed" : "disabled"); + _D("Timeout is %s", c->timeout_enable ? "enalbed" : "disabled"); } else if (MATCH(result->name, "InputSupport")) { c->input_support = (MATCH(result->value, "yes") ? true : false); - _D("'Input' is %s.", c->input_support ? "supported" : "NOT supported"); + _D("Input is %s", c->input_support ? "supported" : "NOT supported"); + } else if (MATCH(result->name, "LockCheckTimeout")) { + SET_CONF(c->lockcheck_timeout, atoi(result->value)); + _D("LockCheckTimeout is %d", c->lockcheck_timeout); + } else if (MATCH(result->name, "AODTSP")) { + c->aod_tsp = (MATCH(result->value, "yes") ? true : false); + _D("TSP control at is %d at aod", c->aod_tsp); } return 0; @@ -2247,9 +2682,58 @@ static int display_probe(void *data) return 0; } +static int input_init_handler(void) +{ + if (!display_conf.input_support) + return 0; + + g_idle_add(init_input, NULL); + + return 0; +} + +static void esd_action(void) +{ + const struct device_ops *touchscreen_ops = NULL; + + _I("ESD on"); + + touchscreen_ops = find_device("touchscreen"); + + if (!check_default(touchscreen_ops)) + touchscreen_ops->stop(NORMAL_MODE); + backlight_ops.off(NORMAL_MODE); + backlight_ops.on(NORMAL_MODE); + if (!check_default(touchscreen_ops)) + touchscreen_ops->start(NORMAL_MODE); +} + +static void lcd_uevent_changed(struct udev_device *dev) +{ + const char *devpath; + const char *action; + + devpath = udev_device_get_devpath(dev); + if (!devpath) + return; + + if (!fnmatch(LCD_ESD_PATH, devpath, 0)) { + action = udev_device_get_action(dev); + if (!strcmp(action, UDEV_CHANGE)) + esd_action(); + } +} + +static const struct uevent_handler lcd_uevent_ops = { + .subsystem = LCD_EVENT_SUBSYSTEM, + .uevent_func = lcd_uevent_changed, + .data = NULL, +}; + static void display_init(void *data) { int ret, i; + unsigned int flags = (WITHOUT_STARTNOTI | FLAG_X_DPMS); int timeout = 0; bool wm_ready; @@ -2265,11 +2749,16 @@ static void display_init(void *data) _W("Failed to load '%s', use default value: %d", DISPLAY_CONF_FILE, ret); + register_kernel_uevent_control(&lcd_uevent_ops); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); register_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); register_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - register_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); register_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + register_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); + register_notifier(DEVICE_NOTIFIER_LCD_AUTOBRT_SENSING, display_auto_brightness_sensing); + + init_save_userlock(); for (i = INIT_SETTING; i < INIT_END; i++) { switch (i) { @@ -2279,15 +2768,14 @@ static void display_init(void *data) case INIT_INTERFACE: if (display_conf.timeout_enable) get_lcd_timeout_from_settings(); - ret = init_sysfs(); + ret = init_sysfs(flags); break; case INIT_POLL: - _I("Input init."); + _I("input init"); pm_callback = poll_callback; - if (display_conf.input_support) - ret = init_input(); - else - ret = 0; + ret = input_init_handler(); + + pm_lock_detector_init(); break; case INIT_DBUS: _I("Dbus init."); @@ -2308,6 +2796,13 @@ static void display_init(void *data) init_lcd_operation(); check_seed_status(); + /* In smd test, TSP should be turned off if display panel is not existed. */ + if (backlight_ops.get_lcd_power() == -ENOENT) { + _I("Display panel is not existed."); + lcd_direct_control(DPMS_OFF, NORMAL_MODE); + exit_lcd_operation(); + } + /* wm_ready needs to be checked * since display manager can be launched later than deviced. * In the case, display cannot be turned on at the first booting */ @@ -2322,33 +2817,35 @@ static void display_init(void *data) trans_table[S_NORMAL][EVENT_TIMEOUT] = S_NORMAL; } - _I("Start Power managing without noti."); - if (power_ops.get_power_lock_support()) - power_ops.power_lock(); - - pm_cur_state = S_NORMAL; - set_setting_pmstate(pm_cur_state); - - if (display_conf.timeout_enable) { - timeout = states[S_NORMAL].timeout; - /* check minimun lcd on time */ - if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) - timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); + if (flags & WITHOUT_STARTNOTI) { /* start without noti */ + _I("Start Power managing without noti"); + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); + power_ops.power_lock(); + } + pm_cur_state = S_NORMAL; + vconf_set_int(VCONFKEY_PM_STATE, pm_cur_state); + + status = DEVICE_OPS_STATUS_START; + if (display_conf.timeout_enable) { + timeout = states[S_NORMAL].timeout; + /* check minimun lcd on time */ + if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) + timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); + + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, + STAY_CUR_STATE, timeout); + } - reset_timeout(timeout); - } - - status = DEVICE_OPS_STATUS_START; - /* - * Lock lcd off until booting is done. - * deviced guarantees all booting script is executing. - * Last script of booting unlocks this suspend blocking state. - */ - if (disp_plgn.pm_lock_internal) { - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); + /* + * Lock lcd off until booting is done. + * deviced guarantees all booting script is executing. + * Last script of booting unlocks this suspend blocking state. + */ + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, + STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); } if (display_conf.input_support) @@ -2372,6 +2869,8 @@ static void display_exit(void *data) if (CHECK_OPS(keyfilter_ops, exit)) keyfilter_ops->exit(); + unregister_kernel_uevent_control(&lcd_uevent_ops); + display_ops_exit(NULL); for (i = i - 1; i >= INIT_SETTING; i--) { @@ -2386,8 +2885,8 @@ static void display_exit(void *data) unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); unregister_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); unregister_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - unregister_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); unregister_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + unregister_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); exit_input(); break; @@ -2405,6 +2904,9 @@ static void display_exit(void *data) static int display_start(enum device_flags flags) { + const struct display_ops *enhance_ops = NULL; + bool on = true; + /* NORMAL MODE */ if (flags & NORMAL_MODE) { if (flags & LCD_PANEL_OFF_MODE) @@ -2413,6 +2915,9 @@ static int display_start(enum device_flags flags) else /* normal lcd on */ backlight_ops.on(flags); + FIND_DISPLAY(enhance_ops, "enhance"); + if (enhance_ops && enhance_ops->func) + enhance_ops->func(RESTORE_ENHANCE_OUTDOOR, &on); return 0; } @@ -2434,7 +2939,7 @@ static int display_start(enum device_flags flags) static int display_stop(enum device_flags flags) { /* NORMAL MODE */ - if (flags & NORMAL_MODE) { + if (flags & NORMAL_MODE || flags & FORCE_OFF_MODE) { backlight_ops.off(flags); return 0; } @@ -2458,7 +2963,7 @@ static int display_status(void) static const struct device_ops display_device_ops = { .priority = DEVICE_PRIORITY_HIGH, - .name = "display", + DECLARE_NAME_LEN("display"), .probe = display_probe, .init = display_init, .exit = display_exit, diff --git a/plugins/mobile/display/device-interface.c b/plugins/mobile/display/device-interface.c index 01b98ac..37a86cb 100644 --- a/plugins/mobile/display/device-interface.c +++ b/plugins/mobile/display/device-interface.c @@ -29,19 +29,21 @@ #include #include #include -#include +#include #include "ambient-mode.h" #include "core/log.h" #include "core/devices.h" -#include "core/list.h" #include "core/common.h" -#include "display/display-dpms.h" +#include "core/device-notifier.h" #include "util.h" #include "device-interface.h" #include "vconf.h" #include "core.h" #include "device-node.h" +#include "display/display-dpms.h" + +#define SET_SUSPEND_TIME 0.5 #define TOUCH_ON 1 #define TOUCH_OFF 0 @@ -49,7 +51,8 @@ #define LCD_PHASED_MIN_BRIGHTNESS 1 #define LCD_PHASED_MAX_BRIGHTNESS 100 #define LCD_PHASED_CHANGE_STEP 5 -#define LCD_PHASED_DELAY 35000 /* microsecond */ +#define LCD_PHASED_DELAY 10000 /* microsecond */ +#define DUMP_MODE_WAITING_TIME 600000 /* microsecond */ #define POWER_AUTOSLEEP_PATH "/sys/power/autosleep" #define POWER_LOCK_PATH "/sys/power/wake_lock" @@ -57,24 +60,57 @@ #define POWER_WAKEUP_PATH "/sys/power/wakeup_count" #define POWER_STATE_PATH "/sys/power/state" -enum { - POWER_UNLOCK = 0, - POWER_LOCK, -}; +#define DISPLAY_HAL_LIB_PATH "/usr/lib/libdisplay-hal.so" + +#define GESTURE_STR "gesture" +#define POWERKEY_STR "powerkey" +#define EVENT_STR "event" +#define TOUCH_STR "touch" +#define TIMEOUT_STR "timeout" +#define PROXIMITY_STR "proximity" +#define PALM_STR "palm" +#define UNKNOWN_STR "unknown" + +#define FREEZER_VITAL_WAKEUP_CGROUP "/sys/fs/cgroup/freezer/vital_wakeup/freezer.state" struct _backlight_ops backlight_ops; struct _power_ops power_ops; +static int mainlock_status = POWER_UNLOCK; static bool custom_status; static int custom_brightness; static int force_brightness; static int default_brightness; - +static int vital_support = -2; +static int vital_service; +static bool vital_sleep; +static int dpms_running_state = DPMS_SETTING_DONE; static struct display_device *display_dev; +static guint release_timer; -static int bl_onoff(int on) +struct display_device *display_dev_get(void) +{ + return display_dev; +} + +void dpms_set_running_state(int val) +{ + dpms_running_state = val; +} + +static int bl_onoff(int on, enum device_flags flags) { dpms_set_state(on); + +#ifdef ENABLE_PM_LOG + if (on == DPMS_ON) + pm_history_save(PM_LOG_LCD_ON_COMPLETE, pm_cur_state); + else if (on == DPMS_OFF || on == DPMS_FORCE_OFF) + pm_history_save(PM_LOG_LCD_OFF_COMPLETE, pm_cur_state); + else + pm_history_save(PM_LOG_LCD_CONTROL_FAIL, on); +#endif + return 0; } @@ -85,12 +121,6 @@ static int bl_brt(int brightness, int delay) if (delay > 0) usleep(delay); - if (force_brightness > 0) { - _I("brightness=%d force brightness=%d", - brightness, force_brightness); - brightness = force_brightness; - } - /* Update device brightness */ ret = backlight_ops.set_brightness(brightness); @@ -115,39 +145,96 @@ static int system_enable_autosleep(void) return sys_set_str(POWER_AUTOSLEEP_PATH, "mem"); } -static int system_power_lock(void) +static int vital_mode_support(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; - int ret; + if (vital_support < 0) { + FILE *fp; + + fp = fopen(FREEZER_VITAL_WAKEUP_CGROUP, "r"); + if (fp == NULL) { + _E("%s open failed", FREEZER_VITAL_WAKEUP_CGROUP); + /* read max 2 times to check if this file exist */ + vital_support++; + return 0; + } + vital_support = 1; + fclose(fp); + } + return vital_support; +} - _I("system power lock."); - ret = sys_set_str(POWER_LOCK_PATH, "mainlock"); +static int suspend_other_process(int type) +{ + int ret = 0; + char buf[8]; + const char *command[1]; - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } + if (vital_service == type) + return ret; + + if (type == VITAL_WAKEUP && vital_service > VITAL_SLEEP) + return ret; + + vital_service = type; + + if (!vital_mode_support()) + return ret; + if (type == VITAL_SLEEP) { + snprintf(buf, sizeof(buf), "%s", "sleep"); + command[0] = buf; + dbus_handle_method_sync_timeout(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", + command, + SET_SUSPEND_TIME*1000); + vital_sleep = true; + } else if (type == VITAL_WAKEUP) { + snprintf(buf, sizeof(buf), "%s", "wakeup"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + } else if (type == VITAL_EXIT) { + snprintf(buf, sizeof(buf), "%s", "exit"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + vital_sleep = false; + } return ret; } -static int system_power_unlock(void) +static int system_power_lock(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; + _I("system power lock"); + suspend_other_process(VITAL_WAKEUP); + mainlock_status = POWER_LOCK; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } + return sys_set_str(POWER_LOCK_PATH, "mainlock"); +} + +static int system_power_unlock(void) +{ + _I("system power unlock"); + suspend_other_process(VITAL_SLEEP); + mainlock_status = POWER_UNLOCK; - _I("system power unlock."); return sys_set_str(POWER_UNLOCK_PATH, "mainlock"); } +static int system_get_power_lock(void) +{ + return mainlock_status; +} + static int system_get_power_lock_support(void) { static int power_lock_support = -1; @@ -162,7 +249,7 @@ static int system_get_power_lock_support(void) else power_lock_support = true; - _I("system power lock: %s", + _I("System power lock: %s", (power_lock_support ? "support" : "not support")); out: @@ -174,9 +261,6 @@ static int get_lcd_power(void) enum display_state val; int ret; - if (ambient_get_state()) - return DPMS_OFF; - if (!display_dev || !display_dev->get_state) { _E("There is no display device."); return -ENOENT; @@ -186,6 +270,12 @@ static int get_lcd_power(void) if (ret < 0) return ret; + if (val == DISPLAY_ON && ambient_get_state()) + return DPMS_OFF; + + if (dpms_running_state != DPMS_SETTING_DONE) + return dpms_running_state; + switch (val) { case DISPLAY_ON: return DPMS_ON; @@ -202,13 +292,16 @@ static int get_lcd_power(void) bool display_dimstay_check(void) { + if (pm_status_flag & DIM_FLAG) + return true; + if ((pm_status_flag & PWRSV_FLAG) && !(pm_status_flag & BRTCH_FLAG)) return true; return false; } -void change_brightness(int start, int end, int step) +static void change_brightness(int start, int end, int step) { int diff, val; int ret = -1; @@ -226,7 +319,20 @@ void change_brightness(int start, int end, int step) if (prev == end) return; - _D("start=%d end=%d step=%d", start, end, step); + if (pm_status_flag & DIM_MASK) + end = 0; + + _I("start %d end %d step %d", start, end, step); + + if (display_dev && display_dev->set_multi_brightness) { + ret = display_dev->set_multi_brightness(end, step, LCD_PHASED_DELAY); + if (ret < 0) + _E("Failed to set_multi_brightness (%d)", ret); + + backlight_ops.set_brightness(end); + + return; + } diff = end - start; @@ -250,16 +356,15 @@ void change_brightness(int start, int end, int step) static int backlight_on(enum device_flags flags) { int ret = -1; + static int cnt; - _D("LCD on %x", flags); + _I("[DPMS XLIB Backlight] LCD on %x cnt:%d", flags, cnt); - ret = bl_onoff(DPMS_ON); - if (ret < 0) - _E("Failed to turn on backlight."); - - if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(LCD_PHASED_MIN_BRIGHTNESS, - default_brightness, LCD_PHASED_CHANGE_STEP); + cnt++; + ret = bl_onoff(DPMS_ON, flags); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_ON, pm_cur_state); +#endif return ret; } @@ -267,19 +372,30 @@ static int backlight_on(enum device_flags flags) static int backlight_off(enum device_flags flags) { int ret = -1; + static int cnt, ambient_cnt; + + if (flags & AMBIENT_MODE) { + _I("[DPMS XLIB Backlight] LCD suspend %x cnt:%d", flags, ambient_cnt); + ambient_cnt++; + + return 0; + } - _D("LCD off %x", flags); + _I("[DPMS XLIB Backlight] LCD off %x cnt:%d", flags, cnt); + cnt++; if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(default_brightness, + backlight_ops.transit_brt(default_brightness, LCD_PHASED_MIN_BRIGHTNESS, LCD_PHASED_CHANGE_STEP); - if (flags & AMBIENT_MODE) - return 0; + if (flags & FORCE_OFF_MODE) + ret = bl_onoff(DPMS_FORCE_OFF, flags); + else + ret = bl_onoff(DPMS_OFF, flags); - ret = bl_onoff(DPMS_OFF); - if (ret < 0) - _E("Failed to turn off backlight."); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_OFF, pm_cur_state); +#endif return ret; } @@ -287,15 +403,8 @@ static int backlight_off(enum device_flags flags) static int backlight_dim(void) { int ret; - int brightness; - ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_DIM_BRIGHTNESS, &brightness); - if (ret < 0) { - _E("Failed to get vconf value for lcd dim brightness: %d", vconf_get_ext_errno()); - return -EPERM; - } - - ret = bl_brt(brightness, 0); + ret = backlight_ops.set_brightness(PM_DIM_BRIGHTNESS); #ifdef ENABLE_PM_LOG if (!ret) pm_history_save(PM_LOG_LCD_DIM, pm_cur_state); @@ -335,11 +444,11 @@ static int custom_backlight_update(void) custom_brightness > PM_MAX_BRIGHTNESS) return -EINVAL; - if (display_dimstay_check()) { + if (display_dimstay_check()) ret = backlight_dim(); - } else { - _I("Custom brightness(%d) restored.", custom_brightness); - ret = bl_brt(custom_brightness, 0); + else { + _I("custom brightness restored! %d", custom_brightness); + ret = backlight_ops.set_brightness(custom_brightness); } return ret; @@ -358,16 +467,18 @@ static int set_force_brightness(int level) static int backlight_update(void) { int ret = 0; + int brt; if (get_custom_status()) { - _I("Custom brightness mode. brt no updated."); + _I("custom brightness mode! brt no updated"); return 0; } if (display_dimstay_check()) ret = backlight_dim(); - else - ret = bl_brt(default_brightness, 0); - + else { + brt = backlight_ops.get_default_brt(); + ret = backlight_ops.set_brightness(brt); + } return ret; } @@ -377,7 +488,7 @@ static int backlight_standby(int force) if ((get_lcd_power() == DPMS_ON) || force) { _I("LCD standby"); - ret = bl_onoff(DPMS_STANDBY); + ret = bl_onoff(DPMS_STANDBY, 0); } return ret; @@ -393,6 +504,11 @@ static int set_default_brt(int level) return 0; } +static int get_default_brt(void) +{ + return default_brightness; +} + static int check_wakeup_src(void) { /* TODO if nedded. @@ -470,10 +586,22 @@ static int set_brightness(int val) return max; } + if (force_brightness > 0 && val != PM_DIM_BRIGHTNESS) { + _I("brightness(%d), force brightness(%d)", + val, force_brightness); + val = force_brightness; + } + + if (pm_status_flag & DIM_MASK) + val = 0; + /* Maximum Brightness to users is 100. * Thus real brightness need to be calculated */ val = val * max / 100; + _I("set brightness %d (default:%d)", val, default_brightness); + device_notify(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, (void *)&val); + return display_dev->set_brightness(val); } @@ -544,6 +672,84 @@ static int get_brightness_by_light_sensor(float lmax, float lmin, float light, i return 0; } +static int get_image_effect(enum display_image_effect *effect) +{ + int ret; + enum display_image_effect val; + + if (!display_dev || !display_dev->get_image_effect) { + _E("There is no display device."); + return -ENOENT; + } + + ret = display_dev->get_image_effect(&val); + if (ret < 0) { + _E("Failed to get image effect: %d", ret); + return ret; + } + + *effect = val; + + return 0; +} + +static int set_image_effect(enum display_image_effect effect) +{ + int ret; + + if (!display_dev || !display_dev->set_image_effect) { + _E("There is no display device."); + return -ENOENT; + } + + ret = display_dev->set_image_effect(effect); + if (ret < 0) { + _E("Failed to set image effect: %d", ret); + return ret; + } + + return 0; +} + +static int get_panel_mode(enum display_panel_mode *mode) +{ + int ret; + enum display_panel_mode val; + + if (!display_dev || !display_dev->get_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->get_panel_mode(&val); + if (ret < 0) { + _E("failed to get panel mode(%d)", ret); + return ret; + } + + *mode = val; + + return 0; +} + +static int set_panel_mode(enum display_panel_mode mode) +{ + int ret; + + if (!display_dev || !display_dev->set_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->set_panel_mode(mode); + if (ret < 0) { + _E("failed to set panel mode(%d)", ret); + return ret; + } + + return 0; +} + static int get_frame_rate(int *rate) { if (!rate) @@ -595,6 +801,101 @@ static int set_frame_rate(int rate) return display_dev->set_frame_rate(rate); } +/* It was operated only AOD enter & leave */ +static int backlight_transit_state(int state) +{ + int brt, val; + int start, end; + + backlight_ops.get_brightness(&brt); + + if (state == DPMS_OFF) { + start = brt; + end = display_conf.aod_enter_level; + + /* + * The value of backlight_ops.get_brightness is system brightness. + * But when device is LBM, the value is not same with real brightness. + * So it should be read exactly value for transit smooth effect + */ + get_brightness(&val); + + if (val > display_conf.aod_enter_level) + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } else { + /* prevent transit effect when another effect is already executed */ + if (brt != display_conf.aod_enter_level) { + _W("effect is already executed brt(%d) aod_level(%d)", + brt, display_conf.aod_enter_level); + return 0; + } + + start = display_conf.aod_enter_level; + end = default_brightness; + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } + + return 0; +} + +static gboolean blink_cb(gpointer data) +{ + static bool flag; + + set_brightness(flag ? PM_MAX_BRIGHTNESS : PM_MIN_BRIGHTNESS); + + flag = !flag; + + return G_SOURCE_CONTINUE; +} + +static void blink(int timeout) +{ + static guint timer; + + if (timer) { + g_source_remove(timer); + timer = 0; + } + + if (timeout < 0) { + _E("timeout value is invalid %d", timeout); + return; + } + + if (timeout == 0) { + backlight_update(); + return; + } + + timer = g_timeout_add(timeout, blink_cb, NULL); +} + +static gboolean release_blink_cb(gpointer data) +{ + blink(0); + + release_timer = 0; + return G_SOURCE_REMOVE; +} + +static void release_blink(void) +{ + if (release_timer) { + g_source_remove(release_timer); + release_timer = 0; + } + + release_timer = g_timeout_add(DUMP_MODE_WAITING_TIME, release_blink_cb, NULL); +} + +static void restore_brightness_func(void) +{ + backlight_ops.set_brightness = set_brightness; + backlight_ops.get_brightness = get_brightness; + backlight_ops.transit_brt = change_brightness; +} + static void _init_ops(void) { backlight_ops.off = backlight_off; @@ -603,6 +904,7 @@ static void _init_ops(void) backlight_ops.update = backlight_update; backlight_ops.standby = backlight_standby; backlight_ops.set_default_brt = set_default_brt; + backlight_ops.get_default_brt = get_default_brt; backlight_ops.get_lcd_power = get_lcd_power; backlight_ops.set_custom_status = set_custom_status; backlight_ops.get_custom_status = get_custom_status; @@ -611,14 +913,24 @@ static void _init_ops(void) backlight_ops.set_force_brightness = set_force_brightness; backlight_ops.set_brightness = set_brightness; backlight_ops.get_brightness = get_brightness; + backlight_ops.restore_brightness_func = restore_brightness_func; backlight_ops.get_brightness_by_light_sensor = get_brightness_by_light_sensor; + backlight_ops.get_image_effect = get_image_effect; + backlight_ops.set_image_effect = set_image_effect; + backlight_ops.get_panel_mode = get_panel_mode; + backlight_ops.set_panel_mode = set_panel_mode; backlight_ops.get_frame_rate = get_frame_rate; backlight_ops.set_frame_rate = set_frame_rate; + backlight_ops.transit_state = backlight_transit_state; + backlight_ops.transit_brt = change_brightness; + backlight_ops.blink = blink; + backlight_ops.release_blink = release_blink; power_ops.suspend = system_suspend; power_ops.enable_autosleep = system_enable_autosleep; power_ops.power_lock = system_power_lock; power_ops.power_unlock = system_power_unlock; + power_ops.get_power_lock = system_get_power_lock; power_ops.get_power_lock_support = system_get_power_lock_support; power_ops.check_wakeup_src = check_wakeup_src; power_ops.get_wakeup_count = get_wakeup_count; @@ -636,12 +948,12 @@ int display_service_load(void) r = hw_get_info(DISPLAY_HARDWARE_DEVICE_ID, (const struct hw_info **)&info); if (r < 0) { - _I("Display shared library is not supported: %d", r); - return -ENODEV; + _I("display shared library is not supported: %d", r); + return 0; } if (!info->open) { - _E("Failed to open display device: open(NULL)"); + _E("Failed to open display device: open(NULL)."); return -EPERM; } @@ -672,17 +984,44 @@ int display_service_free(void) return 0; } -int init_sysfs() +bool vital_mode(void) +{ + return vital_sleep; +} + +static int vital_state_changed(void *data) +{ + int type; + + assert(data); + + type = *(int *)data; + if (type == VITAL_EXIT) + suspend_other_process(VITAL_EXIT); + + return 0; +} + +int init_sysfs(unsigned int flags) { _init_ops(); + register_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } int exit_sysfs(void) { + int fd; const struct device_ops *ops = NULL; + fd = open("/tmp/sem.pixmap_1", O_RDONLY); + if (fd == -1) { + _E("X server disable"); + backlight_on(NORMAL_MODE); + } + backlight_update(); disconnect_interface_with_dpms(); @@ -694,5 +1033,10 @@ int exit_sysfs(void) if (!check_default(ops)) ops->start(NORMAL_MODE); + if (fd != -1) + close(fd); + + unregister_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } diff --git a/plugins/mobile/display/display-info.h b/plugins/mobile/display/display-info.h new file mode 100644 index 0000000..bf368da --- /dev/null +++ b/plugins/mobile/display/display-info.h @@ -0,0 +1,50 @@ +/* + * deviced + * + * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef __DISPLAY_INFO_H__ +#define __DISPLAY_INFO_H__ + +#define DISPLAY_FUNC(a, b) (((a) << 16) | (b)) +#define ENHANCE_CMD(x) DISPLAY_FUNC('E', (x)) +#define HBM_CMD(x) DISPLAY_FUNC('H', (x)) +#define LBM_CMD(x) DISPLAY_FUNC('L', (x)) + +enum hbm_state { + HBM_SET_STATE = HBM_CMD(1), + HBM_GET_STATE, + HBM_TURN_ON, + HBM_TURN_OFF, + HBM_SET_TIMEOUT_STATE, + HBM_TURN_OFF_STATE, +}; + +enum lbm_state { + LBM_TABLE_LOAD = LBM_CMD(1), +}; + +enum enhance_state { + RESTORE_ENHANCE_OUTDOOR = ENHANCE_CMD(1), +}; + +struct hbmsetstate { + int hbm; + int timeout; +}; + +#endif diff --git a/plugins/mobile/display/key-filter.c b/plugins/mobile/display/key-filter.c index 3462aa7..ddbb287 100644 --- a/plugins/mobile/display/key-filter.c +++ b/plugins/mobile/display/key-filter.c @@ -25,6 +25,7 @@ #include #include #include +#include #include "ambient-mode.h" #include "util.h" @@ -36,11 +37,11 @@ #include "core/common.h" #include "core/devices.h" #include "core/device-notifier.h" +#include "shared/common.h" #include "power/power-handler.h" #include "led/touch-key.h" #include "apps/apps.h" -#include #ifndef KEY_SCREENLOCK #define KEY_SCREENLOCK 0x98 #endif @@ -50,21 +51,24 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" +#define PWROFF_POPUP_ACT "pwroff_popup" #define USEC_PER_SEC 1000000 +#define CSC_CONFIG_MODE_RUNNING 1 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ +#define TORCH_COMBINATION_INTERVAL 0.1 /* 0.1 second */ +#define DEFAULT_COMBINATION_INTERVAL 0.1 /* 0.1 second */ -#define KEY_MAX_DELAY_TIME 700 /* ms */ +#define LONGKEY_PRESSED_TIME 4 /* 4 second */ -#define KEY_RELEASED 0 -#define KEY_PRESSED 1 -#define KEY_BEING_PRESSED 2 +#define KEY_MAX_DELAY_TIME 700 /* ms */ #define SIGNAL_CHANGE_HARDKEY "ChangeHardkey" #define SIGNAL_LCDON_BY_POWERKEY "LCDOnByPowerkey" #define SIGNAL_LCDOFF_BY_POWERKEY "LCDOffByPowerkey" -#define TOUCH_RELEASE (-1) +#define NORMAL_POWER 0 +#define KEY_TEST_MODE_POWER 2 #define GLOVE_MODE 1 @@ -72,39 +76,30 @@ enum key_combination_flags { KEY_COMBINATION_STOP = 0, KEY_COMBINATION_POWERKEY = BIT(0), KEY_COMBINATION_MENUKEY = BIT(1), + KEY_COMBINATION_VOLUMEUP = BIT(2), + KEY_COMBINATION_VOLUMEDOWN = BIT(3), }; enum combination_process { COMBINATION_STOP = KEY_COMBINATION_STOP, COMBINATION_SCREENCAPTURE = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_MENUKEY, + COMBINATION_TORCH = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEUP, + COMBINATION_QUICKTALK = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEDOWN, }; -int __WEAK__ get_glove_state(void); -void __WEAK__ switch_glove_key(int val); - static struct timeval pressed_time; static guint longkey_timeout_id = 0; +static guint longkey_restore_id = 0; +static guint displayon_by_powerkey_timeout_id = 0; static int cancel_lcdoff; static int key_combination = KEY_COMBINATION_STOP; static double combination_pressed_time; static bool touch_pressed = false; static int skip_lcd_off = false; static int skip_combination = false; +static int bezel_wakeup = true; static const struct device_ops *touchled; - -static int booting_done(void *data) -{ - static int done = 0; - - if (!data) - return done; - - done = *(int *)data; - - _I("Booting done(%d)", done); - - return done; -} +static int booting_check = true; static inline int current_state_in_on(void) { @@ -128,7 +123,7 @@ static void pwroff_popup(void) _E("Failed to launch power off popup."); } -static void longkey_pressed() +static void longkey_pressed(void) { unsigned int caps; @@ -152,6 +147,14 @@ static void longkey_pressed() pwroff_popup(); } +static gboolean longkey_restore_cb(void *data) +{ + device_notify(DEVICE_NOTIFIER_LONGKEY_RESTORE, (void *)NULL); + longkey_restore_id = 0; + + return G_SOURCE_REMOVE; +} + static gboolean longkey_pressed_cb(void *data) { longkey_pressed(); @@ -196,7 +199,7 @@ static inline void broadcast_lcdoff_by_powerkey(void) NULL); } -static inline bool switch_on_lcd(void) +static inline bool switch_on_lcd(enum device_flags flags) { if (current_state_in_on()) return false; @@ -206,9 +209,12 @@ static inline bool switch_on_lcd(void) return false; } - broadcast_lcdon_by_powerkey(); + if (flags & LCD_ON_BY_POWER_KEY) + broadcast_lcdon_by_powerkey(); + else if (flags & LCD_ON_BY_TOUCH) + _I("Display on by Touch_wakeup event"); - lcd_on_direct(LCD_ON_BY_POWER_KEY); + lcd_on_direct(flags); return true; } @@ -230,15 +236,37 @@ static void check_key_combination(struct input_event *pinput) { double press_time, diff_time; press_time = (pinput->time).tv_sec + USEC_TO_SEC((pinput->time).tv_usec); + diff_time = press_time - combination_pressed_time; switch (key_combination) { case COMBINATION_SCREENCAPTURE: - diff_time = press_time - combination_pressed_time; if (diff_time <= CAPTURE_COMBINATION_INTERVAL) { _I("Combination key : SCREENCAPTURE mode"); skip_combination = true; } break; + case COMBINATION_TORCH: + if (diff_time <= TORCH_COMBINATION_INTERVAL) { + /* When torch combination, display control should be not change. */ + if (displayon_by_powerkey_timeout_id) { + g_source_remove(displayon_by_powerkey_timeout_id); + displayon_by_powerkey_timeout_id = 0; + } + _I("Combination key : TORCH mode"); + skip_combination = true; + } else + key_combination = COMBINATION_STOP; + break; + case COMBINATION_QUICKTALK: + if (diff_time <= DEFAULT_COMBINATION_INTERVAL) { + _I("Combination key : QUICK-TALK mode"); + skip_combination = true; + if (longkey_timeout_id) { + g_source_remove(longkey_timeout_id); + longkey_timeout_id = 0; + } + } + break; default: combination_pressed_time = press_time; return; @@ -255,6 +283,12 @@ static void start_key_combination(struct input_event *pinput) case KEY_MENU: key_combination |= KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination |= KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination |= KEY_COMBINATION_VOLUMEDOWN; + break; default: return; } @@ -276,8 +310,14 @@ static void stop_key_combination(struct input_event *pinput) case KEY_MENU: key_combination &= ~KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination &= ~KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination &= ~KEY_COMBINATION_VOLUMEDOWN; + break; default: - _E("Thid code(%d) is not combination type", pinput->code); + _E("This code(%d) is not combination type.", pinput->code); break; } } @@ -301,9 +341,8 @@ static int process_menu_key(struct input_event *pinput) return false; _D("No lcd-on capability!"); return true; - } else if (pinput->value == KEY_PRESSED) { - switch_on_lcd(); - } + } else if (pinput->value == KEY_PRESSED) + switch_on_lcd(LCD_ON_BY_POWER_KEY); return false; } @@ -336,7 +375,7 @@ static int decide_lcdoff(void) return false; /* At booting time, display must do not turn off */ - if (!booting_done(NULL)) + if (booting_check) return false; return true; @@ -370,6 +409,50 @@ static int lcdoff_powerkey(void) return ignore; } +static bool key_check_display_on(void) +{ + if (current_state_in_on()) + return false; + + if (backlight_ops.get_lcd_power() == DPMS_ON) { + _W("display power was on"); + return false; + } + + return true; +} + +static gboolean display_on_cb(void *data) +{ + if (displayon_by_powerkey_timeout_id == 0) + return G_SOURCE_REMOVE; + + displayon_by_powerkey_timeout_id = 0; + if (backlight_ops.get_lcd_power() != DPMS_ON || + current_state_in_on() == false) { + broadcast_lcdon_by_powerkey(); + lcd_on_direct(LCD_ON_BY_POWER_KEY); + + if (pm_callback) + (*pm_callback) (INPUT_POLL_EVENT, NULL); + } + + return G_SOURCE_REMOVE; +} + +static int process_back_key(struct input_event *pinput) +{ + int ignore = true; + + if (pinput->value == KEY_PRESSED) { + switch_on_lcd(LCD_ON_BY_POWER_KEY); + _I("back key pressed"); + ignore = false; + } + + return ignore; +} + static int process_power_key(struct input_event *pinput) { int ignore = true; @@ -387,9 +470,8 @@ static int process_power_key(struct input_event *pinput) lcdoff_powerkey(); else _D("No lcdoff capability!"); - } else if (skip_lcd_off) { + } else if (skip_lcd_off) ignore = false; - } if (!display_has_caps(caps, DISPLAY_CAPA_LCDON)) ignore = true; @@ -399,10 +481,32 @@ static int process_power_key(struct input_event *pinput) longkey_timeout_id = 0; } + if (longkey_restore_id > 0) { + g_source_remove(longkey_restore_id); + longkey_restore_id = 0; + } + break; case KEY_PRESSED: if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) { - skip_lcd_off = switch_on_lcd(); + if (wearable_mode()) + skip_lcd_off = switch_on_lcd(LCD_ON_BY_POWER_KEY); + else { + /* + * LCD does not turn on immediately at mobile. + * It will be turned on after 0.1 second because of torch concept. + */ + skip_lcd_off = key_check_display_on(); + ignore = true; + + if (!displayon_by_powerkey_timeout_id && + backlight_ops.get_lcd_power() != DPMS_ON && + key_combination != COMBINATION_TORCH) { + displayon_by_powerkey_timeout_id = g_timeout_add( + 100, + display_on_cb, NULL); + } + } } else { _D("No lcdon capability!"); skip_lcd_off = false; @@ -416,9 +520,11 @@ static int process_power_key(struct input_event *pinput) longkey_timeout_id = g_timeout_add_seconds( display_conf.longpress_interval, longkey_pressed_cb, NULL); + /* add long key restore timer */ + longkey_restore_id = g_timeout_add_seconds( + LONGKEY_PRESSED_TIME, + longkey_restore_cb, NULL); } - if (skip_lcd_off) - ignore = false; cancel_lcdoff = 0; break; @@ -479,10 +585,12 @@ static void process_hardkey_backlight(struct input_event *pinput) _I("Touch is pressed, then hard key is not working!"); return; } + if (!wearable_mode()) { /* Sound & Vibrate only in unlock state */ if (__get_lock_screen_state() == VCONFKEY_IDLE_UNLOCK || get_lock_screen_bg_state()) sound_vibrate_hardkey(); + } if (touchled && touchled->execute) { opt = TOUCHLED_PRESS; @@ -502,6 +610,23 @@ static void process_hardkey_backlight(struct input_event *pinput) } } +static void update_vital_state(struct input_event *pinput) +{ + int type; + + /* Change vital state to VITAL_EXIT only if vital mode is active */ + if (!vital_mode()) + return; + + /* Touch or Menu Key Release Event */ + if (pinput->type == EV_ABS || (pinput->type == EV_KEY && + pinput->value == KEY_RELEASED && pinput->code == KEY_MENU)) { + /* Enable all services upon receiving user input, else maintain same state */ + type = VITAL_EXIT; + device_notify(DEVICE_NOTIFIER_VITAL_STATE, &type); + } +} + static int check_key(struct input_event *pinput, int fd) { int ignore = true; @@ -520,6 +645,13 @@ static int check_key(struct input_event *pinput, int fd) ignore = process_screenlock_key(pinput); break; case KEY_BACK: + ignore = process_back_key(pinput); + stop_key_combination(NULL); + if (current_state_in_on()) { + process_hardkey_backlight(pinput); + ignore = false; + } + break; case KEY_PHONE: stop_key_combination(NULL); if (current_state_in_on()) { @@ -529,6 +661,9 @@ static int check_key(struct input_event *pinput, int fd) break; case KEY_VOLUMEUP: case KEY_VOLUMEDOWN: + if (current_state_in_on()) + ignore = false; + break; case KEY_CAMERA: case KEY_EXIT: case KEY_CONFIG: @@ -594,34 +729,36 @@ static int check_key_filter(void *data, int fd) code = pinput->code; value = pinput->value; + update_vital_state(pinput); ignore = check_key(pinput, fd); restore_custom_brightness(); break; case EV_REL: - ignore = false; + if (pm_cur_state == S_LCDOFF && bezel_wakeup) { + switch_on_lcd(LCD_ON_BY_BEZEL); + ignore = false; + } else if (pm_cur_state != S_LCDOFF) + ignore = false; break; case EV_ABS: - if (current_state_in_on()) + update_vital_state(pinput); + if (pinput->value == KEY_PRESSED) { + switch_on_lcd(LCD_ON_BY_TOUCH); ignore = false; + } - if (ambient_get_condition() == true) { - switch_on_lcd(); + if (current_state_in_on()) ignore = false; - } restore_custom_brightness(); - touch_pressed = - (pinput->value == TOUCH_RELEASE ? false : true); + if (pinput->value == KEY_PRESSED) + touch_pressed = true; + else if (pinput->value == KEY_RELEASED) + touch_pressed = false; break; case EV_SW: - if (!get_glove_state || !switch_glove_key) - break; - if (pinput->code == SW_GLOVE && - get_glove_state() == GLOVE_MODE) { - switch_glove_key(pinput->value); - } break; } @@ -631,6 +768,20 @@ static int check_key_filter(void *data, int fd) return 0; } +static int booting_done_cb(void *data) +{ + booting_check = 0; + + return 0; +} + +static int bezel_wakeup_cb(void *data) +{ + bezel_wakeup = (int)data; + + return 0; +} + /* * Default capability * powerkey := LCDON | LCDOFF | POWEROFF @@ -655,12 +806,8 @@ static void keyfilter_init(void) touchled = find_device(TOUCHLED_NAME); - register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); -} - -static void keyfilter_exit(void) -{ - unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb); + register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb); } static void key_backlight_enable(bool enable) @@ -680,7 +827,6 @@ static void key_backlight_enable(bool enable) static const struct display_keyfilter_ops normal_keyfilter_ops = { .init = keyfilter_init, - .exit = keyfilter_exit, .check = check_key_filter, .set_powerkey_ignore = NULL, .powerkey_lcdoff = NULL, diff --git a/plugins/mobile/display/proximity.c b/plugins/mobile/display/proximity.c new file mode 100644 index 0000000..7c04036 --- /dev/null +++ b/plugins/mobile/display/proximity.c @@ -0,0 +1,47 @@ +/* + * deviced + * + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "display/core.h" +#include "shared/log-macro.h" + +#include "proximity.h" + +static int proximity_state = SENSOR_PROXIMITY_NONE; + +int set_proximity_state(int val) +{ + switch (val) { + case SENSOR_PROXIMITY_NONE: + case SENSOR_PROXIMITY_NEAR: + case SENSOR_PROXIMITY_FAR: + break; + default: + _E("Invailed proximity value(%d)", val); + return -1; + } + + _D("set proximity value(%d)", val); + proximity_state = val; + return 0; +} + +int get_proximity_state(void) +{ + return proximity_state; +} + diff --git a/plugins/mobile/display/proximity.h b/plugins/mobile/display/proximity.h new file mode 100644 index 0000000..bbe5509 --- /dev/null +++ b/plugins/mobile/display/proximity.h @@ -0,0 +1,35 @@ +/* + * deviced + * + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @file proximity.h + * @brief proximity header file + */ +#ifndef __PROXIMITY_H__ +#define __PROXIMITY_H__ + +/* + * @brief define proximity state + */ +#define SENSOR_PROXIMITY_NONE -1 +#define SENSOR_PROXIMITY_NEAR 0 +#define SENSOR_PROXIMITY_FAR 5 + +int get_proximity_state(void); +#endif diff --git a/plugins/tv/display/core.c b/plugins/tv/display/core.c index 79bd919..dbd6954 100644 --- a/plugins/tv/display/core.c +++ b/plugins/tv/display/core.c @@ -35,10 +35,9 @@ #include #include #include +#include #include #include -#include -#include #include "ambient-mode.h" #include "util.h" @@ -53,13 +52,13 @@ #include "core/common.h" #include "core/config-parser.h" #include "core/launch.h" +#include "apps/apps.h" #include "extcon/extcon.h" +#include "battery/power-supply.h" #include "power/power-handler.h" #include "dd-display.h" #include "display/display-dpms.h" -#include "battery/battery.h" -#define PM_STATE_LOG_FILE tzplatform_mkpath(TZ_SYS_ALLLOGS, "pm_state.log") #define DISPLAY_CONF_FILE "/etc/deviced/display.conf" /** @@ -70,20 +69,28 @@ #define SET_BRIGHTNESS_IN_BOOTLOADER "/usr/bin/save_blenv SLP_LCD_BRIGHT" #define LOCK_SCREEN_INPUT_TIMEOUT 10000 #define LOCK_SCREEN_CONTROL_TIMEOUT 5000 -#define DD_LCDOFF_INPUT_TIMEOUT 3000 -#define ALWAYS_ON_TIMEOUT 3600000 //3600000 = 1 hour +#define ALWAYS_ON_TIMEOUT 3600000 +#define LATE_LCD_TRANSIT 1 + +#define PID_MAX 6 #define GESTURE_STR "gesture" #define POWER_KEY_STR "powerkey" #define TOUCH_STR "touch" #define EVENT_STR "event" #define TIMEOUT_STR "timeout" +#define PROXI_STR "proximity" +#define PALM_STR "palm" #define UNKNOWN_STR "unknown" -extern void state_tv_init(); -extern void state_tv_deinit(); +#define METHOD_APP_STATUS "CheckAppStatus" + +#define PM_WAKEUP 0 +#define PM_SUSPEND 1 + extern void init_pm_internal(); extern int get_charging_status(int *val); +extern void init_save_userlock(void); unsigned int pm_status_flag; static int trans_condition; @@ -94,6 +101,7 @@ static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT; int pm_cur_state; int pm_old_state; guint timeout_src_id; +int system_wakeup_flag = false; static unsigned int custom_normal_timeout = 0; static unsigned int custom_dim_timeout = 0; static int custom_holdkey_block = false; @@ -101,13 +109,21 @@ static int custom_change_pid = -1; static char *custom_change_name; static bool hallic_open = true; static guint lock_timeout_id; +static guint transit_timer; static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT; +static long displayoff_time; static struct timeval lcdon_tv; static int lcd_paneloff_mode = false; static int stay_touchscreen_off = false; +dd_list *lcdon_ops; +/* + * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial + * state because it should be sent from previous state at booting time. + */ static bool lcdon_broadcast = true; +static int pmstate_suspend = PM_SUSPEND; + static bool touch_blocked = false; -dd_list *lcdon_ops; /* default transition, action fuctions */ static int default_trans(int evt); @@ -118,6 +134,10 @@ static gboolean del_normal_cond(void *data); static gboolean del_dim_cond(void *data); static gboolean del_off_cond(void *data); +static gboolean pmlock_normal_check(void *data); +static gboolean pmlock_dim_check(void *data); +static gboolean pmlock_off_check(void *data); + static int default_proc_change_state(unsigned int cond, pid_t pid); static int (*proc_change_state)(unsigned int cond, pid_t pid) = default_proc_change_state; @@ -142,6 +162,10 @@ static int trans_table[S_END][EVENT_END] = { { S_POWEROFF, S_POWEROFF }, /* S_POWEROFF */ }; +static GSourceFunc warning_cb[S_END] = { + NULL, pmlock_normal_check, pmlock_dim_check, pmlock_off_check, +}; + enum signal_type { SIGNAL_INVALID = 0, SIGNAL_PRE, @@ -149,6 +173,11 @@ enum signal_type { SIGNAL_MAX, }; +enum platform_control { + PLATFORM_DISPLAY_OFF, + PLATFORM_DISPLAY_ON, +}; + static const char *lcdon_sig_lookup[SIGNAL_MAX] = { [SIGNAL_PRE] = "LCDOn", [SIGNAL_POST] = "LCDOnCompleted", @@ -180,7 +209,7 @@ static const char *lcdoff_sig_lookup[SIGNAL_MAX] = { #define LONG_PRESS_INTERVAL 2 /* 2 seconds */ #define SAMPLING_INTERVAL 1 /* 1 sec */ #define BRIGHTNESS_CHANGE_STEP 10 -#define LCD_ALWAYS_ON 1 +#define LCD_ALWAYS_ON 0 #define ACCEL_SENSOR_ON 1 #define CONTINUOUS_SAMPLING 1 #define LCDOFF_TIMEOUT 500 /* milli second */ @@ -197,13 +226,18 @@ struct display_config display_conf = { .lcdoff_timeout = LCDOFF_TIMEOUT, .brightness_change_step = BRIGHTNESS_CHANGE_STEP, .lcd_always_on = LCD_ALWAYS_ON, - .framerate_app = {1, 0, 0, 0}, - .control_display = 1, + .dimming = 1, + .framerate_app = {0, 0, 0, 0}, + .control_display = 0, .powerkey_doublepress = 0, .accel_sensor_on = ACCEL_SENSOR_ON, .continuous_sampling = CONTINUOUS_SAMPLING, - .timeout_enable = false, + .timeout_enable = true, .input_support = true, + .lockcheck_timeout = 600, + .aod_enter_level = 40, + .aod_tsp = true, + .touch_wakeup = false, }; struct display_function_info display_info = { @@ -216,9 +250,11 @@ struct display_function_info display_info = { typedef struct _pm_lock_node { pid_t pid; guint timeout_id; + guint warning_id; time_t time; bool holdkey_block; bool background; + bool broadcast_warning; } PmLockNode; static dd_list *cond_head[S_END]; @@ -233,9 +269,9 @@ static void set_process_active(bool flag, pid_t pid) /* Send dbug to resourced */ ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -289,17 +325,64 @@ void change_proc_change_state(int (*func)(unsigned int cond, pid_t pid)) proc_change_state = func; } +static inline long clock_gettime_to_long(void) +{ + struct timespec now; + int ret; + + ret = clock_gettime(CLOCK_REALTIME, &now); + + if (ret < 0) { + _E("Failed to clock gettime!"); + return 0; + } + + return SEC_TO_MSEC(now.tv_sec) + NSEC_TO_MSEC(now.tv_nsec); +} + +static int display_brightness_changed(void *data) +{ + int brt, ret; + + brt = DATA_VALUE_INT(data); + + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "Brightness", + g_variant_new("(i)", brt)); + if (ret < 0) + _E("Failed to send dbus signal Brightness."); + + return 0; +} + +static int display_auto_brightness_sensing(void *data) +{ + if (!transit_timer) + return 0; + + g_source_remove(transit_timer); + transit_timer = 0; + + return 0; +} + static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) { const char *str; const char *signal; int ret; + long diff = 0; if (type <= SIGNAL_INVALID || type >= SIGNAL_MAX) { _E("Invalid signal type(%d).", type); return; } + if (type == SIGNAL_PRE && displayoff_time != 0) + diff = clock_gettime_to_long() - displayoff_time; + if (flags & LCD_ON_BY_GESTURE) str = GESTURE_STR; else if (flags & LCD_ON_BY_POWER_KEY) @@ -317,7 +400,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, - g_variant_new("(s)", str)); + g_variant_new("(si)", str, diff)); if (ret < 0) _E("Failed to send dbus signal(%s)", signal); } @@ -333,6 +416,9 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) return; } + if (type == SIGNAL_PRE) + displayoff_time = clock_gettime_to_long(); + signal = lcdoff_sig_lookup[type]; if (flags & LCD_OFF_BY_POWER_KEY) @@ -371,9 +457,6 @@ static unsigned long get_lcd_on_flags(void) if (lcd_paneloff_mode) flags |= LCD_PANEL_OFF_MODE; - if (stay_touchscreen_off) - flags |= TOUCH_SCREEN_OFF_MODE; - if (ambient_get_condition() == true) { flags |= AMBIENT_MODE; flags |= LCD_PHASED_TRANSIT_MODE; @@ -387,6 +470,18 @@ bool touch_event_blocked(void) return touch_blocked; } +static gboolean late_transit_on(void *data) +{ + if (!transit_timer) + return G_SOURCE_REMOVE; + + g_source_remove(transit_timer); + transit_timer = 0; + + backlight_ops.transit_state(DPMS_ON); + return G_SOURCE_REMOVE; +} + void lcd_on_procedure(int state, enum device_flags flag) { dd_list *l = NULL; @@ -394,19 +489,29 @@ void lcd_on_procedure(int state, enum device_flags flag) unsigned long flags = get_lcd_on_flags(); flags |= flag; - /* send LCDOn dbus signal */ - if (!lcdon_broadcast) { - broadcast_lcd_on(SIGNAL_PRE, flags); - lcdon_broadcast = true; - } + /* + * Display on procedure + * step 1. broadcast lcd on signal with cause + * step 2. set brightness + * step 3. set pmstate of vconf + * step 4. display on operate + * - a. display on + * - b. TSP(touch screen) and touchkey enable + * step 5. broadcast lcd on complete siganl + * step 6. key backlight enable + */ + _I("[lcdstep] %lu", flags); if (flags & AMBIENT_MODE) { - if (ambient_get_state() == false && - backlight_ops.get_lcd_power() == DPMS_ON) + if (ambient_get_state() == false && backlight_ops.get_lcd_power() == DPMS_ON) return; ambient_set_state(false); } + /* send LCDOn dbus signal */ + if (!lcdon_broadcast) + broadcast_lcd_on(SIGNAL_PRE, flags); + if (!(flags & LCD_PHASED_TRANSIT_MODE)) { /* Update brightness level */ if (state == LCD_DIM) @@ -423,7 +528,13 @@ void lcd_on_procedure(int state, enum device_flags flag) DD_LIST_FOREACH(lcdon_ops, l, ops) ops->start(flags); + if (!lcdon_broadcast) { broadcast_lcd_on(SIGNAL_POST, flags); + if (flags & LCD_PHASED_TRANSIT_MODE) + transit_timer = g_timeout_add_seconds(LATE_LCD_TRANSIT, + late_transit_on, NULL); + lcdon_broadcast = true; + } if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(true); @@ -431,7 +542,7 @@ void lcd_on_procedure(int state, enum device_flags flag) touch_blocked = false; } -static inline unsigned long get_lcd_off_flags(void) +static unsigned long get_lcd_off_flags(void) { unsigned long flags = NORMAL_MODE; @@ -440,10 +551,12 @@ static inline unsigned long get_lcd_off_flags(void) flags |= LCD_PHASED_TRANSIT_MODE; } + if (stay_touchscreen_off) + flags |= TOUCH_SCREEN_OFF_MODE; + return flags; } - inline void lcd_off_procedure(enum device_flags flag) { dd_list *l = NULL; @@ -451,6 +564,20 @@ inline void lcd_off_procedure(enum device_flags flag) unsigned long flags = get_lcd_off_flags(); flags |= flag; + /* + * Display off procedure + * step 0. enhance mode off using nofity (e.g mdnie, HBM, LBM) + * step 1. broadcast lcd off signal with cause + * step 2. set pmstate of vconf + * step 3. display off operate + * - a. display off + * - b. TSP(touch screen) and touchkey disable + * step 4. broadcast lcd off complete siganl + */ + _I("[lcdstep] %lu", flags); + + device_notify(DEVICE_NOTIFIER_LCD_OFF, NULL); + touch_blocked = true; if (flags & AMBIENT_MODE) { @@ -463,18 +590,23 @@ inline void lcd_off_procedure(enum device_flags flag) broadcast_lcd_off(SIGNAL_PRE, flags); lcdon_broadcast = false; } + set_setting_pmstate(S_LCDOFF); + if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(false); - set_setting_pmstate(S_LCDOFF); + if (transit_timer) { + g_source_remove(transit_timer); + transit_timer = 0; + } + + if (flags & LCD_PHASED_TRANSIT_MODE) + backlight_ops.transit_state(DPMS_OFF); DD_LIST_FOREACH(lcdon_ops, l, ops) ops->stop(flags); if (flags & AMBIENT_MODE) - /* Do not broadcast the post signal here. - * The signal will be broadcasted - * after showing Ambient clock */ broadcast_lcd_off_late(flags); else broadcast_lcd_off(SIGNAL_POST, flags); @@ -482,20 +614,20 @@ inline void lcd_off_procedure(enum device_flags flag) void set_stay_touchscreen_off(int val) { - _D("stay touch screen off: %d", val); + _I("Stay touch screen off: %d", val); stay_touchscreen_off = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } void set_lcd_paneloff_mode(int val) { - _D("lcd paneloff mode: %d", val); + _I("Lcd paneloff mode: %d", val); lcd_paneloff_mode = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } int low_battery_state(int val) @@ -539,7 +671,7 @@ static void makeup_trans_condition(void) static PmLockNode *find_node(enum state_t s_index, pid_t pid) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; DD_LIST_FOREACH(cond_head[s_index], elem, t) { if (t->pid == pid) @@ -552,21 +684,28 @@ static PmLockNode *find_node(enum state_t s_index, pid_t pid) static PmLockNode *add_node(enum state_t s_index, pid_t pid, guint timeout_id, bool holdkey_block) { + guint warning_id = 0; PmLockNode *n; time_t now; n = (PmLockNode *) malloc(sizeof(PmLockNode)); if (n == NULL) { - _E("Failed to add cond. Not enough memory."); + _E("Not enough memory, add cond. fail"); return NULL; } + if (pid < INTERNAL_LOCK_BASE) + warning_id = g_timeout_add_seconds(display_conf.lightsensor_interval, + warning_cb[s_index], (void *)((intptr_t)pid)); + time(&now); n->pid = pid; n->timeout_id = timeout_id; + n->warning_id = warning_id; n->time = now; n->holdkey_block = holdkey_block; n->background = false; + n->broadcast_warning = true; DD_LIST_APPEND(cond_head[s_index], n); refresh_app_cond(); @@ -585,6 +724,11 @@ static int del_node(enum state_t s_index, PmLockNode *n) g_source_remove(n->timeout_id); n->timeout_id = 0; } + if (n->warning_id) { + g_source_remove(n->warning_id); + n->warning_id = 0; + } + free(n); refresh_app_cond(); return 0; @@ -592,6 +736,7 @@ static int del_node(enum state_t s_index, PmLockNode *n) static void print_node(int next) { + int ret; dd_list *elem; PmLockNode *n; char buf[30]; @@ -606,10 +751,20 @@ static void print_node(int next) diff = difftime(now, n->time); ctime_r(&n->time, buf); - if (diff > LOCK_TIME_WARNING) - _W("over=%.0f s pid=%5d locktime=%s", diff, n->pid, buf); - else - _I("pid=%5d locktime=%s", n->pid, buf); + if (diff > LOCK_TIME_WARNING) { + if (diff > LOCK_TIME_WARNING * 60 && n->pid < INTERNAL_LOCK_BASE && n->broadcast_warning) { + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_over", + g_variant_new("(i)", n->pid)); + if (ret < 0) + _E("Failed to send dbus signal pmlock_over."); + n->broadcast_warning = false; + } + _W("Over(%.0f s) pid( %5d) lock time(%s)", diff, n->pid, buf); + } else + _I("Pid(%5d) lock time(%s)", n->pid, buf); } } @@ -642,7 +797,6 @@ void get_pname(pid_t pid, char *pname) static void del_state_cond(void *data, enum state_t state) { PmLockNode *tmp = NULL; - char pname[PATH_MAX]; pid_t pid; if (!data) @@ -650,18 +804,20 @@ static void del_state_cond(void *data, enum state_t state) /* A passed data is a pid_t type data, not a 64bit data. */ pid = (pid_t)((intptr_t)data); - _I("Delete process(%d)'s prohibit dim condition by timeout.", pid); + _I("delete prohibit dim condition by timeout (%d)", pid); + + if (pid == INTERNAL_LOCK_AMBIENT) + ambient_check_invalid_state(pid); tmp = find_node(state, pid); del_node(state, tmp); - get_pname(pid, pname); - set_unlock_time(pname, state); + set_unlock_time(pid, state); if (!timeout_src_id) states[pm_cur_state].trans(EVENT_TIMEOUT); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); } static gboolean del_normal_cond(void *data) @@ -682,23 +838,91 @@ static gboolean del_off_cond(void *data) return G_SOURCE_REMOVE; } -/* timeout handler */ -gboolean timeout_handler(void *data) +static void pmlock_check_cb(GVariant *var, void *user_data, GError *err) { - int run_timeout; + pid_t pid; + int ret, state; + char *app_id; - _I("Time out state %s.\n", states[pm_cur_state].name); - /* default setting */ - get_run_timeout(&run_timeout); + if (!var) + return; - /* for sdk - * if the run_timeout is zero, it regards AlwaysOn state + if (!dh_get_param_from_var(var, "(iis)", &pid, &state, &app_id)) { + _E("Failed to notify low: no message(%s)", g_variant_get_type_string(var)); + goto out; + } + + _W("%s(%d) was requested pmlock for a long time.", app_id, pid); + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_expired", + g_variant_new("(i)", pid)); + if (ret < 0) + _E("Failed to send dbus pmlock_expired"); + +out: + g_variant_unref(var); +} + +/* + * Any process is possible many time lock, deviced can not know malicious + * or good process. so infinity or more then 1 min lock process, deviced + * will be checked it to resoured. And then, it will be asked quit or maintain to user. */ - if (pm_cur_state == S_NORMAL && (run_timeout == 0 || display_conf.lcd_always_on)) { - _D("'run_timeout' is always on."); - return G_SOURCE_CONTINUE; +static void pmlock_check(void *data, char *st) +{ + const char *arr[2]; + char chr_pid[PID_MAX]; + pid_t pid; + int ret; + + if (!data || !st) + return; + + if (!strncmp(st, "lcdoff", 4) && backlight_ops.get_lcd_power() == DPMS_ON) { + _D("Lcd state is PM_LCD_POWER_ON"); + return; } + pid = (pid_t)((intptr_t)data); + snprintf(chr_pid, sizeof(chr_pid), "%d", pid); + + arr[0] = chr_pid; + arr[1] = st; + + ret = dbus_handle_method_async_with_reply(RESOURCED_BUS_NAME, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + METHOD_APP_STATUS, + "is", arr, pmlock_check_cb, -1, NULL); + if (ret < 0) + _E("Failed to call dbus method"); +} + +static gboolean pmlock_normal_check(void *data) +{ + pmlock_check(data, "normal"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_dim_check(void *data) +{ + pmlock_check(data, "lcddim"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_off_check(void *data) +{ + pmlock_check(data, "lcdoff"); + return G_SOURCE_CONTINUE; +} + +/* timeout handler */ +gboolean timeout_handler(void *data) +{ + _I("Time out state %s", states[pm_cur_state].name); + if (timeout_src_id) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -713,7 +937,7 @@ void reset_timeout(int timeout) if (!display_conf.timeout_enable) return; - _I("Reset timeout(%d ms)", timeout); + _I("Reset timeout(%d ms).", timeout); if (timeout_src_id != 0) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -754,7 +978,7 @@ static int get_lcd_timeout_from_settings(void) if (val > 0) states[i].timeout = val; - _I("state=%s timeout=%d ms", states[i].name, + _I("State(%s) timeout(%d) ms", states[i].name, states[i].timeout); } @@ -777,7 +1001,7 @@ static void update_display_time(void) if (custom_normal_timeout > 0) { states[S_NORMAL].timeout = custom_normal_timeout; states[S_LCDDIM].timeout = custom_dim_timeout; - _I("CUSTOM: Timeout(%d ms) and dim(%d ms) are set by normal.", + _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)", custom_normal_timeout, custom_dim_timeout); return; } @@ -808,7 +1032,8 @@ static void update_display_time(void) get_dim_timeout(&val); states[S_LCDDIM].timeout = val; - _I("Normal: timeout(%d ms) and dim(%d ms) are set.", states[S_NORMAL].timeout, states[S_LCDDIM].timeout); + _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout); + _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout); } static void update_display_locktime(int time) @@ -817,7 +1042,6 @@ static void update_display_locktime(int time) update_display_time(); } - void set_dim_state(bool on) { _I("Dim state is %d.", on); @@ -825,31 +1049,58 @@ void set_dim_state(bool on) states[pm_cur_state].trans(EVENT_INPUT); } +static void broadcast_pm_suspend(void) +{ + int ret; + + if (pmstate_suspend) + return; -void lcd_on_direct(enum device_flags flags) + _D("PM will be changed to sleep."); + + pmstate_suspend = PM_SUSPEND; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "sleep", + NULL); + if (ret < 0) + _E("Failed to send dbus signal sleep."); +} + +static void broadcast_pm_wakeup(void) { - int ret, call_state; + int ret; + + if (!pmstate_suspend) + return; + + _D("PM is changed to wakeup."); + pmstate_suspend = PM_WAKEUP; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "wakeup", + NULL); + if (ret < 0) + _E("Failed to send dbus signal wakeup."); + +} + +void lcd_on_direct(enum device_flags flags) +{ if (power_ops.get_power_lock_support() - && pm_cur_state == S_SLEEP) + && pm_cur_state == S_SLEEP) { + broadcast_pm_wakeup(); power_ops.power_lock(); + pm_cur_state = S_NORMAL; + } -#ifdef MICRO_DD - _D("Lcd is on directly."); + _D("lcd is on directly"); gettimeofday(&lcdon_tv, NULL); lcd_on_procedure(LCD_NORMAL, flags); - reset_timeout(DD_LCDOFF_INPUT_TIMEOUT); -#else - ret = vconf_get_int(VCONFKEY_CALL_STATE, &call_state); - if ((ret >= 0 && call_state != VCONFKEY_CALL_OFF) || - (__get_lock_screen_state() == VCONFKEY_IDLE_LOCK)) { - _D("LOCK state, lcd is on directly."); - lcd_on_procedure(LCD_NORMAL, flags); - } else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - reset_timeout(display_conf.lcdoff_timeout); -#endif + update_display_locktime(LOCK_SCREEN_INPUT_TIMEOUT); } @@ -861,6 +1112,41 @@ static inline bool check_lcd_is_on(void) return true; } +static int check_lock_condition(enum state_t state) +{ + dd_list *elem; + PmLockNode *t = NULL; + int ret = false; + pid_t owner = getpid(); + + _D("check holdkey block : state of %s", states[state].name); + + DD_LIST_FOREACH(cond_head[state], elem, t) { + if (t->pid != owner && t->background == false) { + ret = true; + _I("state change was blocked by pid(%d)!", t->pid); + break; + } + } + + return ret; +} + +static gboolean timer_refresh_cb(gpointer data) +{ + struct state *st; + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + if (st->action) + st->action(st->timeout); + + return 0; +} + int custom_lcdon(int timeout) { struct state *st; @@ -884,9 +1170,157 @@ int custom_lcdon(int timeout) if (st->action) st->action(st->timeout); + g_idle_add(timer_refresh_cb, NULL); + return 0; } +int custom_lcdoff(enum device_flags flag) +{ + struct state *st; + + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + /* + * When another proccess is normal lock, device is received call then, + * call app can be changed to lcd state by proximity. + * If proximity is near then normal lock will be unlocked. + */ + if (flag & LCD_OFF_BY_PROXIMITY) { + _I("custom lcd off by proximity, delete normal lock"); + delete_condition(S_NORMAL); + } else { + _I("skip custom lcd off"); + return -ECANCELED; + } + } + + _I("custom lcd off by flag(%d)", flag); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + if (set_custom_lcdon_timeout(0) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_on(char *reason, int timeout) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) + flag = LCD_ON_BY_GESTURE; + else if (!strncmp(reason, EVENT_STR, str_len)) + flag = LCD_ON_BY_EVENT; + else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + if (timeout <= 0) { + _E("Cannot setting timeout %d", timeout); + return -EINVAL; + } + + if (check_lcd_is_on() == false) + lcd_on_direct(flag); + + _I("platform lcd on by %s (%d ms)", reason, timeout); + if (set_custom_lcdon_timeout(timeout) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_off(char *reason) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) { + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + _I("skip platform lcd off by gesture"); + return -ECANCELED; + } + flag = LCD_OFF_BY_GESTURE; + } else if (!strncmp(reason, PALM_STR, str_len)) { + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); + + flag = LCD_OFF_BY_PALM; + } else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + _I("platform lcd off by %s", reason); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +int display_platform_control(int type, char *reason, int timeout) +{ + int ret; + + switch (type) { + case PLATFORM_DISPLAY_ON: + ret = display_platform_on(reason, timeout); + break; + case PLATFORM_DISPLAY_OFF: + ret = display_platform_off(reason); + break; + default: + _E("Unkown type(%d)", type); + ret = -EINVAL; + } + + return ret; +} + static void default_proc_change_state_action(enum state_t next, int timeout) { struct state *st; @@ -922,7 +1356,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) default_proc_change_state_action(next, -1); break; case S_LCDOFF: - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_EVENT); if (set_custom_lcdon_timeout(0)) update_display_time(); @@ -933,7 +1367,14 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) /* at first LCD_OFF and then goto sleep */ /* state transition */ default_proc_change_state_action(S_LCDOFF, TIMEOUT_NONE); + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); delete_condition(S_LCDOFF); + if (lcdon_broadcast) { + _I("broadcast lcd off signal at non-lcd device"); + broadcast_lcd_off(SIGNAL_PRE, 0); + broadcast_lcd_off(SIGNAL_POST, 0); + } default_proc_change_state_action(S_SLEEP, TIMEOUT_NONE); break; @@ -968,15 +1409,18 @@ static void proc_condition_lock(PMMsg *data) pid_t pid = data->pid; enum state_t state; int holdkey_block; + bool value = true; + unsigned int flags; state = GET_COND_STATE(data->cond); - if (!state) + if (state == S_START) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); - if (state == S_LCDOFF && - pm_cur_state == S_SLEEP) + if (state == S_LCDOFF && pm_cur_state == S_SLEEP && + power_ops.get_power_lock() == POWER_UNLOCK) proc_change_state(data->cond, INTERNAL_LOCK_PM); if (data->timeout > 0) { @@ -1002,14 +1446,15 @@ static void proc_condition_lock(PMMsg *data) } if (state == S_LCDOFF) - set_process_active(TRUE, pid); + set_process_active(true, pid); + _I("[%s] locked by %5d with %u ms", states[state].name, pid, data->timeout); /* for debug */ - _SD("[%s] Locked by pid=%d process=%s holdkeyblock=%d\n", - states[state].name, pid, pname, holdkey_block); - set_lock_time(pname, state); + _SD("be requested LOCK info pname(%s), holdkeyblock(%d) flags(%d)", + pname, holdkey_block, flags); + set_lock_time(pid, pname, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)true); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static void proc_condition_unlock(PMMsg *data) @@ -1018,27 +1463,28 @@ static void proc_condition_unlock(PMMsg *data) enum state_t state; PmLockNode *tmp; char pname[PATH_MAX]; + bool value = false; + unsigned int flags; state = GET_COND_STATE(data->cond); if (!state) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); tmp = find_node(state, pid); del_node(state, tmp); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); - if (ambient_get_state()) - ambient_check_invalid_state(pid); - - _SD("[%s] Unlocked by pid=%d process=%s\n", - states[state].name, pid, pname); - set_unlock_time(pname, state); + _I("[%s] unlocked by %5d", states[state].name, pid); + /* for debug */ + _SD("be requested UNLOCK info pname(%s) flag(%d)", pname, flags); + set_unlock_time(pid, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)false); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static int proc_condition(PMMsg *data) @@ -1057,15 +1503,11 @@ static int proc_condition(PMMsg *data) flags = GET_COND_FLAG(data->cond); if (flags == 0) { /* guard time for suspend */ - if (pm_cur_state == S_LCDOFF) { + if (pm_cur_state == S_LCDOFF) reset_timeout(states[S_LCDOFF].timeout); - _I("Margin timeout(%d ms)", states[S_LCDOFF].timeout); - } } else { - if (flags & PM_FLAG_RESET_TIMER) { + if (flags & PM_FLAG_RESET_TIMER) reset_timeout(states[pm_cur_state].timeout); - _I("Reset timeout(%d ms)", states[pm_cur_state].timeout); - } } if (!timeout_src_id) @@ -1078,13 +1520,13 @@ static int proc_condition(PMMsg *data) int check_processes(enum state_t prohibit_state) { dd_list *elem, *next; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; DD_LIST_FOREACH_SAFE(cond_head[prohibit_state], elem, next, t) { if (t->pid < INTERNAL_LOCK_BASE && kill(t->pid, 0) == -1) { - _E("Process(%d) does not exist, delete the REQ" - " - prohibit state=%d.", + _E("%d process does not exist, delete the REQ" + " - prohibit state %d ", t->pid, prohibit_state); if (t->pid == custom_change_pid) { get_lcd_timeout_from_settings(); @@ -1092,6 +1534,7 @@ int check_processes(enum state_t prohibit_state) custom_change_pid = -1; } ret = 1; + set_unlock_time(t->pid, prohibit_state); del_node(prohibit_state, t); } } @@ -1102,7 +1545,7 @@ int check_processes(enum state_t prohibit_state) int check_holdkey_block(enum state_t state) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; _I("Check holdkey block: state of %s", states[state].name); @@ -1127,11 +1570,9 @@ int check_holdkey_block(enum state_t state) int delete_condition(enum state_t state) { dd_list *elem, *next; - PmLockNode *t; - pid_t pid; - char pname[PATH_MAX]; + PmLockNode *t = NULL; - _I("Delete condition: state of %s", states[state].name); + _I("delete condition : state of %s", states[state].name); if (!cond_head[state]) return 0; @@ -1141,13 +1582,11 @@ int delete_condition(enum state_t state) g_source_remove(t->timeout_id); t->timeout_id = 0; } - pid = t->pid; if (state == S_LCDOFF) - set_process_active(FALSE, pid); - _I("Delete node of pid(%d).", pid); + set_process_active(false, t->pid); + _I("delete node of pid(%d)", t->pid); + set_unlock_time(t->pid, state); del_node(state, t); - get_pname(pid, pname); - set_unlock_time(pname, state-1); } DD_LIST_FREE_LIST(cond_head[state]); @@ -1189,8 +1628,9 @@ static pm_history pm_history_log[MAX_LOG_COUNT] = {{0, }, }; static int history_count = 0; static const char history_string[PM_LOG_MAX][15] = { - "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON FAIL", - "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF FAIL", "SLEEP"}; + "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON COMPL", "LCD ON FAIL", + "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF COMPL", "LCD OFF FAIL", + "LCD FAIL", "SLEEP"}; void pm_history_init() { @@ -1243,7 +1683,7 @@ void pm_history_print(int fd, int count) time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } #endif @@ -1267,13 +1707,13 @@ void print_info(int fd) "===========================\n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Timeout Info: Run[%dms] Dim[%dms] Off[%dms]\n", states[S_NORMAL].timeout, states[S_LCDDIM].timeout, states[S_LCDOFF].timeout); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Tran. Locked : %s %s %s\n", (trans_condition & MASK_NORMAL) ? states[S_NORMAL].name : "-", @@ -1281,18 +1721,18 @@ void print_info(int fd) (trans_condition & MASK_OFF) ? states[S_LCDOFF].name : "-"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current State: %s\n", states[pm_cur_state].name); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current Lock Conditions: \n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); for (s_index = S_NORMAL; s_index < S_END; s_index++) { DD_LIST_FOREACH(cond_head[s_index], elem, t) { @@ -1303,7 +1743,7 @@ void print_info(int fd) i++, states[s_index].name, t->pid, pname, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } @@ -1314,37 +1754,39 @@ void print_info(int fd) #endif } -void save_display_log(void) +void save_display_log(char *path) { int fd, ret; char buf[255]; time_t now_time; char time_buf[30]; - _D("Internal state is saved."); + _D("internal state is saved!"); time(&now_time); ctime_r(&now_time, time_buf); - fd = open(PM_STATE_LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, 0644); + fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0644); if (fd != -1) { snprintf(buf, sizeof(buf), "\npm_state_log now-time : %d(s) %s\n\n", (int)now_time, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); snprintf(buf, sizeof(buf), "pm_status_flag: %x\n", pm_status_flag); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); - snprintf(buf, sizeof(buf), "screen lock status : %d\n", - __get_lock_screen_state()); - ret = write(fd, buf, strlen(buf)); - if (ret < 0) - _E("write() failed: %d", errno); + if (disp_plgn.get_lock_screen_state ) { + snprintf(buf, sizeof(buf), "screen lock status : %d\n", + disp_plgn.get_lock_screen_state()); + ret = write(fd, buf, strlen(buf)); + if (ret < 0) + _E("write() failed (%d)", errno); + } print_info(fd); close(fd); } @@ -1361,7 +1803,9 @@ void save_display_log(void) */ static void sig_hup(int signo) { - save_display_log(); + _I("received sig hub %d", signo); + + pm_save_logdump(); } int check_lcdoff_direct(void) @@ -1375,6 +1819,9 @@ int check_lcdoff_direct(void) if (pm_cur_state != S_LCDDIM) return false; + if (!display_conf.dimming) + return true; + lock = __get_lock_screen_state(); if (lock != VCONFKEY_IDLE_LOCK && hallic_open) return false; @@ -1389,7 +1836,7 @@ int check_lcdoff_direct(void) else if (ret < 0) _E("Failed to get vconf value for cradle status: %d", vconf_get_ext_errno()); - _D("Goto LCDOFF direct(lock=%d hdmi=%d cradle=%d).", lock, hdmi_state, cradle); + _D("Goto LCDOFF direct: lock(%d) hdmi(%d) cradle(%d).", lock, hdmi_state, cradle); return true; } @@ -1483,22 +1930,10 @@ static inline void stop_lock_timer(void) static void check_lock_screen(void) { - int lock_setting, lock_state, app_state, ret; + int lock_state, ret; stop_lock_timer(); - ret = vconf_get_int(VCONFKEY_CALL_STATE, &app_state); - if (ret >= 0 && app_state != VCONFKEY_CALL_OFF) - goto lcd_on; - else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - /* check setting of lock screen is enabled. */ - ret = vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, - &lock_setting); - if (ret < 0) - _E("Failed to get vconf value for screen lock type: %d", vconf_get_ext_errno()); - /* check state of lock */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); if (ret < 0 || lock_state == VCONFKEY_IDLE_LOCK) { @@ -1553,10 +1988,12 @@ static int default_action(int timeout) } if (pm_cur_state != pm_old_state && pm_cur_state != S_SLEEP) { - if (power_ops.get_power_lock_support()) + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); power_ops.power_lock(); + } set_setting_pmstate(pm_cur_state); - device_notify(DEVICE_NOTIFIER_LCD, &pm_cur_state); + device_notify(DEVICE_NOTIFIER_LCD, (void *)&pm_cur_state); } if (pm_old_state == S_NORMAL && pm_cur_state != S_NORMAL) { @@ -1596,11 +2033,11 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) { stop_lock_timer(); /* lcd off state : turn off the backlight */ - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); } - if (backlight_ops.get_lcd_power() != DPMS_OFF + if (backlight_ops.get_lcd_power() == DPMS_ON || lcd_paneloff_mode) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); break; @@ -1609,7 +2046,7 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) stop_lock_timer(); - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); if (!power_ops.get_power_lock_support()) { @@ -1636,6 +2073,7 @@ go_suspend: #ifdef ENABLE_PM_LOG pm_history_save(PM_LOG_SLEEP, pm_cur_state); #endif + broadcast_pm_suspend(); if (power_ops.get_power_lock_support()) { if (power_ops.enable_autosleep) power_ops.enable_autosleep(); @@ -1643,24 +2081,9 @@ go_suspend: if (power_ops.power_unlock() < 0) _E("Power unlock state error."); } else { - dd_list *elem, *elem_n; - const struct device_ops *dev; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } - power_ops.suspend(); - - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } - - _I("System wakeup."); - disp_plgn.system_wakeup_flag = true; + _I("system wakeup!!"); + system_wakeup_flag = true; /* Resume !! */ if (power_ops.check_wakeup_src() == EVENT_DEVICE) /* system waked up by devices */ @@ -1741,7 +2164,7 @@ static int poll_callback(int condition, PMMsg *data) if (condition == INPUT_POLL_EVENT) { if (pm_cur_state == S_LCDOFF || pm_cur_state == S_SLEEP) - _I("Power key input."); + _I("Input event signal at Display Off"); time(&now); if (last_t != now || pm_cur_state == S_LCDOFF || @@ -1802,11 +2225,13 @@ static int update_setting(int key_idx, int val) } pm_status_flag |= CHRGR_FLAG; } else { - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { power_saving_func(true); pm_status_flag |= LOWBT_FLAG; @@ -1879,9 +2304,9 @@ static void check_seed_status(void) { int ret = -1; int tmp = 0; - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; int brt = 0; - int lock_state = -1; + int lock_state; /* Charging check */ if ((get_charging_status(&tmp) == 0) && (tmp > 0)) @@ -1900,10 +2325,13 @@ static void check_seed_status(void) } _I("Set brightness(%d) from setting app.", tmp); backlight_ops.set_default_brt(tmp); + backlight_ops.set_brightness(tmp); ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { if (!(pm_status_flag & CHRGR_FLAG)) { power_saving_func(true); @@ -1913,9 +2341,10 @@ static void check_seed_status(void) /* lock screen check */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); - if (ret < 0) + if (ret < 0) { + lock_state = -1; _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno()); - + } set_lock_screen_state(lock_state); if (lock_state == VCONFKEY_IDLE_LOCK) { states[S_NORMAL].timeout = lock_screen_timeout; @@ -2045,36 +2474,20 @@ void reset_lcd_timeout(GDBusConnection *conn, static int booting_done(void *data) { - static int done; - - if (!data) - return done; + static bool done = false; + if (data != NULL) { done = *(int*)data; - if (!done) - return done; - - _I("Booting done. Release display and power lock."); - if (disp_plgn.pm_unlock_internal) { - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + if (done) + return 0; + _I("booting done, unlock LCD_OFF"); + if (disp_plgn.pm_unlock_internal) { + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); + } } - return done; -} - -int device_poweroff(void *data) -{ - static int off; - - if (!data) - return off; - - off = *(int *)data; - if (off) - _I("Poweroff"); - - return off; + return 0; } static int process_background(void *data) @@ -2087,7 +2500,7 @@ static int process_background(void *data) node = find_node(S_NORMAL, pid); if (node) { node->background = true; - _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); + _I("%d pid is background, then PM will be unlocked LCD_NORMAL", pid); } return 0; @@ -2103,9 +2516,29 @@ static int process_foreground(void *data) node = find_node(S_NORMAL, pid); if (node) { node->background = false; - _I("Process(%d) is foreground, then PM will be maintained locked LCD_NORMAL.", pid); + _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); + } + + return 0; +} + +static int battery_health_changed(void *data) +{ + int health = DATA_VALUE_INT(data); + + _I("battery health change %d", health); + + if (health == HEALTH_GOOD) { + pm_status_flag &= ~BATTERY_FLAG; + pm_status_flag &= ~DIMSTAY_FLAG; + } else if (health == HEALTH_LOW || health == HEALTH_HIGH || health == HEALTH_OVP) { + pm_status_flag |= BATTERY_FLAG; + pm_status_flag |= DIMSTAY_FLAG; } + if (backlight_ops.get_lcd_power() == DPMS_ON) + backlight_ops.update(); + return 0; } @@ -2123,49 +2556,58 @@ static int display_load_config(struct parse_result *result, void *user_data) if (MATCH(result->name, "LockScreenWaitingTime")) { SET_CONF(c->lock_wait_time, atof(result->value)); - _D("'lock wait time' is %.3f.", c->lock_wait_time); + _D("lock wait time is %.3f", c->lock_wait_time); } else if (MATCH(result->name, "LongPressInterval")) { SET_CONF(c->longpress_interval, atof(result->value)); - _D("'long press interval' is %.3f.", c->longpress_interval); + _D("long press interval is %.3f", c->longpress_interval); } else if (MATCH(result->name, "LightSensorSamplingInterval")) { SET_CONF(c->lightsensor_interval, atof(result->value)); - _D("'lightsensor interval' is %.3f.", c->lightsensor_interval); + _D("lightsensor interval is %.3f", c->lightsensor_interval); } else if (MATCH(result->name, "LCDOffTimeout")) { SET_CONF(c->lcdoff_timeout, atoi(result->value)); - _D("'lcdoff timeout' is %d ms.", c->lcdoff_timeout); + _D("lcdoff timeout is %d ms", c->lcdoff_timeout); } else if (MATCH(result->name, "BrightnessChangeStep")) { SET_CONF(c->brightness_change_step, atoi(result->value)); - _D("'brightness change step' is %d.", c->brightness_change_step); + _D("brightness change step is %d", c->brightness_change_step); } else if (MATCH(result->name, "LCDAlwaysOn")) { c->lcd_always_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'LCD always on' is %d.", c->lcd_always_on); + _D("LCD always on is %d", c->lcd_always_on); + } else if (MATCH(result->name, "Dimming")) { + c->dimming = (MATCH(result->value, "yes") ? 1 : 0); + _D("Dimming is %d", c->dimming); } else if (MATCH(result->name, "ChangedFrameRateAllowed")) { if (strstr(result->value, "setting")) { c->framerate_app[REFRESH_SETTING] = 1; - _D("'framerate app' is setting"); + _D("framerate app is Setting"); } if (strstr(result->value, "all")) { memset(c->framerate_app, 1, sizeof(c->framerate_app)); - _D("'framerate app' is all"); + _D("framerate app is All"); } } else if (MATCH(result->name, "ControlDisplay")) { c->control_display = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ControlDisplay' is %d.", c->control_display); + _D("ControlDisplay is %d", c->control_display); } else if (MATCH(result->name, "PowerKeyDoublePressSupport")) { c->powerkey_doublepress = (MATCH(result->value, "yes") ? 1 : 0); - _D("'PowerKeyDoublePressSupport' is %d.", c->powerkey_doublepress); + _D("PowerKeyDoublePressSupport is %d", c->powerkey_doublepress); } else if (MATCH(result->name, "AccelSensorOn")) { c->accel_sensor_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'AccelSensorOn' is %d.", c->accel_sensor_on); + _D("AccelSensorOn is %d", c->accel_sensor_on); } else if (MATCH(result->name, "ContinuousSampling")) { c->continuous_sampling = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ContinuousSampling' is %d.", c->continuous_sampling); + _D("ContinuousSampling is %d", c->continuous_sampling); } else if (MATCH(result->name, "TimeoutEnable")) { c->timeout_enable = (MATCH(result->value, "yes") ? true : false); - _D("'Timeout' is %s.", c->timeout_enable ? "enalbed" : "disabled"); + _D("Timeout is %s", c->timeout_enable ? "enalbed" : "disabled"); } else if (MATCH(result->name, "InputSupport")) { c->input_support = (MATCH(result->value, "yes") ? true : false); - _D("'Input' is %s.", c->input_support ? "supported" : "NOT supported"); + _D("Input is %s", c->input_support ? "supported" : "NOT supported"); + } else if (MATCH(result->name, "LockCheckTimeout")) { + SET_CONF(c->lockcheck_timeout, atoi(result->value)); + _D("LockCheckTimeout is %d", c->lockcheck_timeout); + } else if (MATCH(result->name, "AODTSP")) { + c->aod_tsp = (MATCH(result->value, "yes") ? true : false); + _D("TSP control at is %d at aod", c->aod_tsp); } return 0; @@ -2228,9 +2670,58 @@ static int display_probe(void *data) return 0; } +static int input_init_handler(void) +{ + if (!display_conf.input_support) + return 0; + + g_idle_add(init_input, NULL); + + return 0; +} + +static void esd_action(void) +{ + const struct device_ops *touchscreen_ops = NULL; + + _I("ESD on"); + + touchscreen_ops = find_device("touchscreen"); + + if (!check_default(touchscreen_ops)) + touchscreen_ops->stop(NORMAL_MODE); + backlight_ops.off(NORMAL_MODE); + backlight_ops.on(NORMAL_MODE); + if (!check_default(touchscreen_ops)) + touchscreen_ops->start(NORMAL_MODE); +} + +static void lcd_uevent_changed(struct udev_device *dev) +{ + const char *devpath; + const char *action; + + devpath = udev_device_get_devpath(dev); + if (!devpath) + return; + + if (!fnmatch(LCD_ESD_PATH, devpath, 0)) { + action = udev_device_get_action(dev); + if (!strcmp(action, UDEV_CHANGE)) + esd_action(); + } +} + +static const struct uevent_handler lcd_uevent_ops = { + .subsystem = LCD_EVENT_SUBSYSTEM, + .uevent_func = lcd_uevent_changed, + .data = NULL, +}; + static void display_init(void *data) { int ret, i; + unsigned int flags = (WITHOUT_STARTNOTI | FLAG_X_DPMS); int timeout = 0; bool wm_ready; @@ -2246,10 +2737,16 @@ static void display_init(void *data) _W("Failed to load '%s', use default value: %d", DISPLAY_CONF_FILE, ret); + register_kernel_uevent_control(&lcd_uevent_ops); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); register_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); register_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - register_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); + register_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + register_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); + register_notifier(DEVICE_NOTIFIER_LCD_AUTOBRT_SENSING, display_auto_brightness_sensing); + + init_save_userlock(); for (i = INIT_SETTING; i < INIT_END; i++) { switch (i) { @@ -2259,15 +2756,14 @@ static void display_init(void *data) case INIT_INTERFACE: if (display_conf.timeout_enable) get_lcd_timeout_from_settings(); - ret = init_sysfs(); + ret = init_sysfs(flags); break; case INIT_POLL: - _I("Input init."); + _I("input init"); pm_callback = poll_callback; - if (display_conf.input_support) - ret = init_input(); - else - ret = 0; + ret = input_init_handler(); + + pm_lock_detector_init(); break; case INIT_DBUS: _I("Dbus init."); @@ -2288,6 +2784,13 @@ static void display_init(void *data) init_lcd_operation(); check_seed_status(); + /* In smd test, TSP should be turned off if display panel is not existed. */ + if (backlight_ops.get_lcd_power() == -ENOENT) { + _I("Display panel is not existed."); + lcd_direct_control(DPMS_OFF, NORMAL_MODE); + exit_lcd_operation(); + } + /* wm_ready needs to be checked * since display manager can be launched later than deviced. * In the case, display cannot be turned on at the first booting */ @@ -2302,49 +2805,47 @@ static void display_init(void *data) trans_table[S_NORMAL][EVENT_TIMEOUT] = S_NORMAL; } - _I("Start Power managing without noti."); - if (power_ops.get_power_lock_support()) - power_ops.power_lock(); - - pm_cur_state = S_NORMAL; - set_setting_pmstate(pm_cur_state); - - if (display_conf.timeout_enable) { - timeout = states[S_NORMAL].timeout; - /* check minimun lcd on time */ - if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) - timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); - - reset_timeout(timeout); - } + if (flags & WITHOUT_STARTNOTI) { /* start without noti */ + _I("Start Power managing without noti"); + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); + power_ops.power_lock(); + } + pm_cur_state = S_NORMAL; + vconf_set_int(VCONFKEY_PM_STATE, pm_cur_state); + + status = DEVICE_OPS_STATUS_START; + if (display_conf.timeout_enable) { + timeout = states[S_NORMAL].timeout; + /* check minimun lcd on time */ + if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) + timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); + + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, + STAY_CUR_STATE, timeout); + } - status = DEVICE_OPS_STATUS_START; - /* - * Lock lcd off until booting is done. - * deviced guarantees all booting script is executing. - * Last script of booting unlocks this suspend blocking state. - */ - if (disp_plgn.pm_lock_internal) { - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); + /* + * Lock lcd off until booting is done. + * deviced guarantees all booting script is executing. + * Last script of booting unlocks this suspend blocking state. + */ + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, + STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); } if (display_conf.input_support) if (CHECK_OPS(keyfilter_ops, init)) keyfilter_ops->init(); } - - state_tv_init(); } static void display_exit(void *data) { int i = INIT_END; - state_tv_deinit(); - status = DEVICE_OPS_STATUS_STOP; /* Set current state to S_NORMAL */ @@ -2356,6 +2857,8 @@ static void display_exit(void *data) if (CHECK_OPS(keyfilter_ops, exit)) keyfilter_ops->exit(); + unregister_kernel_uevent_control(&lcd_uevent_ops); + display_ops_exit(NULL); for (i = i - 1; i >= INIT_SETTING; i--) { @@ -2370,7 +2873,8 @@ static void display_exit(void *data) unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); unregister_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); unregister_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - unregister_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); + unregister_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + unregister_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); exit_input(); break; @@ -2396,6 +2900,7 @@ static int display_start(enum device_flags flags) else /* normal lcd on */ backlight_ops.on(flags); + return 0; } @@ -2417,7 +2922,7 @@ static int display_start(enum device_flags flags) static int display_stop(enum device_flags flags) { /* NORMAL MODE */ - if (flags & NORMAL_MODE) { + if (flags & NORMAL_MODE || flags & FORCE_OFF_MODE) { backlight_ops.off(flags); return 0; } @@ -2441,7 +2946,7 @@ static int display_status(void) static const struct device_ops display_device_ops = { .priority = DEVICE_PRIORITY_HIGH, - .name = "display", + DECLARE_NAME_LEN("display"), .probe = display_probe, .init = display_init, .exit = display_exit, diff --git a/plugins/tv/display/device-interface.c b/plugins/tv/display/device-interface.c index 01b98ac..37a86cb 100644 --- a/plugins/tv/display/device-interface.c +++ b/plugins/tv/display/device-interface.c @@ -29,19 +29,21 @@ #include #include #include -#include +#include #include "ambient-mode.h" #include "core/log.h" #include "core/devices.h" -#include "core/list.h" #include "core/common.h" -#include "display/display-dpms.h" +#include "core/device-notifier.h" #include "util.h" #include "device-interface.h" #include "vconf.h" #include "core.h" #include "device-node.h" +#include "display/display-dpms.h" + +#define SET_SUSPEND_TIME 0.5 #define TOUCH_ON 1 #define TOUCH_OFF 0 @@ -49,7 +51,8 @@ #define LCD_PHASED_MIN_BRIGHTNESS 1 #define LCD_PHASED_MAX_BRIGHTNESS 100 #define LCD_PHASED_CHANGE_STEP 5 -#define LCD_PHASED_DELAY 35000 /* microsecond */ +#define LCD_PHASED_DELAY 10000 /* microsecond */ +#define DUMP_MODE_WAITING_TIME 600000 /* microsecond */ #define POWER_AUTOSLEEP_PATH "/sys/power/autosleep" #define POWER_LOCK_PATH "/sys/power/wake_lock" @@ -57,24 +60,57 @@ #define POWER_WAKEUP_PATH "/sys/power/wakeup_count" #define POWER_STATE_PATH "/sys/power/state" -enum { - POWER_UNLOCK = 0, - POWER_LOCK, -}; +#define DISPLAY_HAL_LIB_PATH "/usr/lib/libdisplay-hal.so" + +#define GESTURE_STR "gesture" +#define POWERKEY_STR "powerkey" +#define EVENT_STR "event" +#define TOUCH_STR "touch" +#define TIMEOUT_STR "timeout" +#define PROXIMITY_STR "proximity" +#define PALM_STR "palm" +#define UNKNOWN_STR "unknown" + +#define FREEZER_VITAL_WAKEUP_CGROUP "/sys/fs/cgroup/freezer/vital_wakeup/freezer.state" struct _backlight_ops backlight_ops; struct _power_ops power_ops; +static int mainlock_status = POWER_UNLOCK; static bool custom_status; static int custom_brightness; static int force_brightness; static int default_brightness; - +static int vital_support = -2; +static int vital_service; +static bool vital_sleep; +static int dpms_running_state = DPMS_SETTING_DONE; static struct display_device *display_dev; +static guint release_timer; -static int bl_onoff(int on) +struct display_device *display_dev_get(void) +{ + return display_dev; +} + +void dpms_set_running_state(int val) +{ + dpms_running_state = val; +} + +static int bl_onoff(int on, enum device_flags flags) { dpms_set_state(on); + +#ifdef ENABLE_PM_LOG + if (on == DPMS_ON) + pm_history_save(PM_LOG_LCD_ON_COMPLETE, pm_cur_state); + else if (on == DPMS_OFF || on == DPMS_FORCE_OFF) + pm_history_save(PM_LOG_LCD_OFF_COMPLETE, pm_cur_state); + else + pm_history_save(PM_LOG_LCD_CONTROL_FAIL, on); +#endif + return 0; } @@ -85,12 +121,6 @@ static int bl_brt(int brightness, int delay) if (delay > 0) usleep(delay); - if (force_brightness > 0) { - _I("brightness=%d force brightness=%d", - brightness, force_brightness); - brightness = force_brightness; - } - /* Update device brightness */ ret = backlight_ops.set_brightness(brightness); @@ -115,39 +145,96 @@ static int system_enable_autosleep(void) return sys_set_str(POWER_AUTOSLEEP_PATH, "mem"); } -static int system_power_lock(void) +static int vital_mode_support(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; - int ret; + if (vital_support < 0) { + FILE *fp; + + fp = fopen(FREEZER_VITAL_WAKEUP_CGROUP, "r"); + if (fp == NULL) { + _E("%s open failed", FREEZER_VITAL_WAKEUP_CGROUP); + /* read max 2 times to check if this file exist */ + vital_support++; + return 0; + } + vital_support = 1; + fclose(fp); + } + return vital_support; +} - _I("system power lock."); - ret = sys_set_str(POWER_LOCK_PATH, "mainlock"); +static int suspend_other_process(int type) +{ + int ret = 0; + char buf[8]; + const char *command[1]; - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } + if (vital_service == type) + return ret; + + if (type == VITAL_WAKEUP && vital_service > VITAL_SLEEP) + return ret; + + vital_service = type; + + if (!vital_mode_support()) + return ret; + if (type == VITAL_SLEEP) { + snprintf(buf, sizeof(buf), "%s", "sleep"); + command[0] = buf; + dbus_handle_method_sync_timeout(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", + command, + SET_SUSPEND_TIME*1000); + vital_sleep = true; + } else if (type == VITAL_WAKEUP) { + snprintf(buf, sizeof(buf), "%s", "wakeup"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + } else if (type == VITAL_EXIT) { + snprintf(buf, sizeof(buf), "%s", "exit"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + vital_sleep = false; + } return ret; } -static int system_power_unlock(void) +static int system_power_lock(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; + _I("system power lock"); + suspend_other_process(VITAL_WAKEUP); + mainlock_status = POWER_LOCK; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } + return sys_set_str(POWER_LOCK_PATH, "mainlock"); +} + +static int system_power_unlock(void) +{ + _I("system power unlock"); + suspend_other_process(VITAL_SLEEP); + mainlock_status = POWER_UNLOCK; - _I("system power unlock."); return sys_set_str(POWER_UNLOCK_PATH, "mainlock"); } +static int system_get_power_lock(void) +{ + return mainlock_status; +} + static int system_get_power_lock_support(void) { static int power_lock_support = -1; @@ -162,7 +249,7 @@ static int system_get_power_lock_support(void) else power_lock_support = true; - _I("system power lock: %s", + _I("System power lock: %s", (power_lock_support ? "support" : "not support")); out: @@ -174,9 +261,6 @@ static int get_lcd_power(void) enum display_state val; int ret; - if (ambient_get_state()) - return DPMS_OFF; - if (!display_dev || !display_dev->get_state) { _E("There is no display device."); return -ENOENT; @@ -186,6 +270,12 @@ static int get_lcd_power(void) if (ret < 0) return ret; + if (val == DISPLAY_ON && ambient_get_state()) + return DPMS_OFF; + + if (dpms_running_state != DPMS_SETTING_DONE) + return dpms_running_state; + switch (val) { case DISPLAY_ON: return DPMS_ON; @@ -202,13 +292,16 @@ static int get_lcd_power(void) bool display_dimstay_check(void) { + if (pm_status_flag & DIM_FLAG) + return true; + if ((pm_status_flag & PWRSV_FLAG) && !(pm_status_flag & BRTCH_FLAG)) return true; return false; } -void change_brightness(int start, int end, int step) +static void change_brightness(int start, int end, int step) { int diff, val; int ret = -1; @@ -226,7 +319,20 @@ void change_brightness(int start, int end, int step) if (prev == end) return; - _D("start=%d end=%d step=%d", start, end, step); + if (pm_status_flag & DIM_MASK) + end = 0; + + _I("start %d end %d step %d", start, end, step); + + if (display_dev && display_dev->set_multi_brightness) { + ret = display_dev->set_multi_brightness(end, step, LCD_PHASED_DELAY); + if (ret < 0) + _E("Failed to set_multi_brightness (%d)", ret); + + backlight_ops.set_brightness(end); + + return; + } diff = end - start; @@ -250,16 +356,15 @@ void change_brightness(int start, int end, int step) static int backlight_on(enum device_flags flags) { int ret = -1; + static int cnt; - _D("LCD on %x", flags); + _I("[DPMS XLIB Backlight] LCD on %x cnt:%d", flags, cnt); - ret = bl_onoff(DPMS_ON); - if (ret < 0) - _E("Failed to turn on backlight."); - - if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(LCD_PHASED_MIN_BRIGHTNESS, - default_brightness, LCD_PHASED_CHANGE_STEP); + cnt++; + ret = bl_onoff(DPMS_ON, flags); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_ON, pm_cur_state); +#endif return ret; } @@ -267,19 +372,30 @@ static int backlight_on(enum device_flags flags) static int backlight_off(enum device_flags flags) { int ret = -1; + static int cnt, ambient_cnt; + + if (flags & AMBIENT_MODE) { + _I("[DPMS XLIB Backlight] LCD suspend %x cnt:%d", flags, ambient_cnt); + ambient_cnt++; + + return 0; + } - _D("LCD off %x", flags); + _I("[DPMS XLIB Backlight] LCD off %x cnt:%d", flags, cnt); + cnt++; if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(default_brightness, + backlight_ops.transit_brt(default_brightness, LCD_PHASED_MIN_BRIGHTNESS, LCD_PHASED_CHANGE_STEP); - if (flags & AMBIENT_MODE) - return 0; + if (flags & FORCE_OFF_MODE) + ret = bl_onoff(DPMS_FORCE_OFF, flags); + else + ret = bl_onoff(DPMS_OFF, flags); - ret = bl_onoff(DPMS_OFF); - if (ret < 0) - _E("Failed to turn off backlight."); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_OFF, pm_cur_state); +#endif return ret; } @@ -287,15 +403,8 @@ static int backlight_off(enum device_flags flags) static int backlight_dim(void) { int ret; - int brightness; - ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_DIM_BRIGHTNESS, &brightness); - if (ret < 0) { - _E("Failed to get vconf value for lcd dim brightness: %d", vconf_get_ext_errno()); - return -EPERM; - } - - ret = bl_brt(brightness, 0); + ret = backlight_ops.set_brightness(PM_DIM_BRIGHTNESS); #ifdef ENABLE_PM_LOG if (!ret) pm_history_save(PM_LOG_LCD_DIM, pm_cur_state); @@ -335,11 +444,11 @@ static int custom_backlight_update(void) custom_brightness > PM_MAX_BRIGHTNESS) return -EINVAL; - if (display_dimstay_check()) { + if (display_dimstay_check()) ret = backlight_dim(); - } else { - _I("Custom brightness(%d) restored.", custom_brightness); - ret = bl_brt(custom_brightness, 0); + else { + _I("custom brightness restored! %d", custom_brightness); + ret = backlight_ops.set_brightness(custom_brightness); } return ret; @@ -358,16 +467,18 @@ static int set_force_brightness(int level) static int backlight_update(void) { int ret = 0; + int brt; if (get_custom_status()) { - _I("Custom brightness mode. brt no updated."); + _I("custom brightness mode! brt no updated"); return 0; } if (display_dimstay_check()) ret = backlight_dim(); - else - ret = bl_brt(default_brightness, 0); - + else { + brt = backlight_ops.get_default_brt(); + ret = backlight_ops.set_brightness(brt); + } return ret; } @@ -377,7 +488,7 @@ static int backlight_standby(int force) if ((get_lcd_power() == DPMS_ON) || force) { _I("LCD standby"); - ret = bl_onoff(DPMS_STANDBY); + ret = bl_onoff(DPMS_STANDBY, 0); } return ret; @@ -393,6 +504,11 @@ static int set_default_brt(int level) return 0; } +static int get_default_brt(void) +{ + return default_brightness; +} + static int check_wakeup_src(void) { /* TODO if nedded. @@ -470,10 +586,22 @@ static int set_brightness(int val) return max; } + if (force_brightness > 0 && val != PM_DIM_BRIGHTNESS) { + _I("brightness(%d), force brightness(%d)", + val, force_brightness); + val = force_brightness; + } + + if (pm_status_flag & DIM_MASK) + val = 0; + /* Maximum Brightness to users is 100. * Thus real brightness need to be calculated */ val = val * max / 100; + _I("set brightness %d (default:%d)", val, default_brightness); + device_notify(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, (void *)&val); + return display_dev->set_brightness(val); } @@ -544,6 +672,84 @@ static int get_brightness_by_light_sensor(float lmax, float lmin, float light, i return 0; } +static int get_image_effect(enum display_image_effect *effect) +{ + int ret; + enum display_image_effect val; + + if (!display_dev || !display_dev->get_image_effect) { + _E("There is no display device."); + return -ENOENT; + } + + ret = display_dev->get_image_effect(&val); + if (ret < 0) { + _E("Failed to get image effect: %d", ret); + return ret; + } + + *effect = val; + + return 0; +} + +static int set_image_effect(enum display_image_effect effect) +{ + int ret; + + if (!display_dev || !display_dev->set_image_effect) { + _E("There is no display device."); + return -ENOENT; + } + + ret = display_dev->set_image_effect(effect); + if (ret < 0) { + _E("Failed to set image effect: %d", ret); + return ret; + } + + return 0; +} + +static int get_panel_mode(enum display_panel_mode *mode) +{ + int ret; + enum display_panel_mode val; + + if (!display_dev || !display_dev->get_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->get_panel_mode(&val); + if (ret < 0) { + _E("failed to get panel mode(%d)", ret); + return ret; + } + + *mode = val; + + return 0; +} + +static int set_panel_mode(enum display_panel_mode mode) +{ + int ret; + + if (!display_dev || !display_dev->set_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->set_panel_mode(mode); + if (ret < 0) { + _E("failed to set panel mode(%d)", ret); + return ret; + } + + return 0; +} + static int get_frame_rate(int *rate) { if (!rate) @@ -595,6 +801,101 @@ static int set_frame_rate(int rate) return display_dev->set_frame_rate(rate); } +/* It was operated only AOD enter & leave */ +static int backlight_transit_state(int state) +{ + int brt, val; + int start, end; + + backlight_ops.get_brightness(&brt); + + if (state == DPMS_OFF) { + start = brt; + end = display_conf.aod_enter_level; + + /* + * The value of backlight_ops.get_brightness is system brightness. + * But when device is LBM, the value is not same with real brightness. + * So it should be read exactly value for transit smooth effect + */ + get_brightness(&val); + + if (val > display_conf.aod_enter_level) + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } else { + /* prevent transit effect when another effect is already executed */ + if (brt != display_conf.aod_enter_level) { + _W("effect is already executed brt(%d) aod_level(%d)", + brt, display_conf.aod_enter_level); + return 0; + } + + start = display_conf.aod_enter_level; + end = default_brightness; + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } + + return 0; +} + +static gboolean blink_cb(gpointer data) +{ + static bool flag; + + set_brightness(flag ? PM_MAX_BRIGHTNESS : PM_MIN_BRIGHTNESS); + + flag = !flag; + + return G_SOURCE_CONTINUE; +} + +static void blink(int timeout) +{ + static guint timer; + + if (timer) { + g_source_remove(timer); + timer = 0; + } + + if (timeout < 0) { + _E("timeout value is invalid %d", timeout); + return; + } + + if (timeout == 0) { + backlight_update(); + return; + } + + timer = g_timeout_add(timeout, blink_cb, NULL); +} + +static gboolean release_blink_cb(gpointer data) +{ + blink(0); + + release_timer = 0; + return G_SOURCE_REMOVE; +} + +static void release_blink(void) +{ + if (release_timer) { + g_source_remove(release_timer); + release_timer = 0; + } + + release_timer = g_timeout_add(DUMP_MODE_WAITING_TIME, release_blink_cb, NULL); +} + +static void restore_brightness_func(void) +{ + backlight_ops.set_brightness = set_brightness; + backlight_ops.get_brightness = get_brightness; + backlight_ops.transit_brt = change_brightness; +} + static void _init_ops(void) { backlight_ops.off = backlight_off; @@ -603,6 +904,7 @@ static void _init_ops(void) backlight_ops.update = backlight_update; backlight_ops.standby = backlight_standby; backlight_ops.set_default_brt = set_default_brt; + backlight_ops.get_default_brt = get_default_brt; backlight_ops.get_lcd_power = get_lcd_power; backlight_ops.set_custom_status = set_custom_status; backlight_ops.get_custom_status = get_custom_status; @@ -611,14 +913,24 @@ static void _init_ops(void) backlight_ops.set_force_brightness = set_force_brightness; backlight_ops.set_brightness = set_brightness; backlight_ops.get_brightness = get_brightness; + backlight_ops.restore_brightness_func = restore_brightness_func; backlight_ops.get_brightness_by_light_sensor = get_brightness_by_light_sensor; + backlight_ops.get_image_effect = get_image_effect; + backlight_ops.set_image_effect = set_image_effect; + backlight_ops.get_panel_mode = get_panel_mode; + backlight_ops.set_panel_mode = set_panel_mode; backlight_ops.get_frame_rate = get_frame_rate; backlight_ops.set_frame_rate = set_frame_rate; + backlight_ops.transit_state = backlight_transit_state; + backlight_ops.transit_brt = change_brightness; + backlight_ops.blink = blink; + backlight_ops.release_blink = release_blink; power_ops.suspend = system_suspend; power_ops.enable_autosleep = system_enable_autosleep; power_ops.power_lock = system_power_lock; power_ops.power_unlock = system_power_unlock; + power_ops.get_power_lock = system_get_power_lock; power_ops.get_power_lock_support = system_get_power_lock_support; power_ops.check_wakeup_src = check_wakeup_src; power_ops.get_wakeup_count = get_wakeup_count; @@ -636,12 +948,12 @@ int display_service_load(void) r = hw_get_info(DISPLAY_HARDWARE_DEVICE_ID, (const struct hw_info **)&info); if (r < 0) { - _I("Display shared library is not supported: %d", r); - return -ENODEV; + _I("display shared library is not supported: %d", r); + return 0; } if (!info->open) { - _E("Failed to open display device: open(NULL)"); + _E("Failed to open display device: open(NULL)."); return -EPERM; } @@ -672,17 +984,44 @@ int display_service_free(void) return 0; } -int init_sysfs() +bool vital_mode(void) +{ + return vital_sleep; +} + +static int vital_state_changed(void *data) +{ + int type; + + assert(data); + + type = *(int *)data; + if (type == VITAL_EXIT) + suspend_other_process(VITAL_EXIT); + + return 0; +} + +int init_sysfs(unsigned int flags) { _init_ops(); + register_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } int exit_sysfs(void) { + int fd; const struct device_ops *ops = NULL; + fd = open("/tmp/sem.pixmap_1", O_RDONLY); + if (fd == -1) { + _E("X server disable"); + backlight_on(NORMAL_MODE); + } + backlight_update(); disconnect_interface_with_dpms(); @@ -694,5 +1033,10 @@ int exit_sysfs(void) if (!check_default(ops)) ops->start(NORMAL_MODE); + if (fd != -1) + close(fd); + + unregister_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } diff --git a/plugins/tv/display/key-filter.c b/plugins/tv/display/key-filter.c index 8b35f7c..ddbb287 100644 --- a/plugins/tv/display/key-filter.c +++ b/plugins/tv/display/key-filter.c @@ -25,6 +25,7 @@ #include #include #include +#include #include "ambient-mode.h" #include "util.h" @@ -36,11 +37,11 @@ #include "core/common.h" #include "core/devices.h" #include "core/device-notifier.h" +#include "shared/common.h" #include "power/power-handler.h" #include "led/touch-key.h" #include "apps/apps.h" -#include #ifndef KEY_SCREENLOCK #define KEY_SCREENLOCK 0x98 #endif @@ -50,21 +51,24 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" +#define PWROFF_POPUP_ACT "pwroff_popup" #define USEC_PER_SEC 1000000 +#define CSC_CONFIG_MODE_RUNNING 1 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ +#define TORCH_COMBINATION_INTERVAL 0.1 /* 0.1 second */ +#define DEFAULT_COMBINATION_INTERVAL 0.1 /* 0.1 second */ -#define KEY_MAX_DELAY_TIME 700 /* ms */ +#define LONGKEY_PRESSED_TIME 4 /* 4 second */ -#define KEY_RELEASED 0 -#define KEY_PRESSED 1 -#define KEY_BEING_PRESSED 2 +#define KEY_MAX_DELAY_TIME 700 /* ms */ #define SIGNAL_CHANGE_HARDKEY "ChangeHardkey" #define SIGNAL_LCDON_BY_POWERKEY "LCDOnByPowerkey" #define SIGNAL_LCDOFF_BY_POWERKEY "LCDOffByPowerkey" -#define TOUCH_RELEASE (-1) +#define NORMAL_POWER 0 +#define KEY_TEST_MODE_POWER 2 #define GLOVE_MODE 1 @@ -72,39 +76,30 @@ enum key_combination_flags { KEY_COMBINATION_STOP = 0, KEY_COMBINATION_POWERKEY = BIT(0), KEY_COMBINATION_MENUKEY = BIT(1), + KEY_COMBINATION_VOLUMEUP = BIT(2), + KEY_COMBINATION_VOLUMEDOWN = BIT(3), }; enum combination_process { COMBINATION_STOP = KEY_COMBINATION_STOP, COMBINATION_SCREENCAPTURE = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_MENUKEY, + COMBINATION_TORCH = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEUP, + COMBINATION_QUICKTALK = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEDOWN, }; -int __WEAK__ get_glove_state(void); -void __WEAK__ switch_glove_key(int val); - static struct timeval pressed_time; static guint longkey_timeout_id = 0; +static guint longkey_restore_id = 0; +static guint displayon_by_powerkey_timeout_id = 0; static int cancel_lcdoff; static int key_combination = KEY_COMBINATION_STOP; static double combination_pressed_time; static bool touch_pressed = false; static int skip_lcd_off = false; static int skip_combination = false; +static int bezel_wakeup = true; static const struct device_ops *touchled; - -static int booting_done(void *data) -{ - static int done = 0; - - if (!data) - return done; - - done = *(int *)data; - - _I("Booting done(%d)", done); - - return done; -} +static int booting_check = true; static inline int current_state_in_on(void) { @@ -128,7 +123,7 @@ static void pwroff_popup(void) _E("Failed to launch power off popup."); } -static void longkey_pressed() +static void longkey_pressed(void) { unsigned int caps; @@ -152,6 +147,14 @@ static void longkey_pressed() pwroff_popup(); } +static gboolean longkey_restore_cb(void *data) +{ + device_notify(DEVICE_NOTIFIER_LONGKEY_RESTORE, (void *)NULL); + longkey_restore_id = 0; + + return G_SOURCE_REMOVE; +} + static gboolean longkey_pressed_cb(void *data) { longkey_pressed(); @@ -196,7 +199,7 @@ static inline void broadcast_lcdoff_by_powerkey(void) NULL); } -static inline bool switch_on_lcd(void) +static inline bool switch_on_lcd(enum device_flags flags) { if (current_state_in_on()) return false; @@ -206,9 +209,12 @@ static inline bool switch_on_lcd(void) return false; } - broadcast_lcdon_by_powerkey(); + if (flags & LCD_ON_BY_POWER_KEY) + broadcast_lcdon_by_powerkey(); + else if (flags & LCD_ON_BY_TOUCH) + _I("Display on by Touch_wakeup event"); - lcd_on_direct(LCD_ON_BY_POWER_KEY); + lcd_on_direct(flags); return true; } @@ -230,15 +236,37 @@ static void check_key_combination(struct input_event *pinput) { double press_time, diff_time; press_time = (pinput->time).tv_sec + USEC_TO_SEC((pinput->time).tv_usec); + diff_time = press_time - combination_pressed_time; switch (key_combination) { case COMBINATION_SCREENCAPTURE: - diff_time = press_time - combination_pressed_time; if (diff_time <= CAPTURE_COMBINATION_INTERVAL) { _I("Combination key : SCREENCAPTURE mode"); skip_combination = true; } break; + case COMBINATION_TORCH: + if (diff_time <= TORCH_COMBINATION_INTERVAL) { + /* When torch combination, display control should be not change. */ + if (displayon_by_powerkey_timeout_id) { + g_source_remove(displayon_by_powerkey_timeout_id); + displayon_by_powerkey_timeout_id = 0; + } + _I("Combination key : TORCH mode"); + skip_combination = true; + } else + key_combination = COMBINATION_STOP; + break; + case COMBINATION_QUICKTALK: + if (diff_time <= DEFAULT_COMBINATION_INTERVAL) { + _I("Combination key : QUICK-TALK mode"); + skip_combination = true; + if (longkey_timeout_id) { + g_source_remove(longkey_timeout_id); + longkey_timeout_id = 0; + } + } + break; default: combination_pressed_time = press_time; return; @@ -255,6 +283,12 @@ static void start_key_combination(struct input_event *pinput) case KEY_MENU: key_combination |= KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination |= KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination |= KEY_COMBINATION_VOLUMEDOWN; + break; default: return; } @@ -276,8 +310,14 @@ static void stop_key_combination(struct input_event *pinput) case KEY_MENU: key_combination &= ~KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination &= ~KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination &= ~KEY_COMBINATION_VOLUMEDOWN; + break; default: - _E("Thid code(%d) is not combination type", pinput->code); + _E("This code(%d) is not combination type.", pinput->code); break; } } @@ -301,24 +341,118 @@ static int process_menu_key(struct input_event *pinput) return false; _D("No lcd-on capability!"); return true; - } else if (pinput->value == KEY_PRESSED) { - switch_on_lcd(); - } + } else if (pinput->value == KEY_PRESSED) + switch_on_lcd(LCD_ON_BY_POWER_KEY); return false; } -static bool release_short_powerkey(void) +static int decide_lcdoff(void) { -// tv d - no, a - yes - if (!display_conf.powerkey_doublepress && display_conf.lcd_always_on) { - longkey_pressed(); + /* It's not needed if it's already LCD off state */ + if (!current_state_in_on() && + backlight_ops.get_lcd_power() != DPMS_ON) + return false; + + /* + * This flag is set at the moment + * that LCD is turned on by power key + * LCD has not to turned off in the situation. + */ + if (skip_lcd_off) + return false; + + /* LCD is not turned off when powerkey is pressed,not released */ + if (key_combination == KEY_COMBINATION_POWERKEY) + return false; + + /* LCD-off is blocked at the moment poweroff popup shows */ + if (cancel_lcdoff) + return false; + + /* LCD-off is blocked when powerkey and volmedown key are pressed */ + if (skip_combination) + return false; + + /* At booting time, display must do not turn off */ + if (booting_check) + return false; + + return true; +} + +static int lcdoff_powerkey(void) +{ + int ignore = true; + + if (decide_lcdoff() == true) { + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + if (!check_holdkey_block(S_NORMAL) && + !check_holdkey_block(S_LCDDIM)) { + if (display_info.update_auto_brightness) + display_info.update_auto_brightness(false); + switch_off_lcd(); + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); + update_lcdoff_source(VCONFKEY_PM_LCDOFF_BY_POWERKEY); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_POWERKEY, LCD_OFF); + } + } else { + ignore = false; + skip_combination = false; + } + cancel_lcdoff = 0; + + return ignore; +} + +static bool key_check_display_on(void) +{ + if (current_state_in_on()) + return false; + + if (backlight_ops.get_lcd_power() == DPMS_ON) { + _W("display power was on"); return false; } return true; } +static gboolean display_on_cb(void *data) +{ + if (displayon_by_powerkey_timeout_id == 0) + return G_SOURCE_REMOVE; + + displayon_by_powerkey_timeout_id = 0; + if (backlight_ops.get_lcd_power() != DPMS_ON || + current_state_in_on() == false) { + broadcast_lcdon_by_powerkey(); + lcd_on_direct(LCD_ON_BY_POWER_KEY); + + if (pm_callback) + (*pm_callback) (INPUT_POLL_EVENT, NULL); + } + + return G_SOURCE_REMOVE; +} + +static int process_back_key(struct input_event *pinput) +{ + int ignore = true; + + if (pinput->value == KEY_PRESSED) { + switch_on_lcd(LCD_ON_BY_POWER_KEY); + _I("back key pressed"); + ignore = false; + } + + return ignore; +} + static int process_power_key(struct input_event *pinput) { int ignore = true; @@ -331,7 +465,13 @@ static int process_power_key(struct input_event *pinput) case KEY_RELEASED: check_key_pair(pinput->code, pinput->value, &value); - ignore = release_short_powerkey(); + if (!display_conf.powerkey_doublepress) { + if (display_has_caps(caps, DISPLAY_CAPA_LCDOFF)) + lcdoff_powerkey(); + else + _D("No lcdoff capability!"); + } else if (skip_lcd_off) + ignore = false; if (!display_has_caps(caps, DISPLAY_CAPA_LCDON)) ignore = true; @@ -341,10 +481,32 @@ static int process_power_key(struct input_event *pinput) longkey_timeout_id = 0; } + if (longkey_restore_id > 0) { + g_source_remove(longkey_restore_id); + longkey_restore_id = 0; + } + break; case KEY_PRESSED: if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) { - skip_lcd_off = switch_on_lcd(); + if (wearable_mode()) + skip_lcd_off = switch_on_lcd(LCD_ON_BY_POWER_KEY); + else { + /* + * LCD does not turn on immediately at mobile. + * It will be turned on after 0.1 second because of torch concept. + */ + skip_lcd_off = key_check_display_on(); + ignore = true; + + if (!displayon_by_powerkey_timeout_id && + backlight_ops.get_lcd_power() != DPMS_ON && + key_combination != COMBINATION_TORCH) { + displayon_by_powerkey_timeout_id = g_timeout_add( + 100, + display_on_cb, NULL); + } + } } else { _D("No lcdon capability!"); skip_lcd_off = false; @@ -358,9 +520,11 @@ static int process_power_key(struct input_event *pinput) longkey_timeout_id = g_timeout_add_seconds( display_conf.longpress_interval, longkey_pressed_cb, NULL); + /* add long key restore timer */ + longkey_restore_id = g_timeout_add_seconds( + LONGKEY_PRESSED_TIME, + longkey_restore_cb, NULL); } - if (skip_lcd_off) - ignore = false; cancel_lcdoff = 0; break; @@ -421,10 +585,12 @@ static void process_hardkey_backlight(struct input_event *pinput) _I("Touch is pressed, then hard key is not working!"); return; } + if (!wearable_mode()) { /* Sound & Vibrate only in unlock state */ if (__get_lock_screen_state() == VCONFKEY_IDLE_UNLOCK || get_lock_screen_bg_state()) sound_vibrate_hardkey(); + } if (touchled && touchled->execute) { opt = TOUCHLED_PRESS; @@ -444,6 +610,23 @@ static void process_hardkey_backlight(struct input_event *pinput) } } +static void update_vital_state(struct input_event *pinput) +{ + int type; + + /* Change vital state to VITAL_EXIT only if vital mode is active */ + if (!vital_mode()) + return; + + /* Touch or Menu Key Release Event */ + if (pinput->type == EV_ABS || (pinput->type == EV_KEY && + pinput->value == KEY_RELEASED && pinput->code == KEY_MENU)) { + /* Enable all services upon receiving user input, else maintain same state */ + type = VITAL_EXIT; + device_notify(DEVICE_NOTIFIER_VITAL_STATE, &type); + } +} + static int check_key(struct input_event *pinput, int fd) { int ignore = true; @@ -462,6 +645,13 @@ static int check_key(struct input_event *pinput, int fd) ignore = process_screenlock_key(pinput); break; case KEY_BACK: + ignore = process_back_key(pinput); + stop_key_combination(NULL); + if (current_state_in_on()) { + process_hardkey_backlight(pinput); + ignore = false; + } + break; case KEY_PHONE: stop_key_combination(NULL); if (current_state_in_on()) { @@ -471,6 +661,9 @@ static int check_key(struct input_event *pinput, int fd) break; case KEY_VOLUMEUP: case KEY_VOLUMEDOWN: + if (current_state_in_on()) + ignore = false; + break; case KEY_CAMERA: case KEY_EXIT: case KEY_CONFIG: @@ -536,34 +729,36 @@ static int check_key_filter(void *data, int fd) code = pinput->code; value = pinput->value; + update_vital_state(pinput); ignore = check_key(pinput, fd); restore_custom_brightness(); break; case EV_REL: - ignore = false; + if (pm_cur_state == S_LCDOFF && bezel_wakeup) { + switch_on_lcd(LCD_ON_BY_BEZEL); + ignore = false; + } else if (pm_cur_state != S_LCDOFF) + ignore = false; break; case EV_ABS: - if (current_state_in_on()) + update_vital_state(pinput); + if (pinput->value == KEY_PRESSED) { + switch_on_lcd(LCD_ON_BY_TOUCH); ignore = false; + } - if (ambient_get_condition() == true) { - switch_on_lcd(); + if (current_state_in_on()) ignore = false; - } restore_custom_brightness(); - touch_pressed = - (pinput->value == TOUCH_RELEASE ? false : true); + if (pinput->value == KEY_PRESSED) + touch_pressed = true; + else if (pinput->value == KEY_RELEASED) + touch_pressed = false; break; case EV_SW: - if (!get_glove_state || !switch_glove_key) - break; - if (pinput->code == SW_GLOVE && - get_glove_state() == GLOVE_MODE) { - switch_glove_key(pinput->value); - } break; } @@ -573,6 +768,20 @@ static int check_key_filter(void *data, int fd) return 0; } +static int booting_done_cb(void *data) +{ + booting_check = 0; + + return 0; +} + +static int bezel_wakeup_cb(void *data) +{ + bezel_wakeup = (int)data; + + return 0; +} + /* * Default capability * powerkey := LCDON | LCDOFF | POWEROFF @@ -597,12 +806,8 @@ static void keyfilter_init(void) touchled = find_device(TOUCHLED_NAME); - register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); -} - -static void keyfilter_exit(void) -{ - unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb); + register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb); } static void key_backlight_enable(bool enable) @@ -622,7 +827,6 @@ static void key_backlight_enable(bool enable) static const struct display_keyfilter_ops normal_keyfilter_ops = { .init = keyfilter_init, - .exit = keyfilter_exit, .check = check_key_filter, .set_powerkey_ignore = NULL, .powerkey_lcdoff = NULL, diff --git a/plugins/wearable/display/bezel.c b/plugins/wearable/display/bezel.c index 47f09b1..2ea3622 100644 --- a/plugins/wearable/display/bezel.c +++ b/plugins/wearable/display/bezel.c @@ -123,7 +123,7 @@ static int bezel_stop(enum device_flags flags) */ static const struct device_ops bezel_device_ops = { .priority = DEVICE_PRIORITY_HIGH, - .name = "bezel", + DECLARE_NAME_LEN("bezel"), .init = bezel_init, .exit = bezel_exit, .start = bezel_start, diff --git a/plugins/wearable/display/core.c b/plugins/wearable/display/core.c index 3f8c686..f65f2a1 100644 --- a/plugins/wearable/display/core.c +++ b/plugins/wearable/display/core.c @@ -35,10 +35,9 @@ #include #include #include +#include #include #include -#include -#include #include "ambient-mode.h" #include "util.h" @@ -53,14 +52,14 @@ #include "core/common.h" #include "core/config-parser.h" #include "core/launch.h" +#include "apps/apps.h" #include "extcon/extcon.h" +#include "battery/power-supply.h" #include "power/power-handler.h" #include "dd-display.h" #include "display/display-dpms.h" -#include "battery/battery.h" -#include "battery/power-supply.h" +#include "display-info.h" -#define PM_STATE_LOG_FILE tzplatform_mkpath(TZ_SYS_ALLLOGS, "pm_state.log") #define DISPLAY_CONF_FILE "/etc/deviced/display.conf" /** @@ -71,18 +70,28 @@ #define SET_BRIGHTNESS_IN_BOOTLOADER "/usr/bin/save_blenv SLP_LCD_BRIGHT" #define LOCK_SCREEN_INPUT_TIMEOUT 10000 #define LOCK_SCREEN_CONTROL_TIMEOUT 5000 -#define DD_LCDOFF_INPUT_TIMEOUT 3000 -#define ALWAYS_ON_TIMEOUT 3600000 //3600000 = 1 hour +#define ALWAYS_ON_TIMEOUT 3600000 +#define LATE_LCD_TRANSIT 1 + +#define PID_MAX 6 #define GESTURE_STR "gesture" #define POWER_KEY_STR "powerkey" #define TOUCH_STR "touch" #define EVENT_STR "event" #define TIMEOUT_STR "timeout" +#define PROXI_STR "proximity" +#define PALM_STR "palm" #define UNKNOWN_STR "unknown" +#define METHOD_APP_STATUS "CheckAppStatus" + +#define PM_WAKEUP 0 +#define PM_SUSPEND 1 + extern void init_pm_internal(); extern int get_charging_status(int *val); +extern void init_save_userlock(void); unsigned int pm_status_flag; static int trans_condition; @@ -93,6 +102,7 @@ static enum device_ops_status status = DEVICE_OPS_STATUS_UNINIT; int pm_cur_state; int pm_old_state; guint timeout_src_id; +int system_wakeup_flag = false; static unsigned int custom_normal_timeout = 0; static unsigned int custom_dim_timeout = 0; static int custom_holdkey_block = false; @@ -100,13 +110,21 @@ static int custom_change_pid = -1; static char *custom_change_name; static bool hallic_open = true; static guint lock_timeout_id; +static guint transit_timer; static int lock_screen_timeout = LOCK_SCREEN_INPUT_TIMEOUT; +static long displayoff_time; static struct timeval lcdon_tv; static int lcd_paneloff_mode = false; static int stay_touchscreen_off = false; +dd_list *lcdon_ops; +/* + * The two variables(lcdon_broadcast, pmstate_suspend) must be set initial + * state because it should be sent from previous state at booting time. + */ static bool lcdon_broadcast = true; +static int pmstate_suspend = PM_SUSPEND; + static bool touch_blocked = false; -dd_list *lcdon_ops; /* default transition, action fuctions */ static int default_trans(int evt); @@ -117,6 +135,10 @@ static gboolean del_normal_cond(void *data); static gboolean del_dim_cond(void *data); static gboolean del_off_cond(void *data); +static gboolean pmlock_normal_check(void *data); +static gboolean pmlock_dim_check(void *data); +static gboolean pmlock_off_check(void *data); + static int default_proc_change_state(unsigned int cond, pid_t pid); static int (*proc_change_state)(unsigned int cond, pid_t pid) = default_proc_change_state; @@ -141,6 +163,10 @@ static int trans_table[S_END][EVENT_END] = { { S_POWEROFF, S_POWEROFF }, /* S_POWEROFF */ }; +static GSourceFunc warning_cb[S_END] = { + NULL, pmlock_normal_check, pmlock_dim_check, pmlock_off_check, +}; + enum signal_type { SIGNAL_INVALID = 0, SIGNAL_PRE, @@ -148,6 +174,11 @@ enum signal_type { SIGNAL_MAX, }; +enum platform_control { + PLATFORM_DISPLAY_OFF, + PLATFORM_DISPLAY_ON, +}; + static const char *lcdon_sig_lookup[SIGNAL_MAX] = { [SIGNAL_PRE] = "LCDOn", [SIGNAL_POST] = "LCDOnCompleted", @@ -179,7 +210,7 @@ static const char *lcdoff_sig_lookup[SIGNAL_MAX] = { #define LONG_PRESS_INTERVAL 2 /* 2 seconds */ #define SAMPLING_INTERVAL 1 /* 1 sec */ #define BRIGHTNESS_CHANGE_STEP 10 -#define LCD_ALWAYS_ON 1 +#define LCD_ALWAYS_ON 0 #define ACCEL_SENSOR_ON 1 #define CONTINUOUS_SAMPLING 1 #define LCDOFF_TIMEOUT 500 /* milli second */ @@ -196,13 +227,18 @@ struct display_config display_conf = { .lcdoff_timeout = LCDOFF_TIMEOUT, .brightness_change_step = BRIGHTNESS_CHANGE_STEP, .lcd_always_on = LCD_ALWAYS_ON, - .framerate_app = {1, 0, 0, 0}, - .control_display = 1, + .dimming = 1, + .framerate_app = {0, 0, 0, 0}, + .control_display = 0, .powerkey_doublepress = 0, .accel_sensor_on = ACCEL_SENSOR_ON, .continuous_sampling = CONTINUOUS_SAMPLING, - .timeout_enable = false, + .timeout_enable = true, .input_support = true, + .lockcheck_timeout = 600, + .aod_enter_level = 40, + .aod_tsp = true, + .touch_wakeup = false, }; struct display_function_info display_info = { @@ -215,9 +251,11 @@ struct display_function_info display_info = { typedef struct _pm_lock_node { pid_t pid; guint timeout_id; + guint warning_id; time_t time; bool holdkey_block; bool background; + bool broadcast_warning; } PmLockNode; static dd_list *cond_head[S_END]; @@ -232,9 +270,9 @@ static void set_process_active(bool flag, pid_t pid) /* Send dbug to resourced */ ret = dbus_handle_emit_dbus_signal(NULL, RESOURCED_PATH_PROCESS, - RESOURCED_INTERFACE_PROCESS, - RESOURCED_METHOD_ACTIVE, - g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); + RESOURCED_INTERFACE_PROCESS, + RESOURCED_METHOD_ACTIVE, + g_variant_new("(si)", (flag ? ACTIVE_ACT : INACTIVE_ACT), pid)); if (ret < 0) _E("Failed to send dbus signal to resourced."); } @@ -288,17 +326,64 @@ void change_proc_change_state(int (*func)(unsigned int cond, pid_t pid)) proc_change_state = func; } +static inline long clock_gettime_to_long(void) +{ + struct timespec now; + int ret; + + ret = clock_gettime(CLOCK_REALTIME, &now); + + if (ret < 0) { + _E("Failed to clock gettime!"); + return 0; + } + + return SEC_TO_MSEC(now.tv_sec) + NSEC_TO_MSEC(now.tv_nsec); +} + +static int display_brightness_changed(void *data) +{ + int brt, ret; + + brt = DATA_VALUE_INT(data); + + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "Brightness", + g_variant_new("(i)", brt)); + if (ret < 0) + _E("Failed to send dbus signal Brightness."); + + return 0; +} + +static int display_auto_brightness_sensing(void *data) +{ + if (!transit_timer) + return 0; + + g_source_remove(transit_timer); + transit_timer = 0; + + return 0; +} + static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) { const char *str; const char *signal; int ret; + long diff = 0; if (type <= SIGNAL_INVALID || type >= SIGNAL_MAX) { _E("Invalid signal type(%d).", type); return; } + if (type == SIGNAL_PRE && displayoff_time != 0) + diff = clock_gettime_to_long() - displayoff_time; + if (flags & LCD_ON_BY_GESTURE) str = GESTURE_STR; else if (flags & LCD_ON_BY_POWER_KEY) @@ -316,7 +401,7 @@ static void broadcast_lcd_on(enum signal_type type, enum device_flags flags) DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, signal, - g_variant_new("(s)", str)); + g_variant_new("(si)", str, diff)); if (ret < 0) _E("Failed to send dbus signal(%s)", signal); } @@ -332,6 +417,9 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) return; } + if (type == SIGNAL_PRE) + displayoff_time = clock_gettime_to_long(); + signal = lcdoff_sig_lookup[type]; if (flags & LCD_OFF_BY_POWER_KEY) @@ -340,6 +428,12 @@ static void broadcast_lcd_off(enum signal_type type, enum device_flags flags) str = TIMEOUT_STR; else if (flags & LCD_OFF_BY_EVENT) str = EVENT_STR; + else if (flags & LCD_OFF_BY_PROXIMITY) + str = PROXI_STR; + else if (flags & LCD_OFF_BY_PALM) + str = PALM_STR; + else if (flags & LCD_OFF_BY_GESTURE) + str = GESTURE_STR; else str = UNKNOWN_STR; @@ -370,9 +464,6 @@ static unsigned long get_lcd_on_flags(void) if (lcd_paneloff_mode) flags |= LCD_PANEL_OFF_MODE; - if (stay_touchscreen_off) - flags |= TOUCH_SCREEN_OFF_MODE; - if (ambient_get_condition() == true) { flags |= AMBIENT_MODE; flags |= LCD_PHASED_TRANSIT_MODE; @@ -386,6 +477,18 @@ bool touch_event_blocked(void) return touch_blocked; } +static gboolean late_transit_on(void *data) +{ + if (!transit_timer) + return G_SOURCE_REMOVE; + + g_source_remove(transit_timer); + transit_timer = 0; + + backlight_ops.transit_state(DPMS_ON); + return G_SOURCE_REMOVE; +} + void lcd_on_procedure(int state, enum device_flags flag) { dd_list *l = NULL; @@ -393,19 +496,29 @@ void lcd_on_procedure(int state, enum device_flags flag) unsigned long flags = get_lcd_on_flags(); flags |= flag; - /* send LCDOn dbus signal */ - if (!lcdon_broadcast) { - broadcast_lcd_on(SIGNAL_PRE, flags); - lcdon_broadcast = true; - } + /* + * Display on procedure + * step 1. broadcast lcd on signal with cause + * step 2. set brightness + * step 3. set pmstate of vconf + * step 4. display on operate + * - a. display on + * - b. TSP(touch screen) and touchkey enable + * step 5. broadcast lcd on complete siganl + * step 6. key backlight enable + */ + _I("[lcdstep] %lu", flags); if (flags & AMBIENT_MODE) { - if (ambient_get_state() == false && - backlight_ops.get_lcd_power() == DPMS_ON) + if (ambient_get_state() == false && backlight_ops.get_lcd_power() == DPMS_ON) return; ambient_set_state(false); } + /* send LCDOn dbus signal */ + if (!lcdon_broadcast) + broadcast_lcd_on(SIGNAL_PRE, flags); + if (!(flags & LCD_PHASED_TRANSIT_MODE)) { /* Update brightness level */ if (state == LCD_DIM) @@ -422,7 +535,13 @@ void lcd_on_procedure(int state, enum device_flags flag) DD_LIST_FOREACH(lcdon_ops, l, ops) ops->start(flags); - broadcast_lcd_on(SIGNAL_POST, flags); + if (!lcdon_broadcast) { + broadcast_lcd_on(SIGNAL_POST, flags); + if (flags & LCD_PHASED_TRANSIT_MODE) + transit_timer = g_timeout_add_seconds(LATE_LCD_TRANSIT, + late_transit_on, NULL); + lcdon_broadcast = true; + } if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(true); @@ -430,7 +549,7 @@ void lcd_on_procedure(int state, enum device_flags flag) touch_blocked = false; } -static inline unsigned long get_lcd_off_flags(void) +static unsigned long get_lcd_off_flags(void) { unsigned long flags = NORMAL_MODE; @@ -439,10 +558,12 @@ static inline unsigned long get_lcd_off_flags(void) flags |= LCD_PHASED_TRANSIT_MODE; } + if (stay_touchscreen_off) + flags |= TOUCH_SCREEN_OFF_MODE; + return flags; } - inline void lcd_off_procedure(enum device_flags flag) { dd_list *l = NULL; @@ -450,6 +571,20 @@ inline void lcd_off_procedure(enum device_flags flag) unsigned long flags = get_lcd_off_flags(); flags |= flag; + /* + * Display off procedure + * step 0. enhance mode off using nofity (e.g mdnie, HBM, LBM) + * step 1. broadcast lcd off signal with cause + * step 2. set pmstate of vconf + * step 3. display off operate + * - a. display off + * - b. TSP(touch screen) and touchkey disable + * step 4. broadcast lcd off complete siganl + */ + _I("[lcdstep] %lu", flags); + + device_notify(DEVICE_NOTIFIER_LCD_OFF, NULL); + touch_blocked = true; if (flags & AMBIENT_MODE) { @@ -462,18 +597,23 @@ inline void lcd_off_procedure(enum device_flags flag) broadcast_lcd_off(SIGNAL_PRE, flags); lcdon_broadcast = false; } + set_setting_pmstate(S_LCDOFF); + if (CHECK_OPS(keyfilter_ops, backlight_enable)) keyfilter_ops->backlight_enable(false); - set_setting_pmstate(S_LCDOFF); + if (transit_timer) { + g_source_remove(transit_timer); + transit_timer = 0; + } + + if (flags & LCD_PHASED_TRANSIT_MODE) + backlight_ops.transit_state(DPMS_OFF); DD_LIST_FOREACH(lcdon_ops, l, ops) ops->stop(flags); if (flags & AMBIENT_MODE) - /* Do not broadcast the post signal here. - * The signal will be broadcasted - * after showing Ambient clock */ broadcast_lcd_off_late(flags); else broadcast_lcd_off(SIGNAL_POST, flags); @@ -481,20 +621,20 @@ inline void lcd_off_procedure(enum device_flags flag) void set_stay_touchscreen_off(int val) { - _D("stay touch screen off: %d", val); + _I("Stay touch screen off: %d", val); stay_touchscreen_off = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } void set_lcd_paneloff_mode(int val) { - _D("lcd paneloff mode: %d", val); + _I("Lcd paneloff mode: %d", val); lcd_paneloff_mode = val; - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); - set_setting_pmstate(LCD_NORMAL); + if (disp_plgn.pm_change_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } int low_battery_state(int val) @@ -538,7 +678,7 @@ static void makeup_trans_condition(void) static PmLockNode *find_node(enum state_t s_index, pid_t pid) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; DD_LIST_FOREACH(cond_head[s_index], elem, t) { if (t->pid == pid) @@ -551,21 +691,28 @@ static PmLockNode *find_node(enum state_t s_index, pid_t pid) static PmLockNode *add_node(enum state_t s_index, pid_t pid, guint timeout_id, bool holdkey_block) { + guint warning_id = 0; PmLockNode *n; time_t now; n = (PmLockNode *) malloc(sizeof(PmLockNode)); if (n == NULL) { - _E("Failed to add cond. Not enough memory."); + _E("Not enough memory, add cond. fail"); return NULL; } + if (pid < INTERNAL_LOCK_BASE) + warning_id = g_timeout_add_seconds(display_conf.lightsensor_interval, + warning_cb[s_index], (void *)((intptr_t)pid)); + time(&now); n->pid = pid; n->timeout_id = timeout_id; + n->warning_id = warning_id; n->time = now; n->holdkey_block = holdkey_block; n->background = false; + n->broadcast_warning = true; DD_LIST_APPEND(cond_head[s_index], n); refresh_app_cond(); @@ -584,6 +731,11 @@ static int del_node(enum state_t s_index, PmLockNode *n) g_source_remove(n->timeout_id); n->timeout_id = 0; } + if (n->warning_id) { + g_source_remove(n->warning_id); + n->warning_id = 0; + } + free(n); refresh_app_cond(); return 0; @@ -591,6 +743,7 @@ static int del_node(enum state_t s_index, PmLockNode *n) static void print_node(int next) { + int ret; dd_list *elem; PmLockNode *n; char buf[30]; @@ -605,10 +758,20 @@ static void print_node(int next) diff = difftime(now, n->time); ctime_r(&n->time, buf); - if (diff > LOCK_TIME_WARNING) - _W("over=%.0f s pid=%5d locktime=%s", diff, n->pid, buf); - else - _I("pid=%5d locktime=%s", n->pid, buf); + if (diff > LOCK_TIME_WARNING) { + if (diff > LOCK_TIME_WARNING * 60 && n->pid < INTERNAL_LOCK_BASE && n->broadcast_warning) { + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_over", + g_variant_new("(i)", n->pid)); + if (ret < 0) + _E("Failed to send dbus signal pmlock_over."); + n->broadcast_warning = false; + } + _W("Over(%.0f s) pid( %5d) lock time(%s)", diff, n->pid, buf); + } else + _I("Pid(%5d) lock time(%s)", n->pid, buf); } } @@ -641,7 +804,6 @@ void get_pname(pid_t pid, char *pname) static void del_state_cond(void *data, enum state_t state) { PmLockNode *tmp = NULL; - char pname[PATH_MAX]; pid_t pid; if (!data) @@ -649,21 +811,20 @@ static void del_state_cond(void *data, enum state_t state) /* A passed data is a pid_t type data, not a 64bit data. */ pid = (pid_t)((intptr_t)data); - _I("Delete process(%d)'s prohibit dim condition by timeout.", pid); + _I("delete prohibit dim condition by timeout (%d)", pid); if (pid == INTERNAL_LOCK_AMBIENT) ambient_check_invalid_state(pid); tmp = find_node(state, pid); del_node(state, tmp); - get_pname(pid, pname); - set_unlock_time(pname, state); + set_unlock_time(pid, state); if (!timeout_src_id) states[pm_cur_state].trans(EVENT_TIMEOUT); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); } static gboolean del_normal_cond(void *data) @@ -684,23 +845,91 @@ static gboolean del_off_cond(void *data) return G_SOURCE_REMOVE; } -/* timeout handler */ -gboolean timeout_handler(void *data) +static void pmlock_check_cb(GVariant *var, void *user_data, GError *err) { - int run_timeout; + pid_t pid; + int ret, state; + char *app_id; - _I("Time out state %s.\n", states[pm_cur_state].name); - /* default setting */ - get_run_timeout(&run_timeout); + if (!var) + return; - /* for sdk - * if the run_timeout is zero, it regards AlwaysOn state - */ - if (pm_cur_state == S_NORMAL && (run_timeout == 0 || display_conf.lcd_always_on)) { - _D("'run_timeout' is always on."); - return G_SOURCE_CONTINUE; + if (!dh_get_param_from_var(var, "(iis)", &pid, &state, &app_id)) { + _E("Failed to notify low: no message(%s)", g_variant_get_type_string(var)); + goto out; } + _W("%s(%d) was requested pmlock for a long time.", app_id, pid); + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "pmlock_expired", + g_variant_new("(i)", pid)); + if (ret < 0) + _E("Failed to send dbus pmlock_expired"); + +out: + g_variant_unref(var); +} + +/* + * Any process is possible many time lock, deviced can not know malicious + * or good process. so infinity or more then 1 min lock process, deviced + * will be checked it to resoured. And then, it will be asked quit or maintain to user. + */ +static void pmlock_check(void *data, char *st) +{ + const char *arr[2]; + char chr_pid[PID_MAX]; + pid_t pid; + int ret; + + if (!data || !st) + return; + + if (!strncmp(st, "lcdoff", 4) && backlight_ops.get_lcd_power() == DPMS_ON) { + _D("Lcd state is PM_LCD_POWER_ON"); + return; + } + + pid = (pid_t)((intptr_t)data); + snprintf(chr_pid, sizeof(chr_pid), "%d", pid); + + arr[0] = chr_pid; + arr[1] = st; + + ret = dbus_handle_method_async_with_reply(RESOURCED_BUS_NAME, + RESOURCED_PATH_PROCESS, + RESOURCED_INTERFACE_PROCESS, + METHOD_APP_STATUS, + "is", arr, pmlock_check_cb, -1, NULL); + if (ret < 0) + _E("Failed to call dbus method"); +} + +static gboolean pmlock_normal_check(void *data) +{ + pmlock_check(data, "normal"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_dim_check(void *data) +{ + pmlock_check(data, "lcddim"); + return G_SOURCE_CONTINUE; +} + +static gboolean pmlock_off_check(void *data) +{ + pmlock_check(data, "lcdoff"); + return G_SOURCE_CONTINUE; +} + +/* timeout handler */ +gboolean timeout_handler(void *data) +{ + _I("Time out state %s", states[pm_cur_state].name); + if (timeout_src_id) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -715,7 +944,7 @@ void reset_timeout(int timeout) if (!display_conf.timeout_enable) return; - _I("Reset timeout(%d ms)", timeout); + _I("Reset timeout(%d ms).", timeout); if (timeout_src_id != 0) { g_source_remove(timeout_src_id); timeout_src_id = 0; @@ -756,7 +985,7 @@ static int get_lcd_timeout_from_settings(void) if (val > 0) states[i].timeout = val; - _I("state=%s timeout=%d ms", states[i].name, + _I("State(%s) timeout(%d) ms", states[i].name, states[i].timeout); } @@ -779,7 +1008,7 @@ static void update_display_time(void) if (custom_normal_timeout > 0) { states[S_NORMAL].timeout = custom_normal_timeout; states[S_LCDDIM].timeout = custom_dim_timeout; - _I("CUSTOM: Timeout(%d ms) and dim(%d ms) are set by normal.", + _I("CUSTOM : timeout is set by normal(%d ms), dim(%d ms)", custom_normal_timeout, custom_dim_timeout); return; } @@ -810,7 +1039,8 @@ static void update_display_time(void) get_dim_timeout(&val); states[S_LCDDIM].timeout = val; - _I("Normal: timeout(%d ms) and dim(%d ms) are set.", states[S_NORMAL].timeout, states[S_LCDDIM].timeout); + _I("Normal: NORMAL timeout is set by %d ms", states[S_NORMAL].timeout); + _I("Normal: DIM timeout is set by %d ms", states[S_LCDDIM].timeout); } static void update_display_locktime(int time) @@ -819,7 +1049,6 @@ static void update_display_locktime(int time) update_display_time(); } - void set_dim_state(bool on) { _I("Dim state is %d.", on); @@ -827,31 +1056,58 @@ void set_dim_state(bool on) states[pm_cur_state].trans(EVENT_INPUT); } +static void broadcast_pm_suspend(void) +{ + int ret; -void lcd_on_direct(enum device_flags flags) + if (pmstate_suspend) + return; + + _D("PM will be changed to sleep."); + + pmstate_suspend = PM_SUSPEND; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "sleep", + NULL); + if (ret < 0) + _E("Failed to send dbus signal sleep."); +} + +static void broadcast_pm_wakeup(void) { - int ret, call_state; + int ret; + + if (!pmstate_suspend) + return; + + _D("PM is changed to wakeup."); + + pmstate_suspend = PM_WAKEUP; + ret = dbus_handle_emit_dbus_signal(NULL, + DEVICED_PATH_DISPLAY, + DEVICED_INTERFACE_DISPLAY, + "wakeup", + NULL); + if (ret < 0) + _E("Failed to send dbus signal wakeup."); +} + +void lcd_on_direct(enum device_flags flags) +{ if (power_ops.get_power_lock_support() - && pm_cur_state == S_SLEEP) + && pm_cur_state == S_SLEEP) { + broadcast_pm_wakeup(); power_ops.power_lock(); + pm_cur_state = S_NORMAL; + } -#ifdef MICRO_DD - _D("Lcd is on directly."); + _D("lcd is on directly"); gettimeofday(&lcdon_tv, NULL); lcd_on_procedure(LCD_NORMAL, flags); - reset_timeout(DD_LCDOFF_INPUT_TIMEOUT); -#else - ret = vconf_get_int(VCONFKEY_CALL_STATE, &call_state); - if ((ret >= 0 && call_state != VCONFKEY_CALL_OFF) || - (__get_lock_screen_state() == VCONFKEY_IDLE_LOCK)) { - _D("LOCK state, lcd is on directly."); - lcd_on_procedure(LCD_NORMAL, flags); - } else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - reset_timeout(display_conf.lcdoff_timeout); -#endif + update_display_locktime(LOCK_SCREEN_INPUT_TIMEOUT); } @@ -863,6 +1119,56 @@ static inline bool check_lcd_is_on(void) return true; } +static int check_lock_condition(enum state_t state) +{ + dd_list *elem; + PmLockNode *t = NULL; + int ret = false; + pid_t owner = getpid(); + + _D("check holdkey block : state of %s", states[state].name); + + DD_LIST_FOREACH(cond_head[state], elem, t) { + if (t->pid != owner && t->background == false) { + ret = true; + _I("state change was blocked by pid(%d)!", t->pid); + break; + } + } + + return ret; +} + +static gboolean timer_refresh_cb(gpointer data) +{ + struct state *st; + int v, ret; + + ret = vconf_get_int(VCONFKEY_HOMESCREEN_WATCHFACE_VISIBILITY, &v); + if (ret < 0) + _E("Failed to get homescreen watchface visibility"); + + if (!v) + return 0; + + /** + * In watchface, it will be applied at 5 seconds for reduce power-supply. + * When the device's screen is another app, it will do turn off after 7 seconds. + */ + if (set_custom_lcdon_timeout(5000) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + if (st->action) + st->action(st->timeout); + + return 0; +} + int custom_lcdon(int timeout) { struct state *st; @@ -886,9 +1192,157 @@ int custom_lcdon(int timeout) if (st->action) st->action(st->timeout); + g_idle_add(timer_refresh_cb, NULL); + return 0; } +int custom_lcdoff(enum device_flags flag) +{ + struct state *st; + + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + /* + * When another proccess is normal lock, device is received call then, + * call app can be changed to lcd state by proximity. + * If proximity is near then normal lock will be unlocked. + */ + if (flag & LCD_OFF_BY_PROXIMITY) { + _I("custom lcd off by proximity, delete normal lock"); + delete_condition(S_NORMAL); + } else { + _I("skip custom lcd off"); + return -ECANCELED; + } + } + + _I("custom lcd off by flag(%d)", flag); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + if (set_custom_lcdon_timeout(0) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_on(char *reason, int timeout) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) + flag = LCD_ON_BY_GESTURE; + else if (!strncmp(reason, EVENT_STR, str_len)) + flag = LCD_ON_BY_EVENT; + else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + if (timeout <= 0) { + _E("Cannot setting timeout %d", timeout); + return -EINVAL; + } + + if (check_lcd_is_on() == false) + lcd_on_direct(flag); + + _I("platform lcd on by %s (%d ms)", reason, timeout); + if (set_custom_lcdon_timeout(timeout) == true) + update_display_time(); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_NORMAL; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +static int display_platform_off(char *reason) +{ + struct state *st; + int flag; + int str_len; + + str_len = strlen(reason); + + if (!strncmp(reason, GESTURE_STR, str_len)) { + check_processes(S_NORMAL); + check_processes(S_LCDDIM); + + /* check holdkey block flag in lock node */ + if (check_lock_condition(S_NORMAL) || check_lock_condition(S_LCDDIM)) { + _I("skip platform lcd off by gesture"); + return -ECANCELED; + } + flag = LCD_OFF_BY_GESTURE; + } else if (!strncmp(reason, PALM_STR, str_len)) { + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); + + flag = LCD_OFF_BY_PALM; + } else { + _E("Reason is unkown(%s)", reason); + return -EINVAL; + } + + _I("platform lcd off by %s", reason); + if (backlight_ops.get_lcd_power() == DPMS_ON) + lcd_off_procedure(flag); + + /* state transition */ + pm_old_state = pm_cur_state; + pm_cur_state = S_LCDOFF; + st = &states[pm_cur_state]; + + /* enter action */ + if (st->action) + st->action(st->timeout); + + return 0; +} + +int display_platform_control(int type, char *reason, int timeout) +{ + int ret; + + switch (type) { + case PLATFORM_DISPLAY_ON: + ret = display_platform_on(reason, timeout); + break; + case PLATFORM_DISPLAY_OFF: + ret = display_platform_off(reason); + break; + default: + _E("Unkown type(%d)", type); + ret = -EINVAL; + } + + return ret; +} + static void default_proc_change_state_action(enum state_t next, int timeout) { struct state *st; @@ -924,7 +1378,7 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) default_proc_change_state_action(next, -1); break; case S_LCDOFF: - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_EVENT); if (set_custom_lcdon_timeout(0)) update_display_time(); @@ -935,7 +1389,14 @@ static int default_proc_change_state(unsigned int cond, pid_t pid) /* at first LCD_OFF and then goto sleep */ /* state transition */ default_proc_change_state_action(S_LCDOFF, TIMEOUT_NONE); + delete_condition(S_NORMAL); + delete_condition(S_LCDDIM); delete_condition(S_LCDOFF); + if (lcdon_broadcast) { + _I("broadcast lcd off signal at non-lcd device"); + broadcast_lcd_off(SIGNAL_PRE, 0); + broadcast_lcd_off(SIGNAL_POST, 0); + } default_proc_change_state_action(S_SLEEP, TIMEOUT_NONE); break; @@ -970,15 +1431,18 @@ static void proc_condition_lock(PMMsg *data) pid_t pid = data->pid; enum state_t state; int holdkey_block; + bool value = true; + unsigned int flags; state = GET_COND_STATE(data->cond); - if (!state) + if (state == S_START) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); - if (state == S_LCDOFF && - pm_cur_state == S_SLEEP) + if (state == S_LCDOFF && pm_cur_state == S_SLEEP && + power_ops.get_power_lock() == POWER_UNLOCK) proc_change_state(data->cond, INTERNAL_LOCK_PM); if (data->timeout > 0) { @@ -1004,14 +1468,15 @@ static void proc_condition_lock(PMMsg *data) } if (state == S_LCDOFF) - set_process_active(TRUE, pid); + set_process_active(true, pid); + _I("[%s] locked by %5d with %u ms", states[state].name, pid, data->timeout); /* for debug */ - _SD("[%s] Locked by pid=%d process=%s holdkeyblock=%d\n", - states[state].name, pid, pname, holdkey_block); - set_lock_time(pname, state); + _SD("be requested LOCK info pname(%s), holdkeyblock(%d) flags(%d)", + pname, holdkey_block, flags); + set_lock_time(pid, pname, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)true); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static void proc_condition_unlock(PMMsg *data) @@ -1020,24 +1485,28 @@ static void proc_condition_unlock(PMMsg *data) enum state_t state; PmLockNode *tmp; char pname[PATH_MAX]; + bool value = false; + unsigned int flags; state = GET_COND_STATE(data->cond); if (!state) return; + flags = GET_COND_FLAG(data->cond); get_pname(pid, pname); tmp = find_node(state, pid); del_node(state, tmp); if (state == S_LCDOFF) - set_process_active(FALSE, pid); + set_process_active(false, pid); - _SD("[%s] Unlocked by pid=%d process=%s\n", - states[state].name, pid, pname); - set_unlock_time(pname, state); + _I("[%s] unlocked by %5d", states[state].name, pid); + /* for debug */ + _SD("be requested UNLOCK info pname(%s) flag(%d)", pname, flags); + set_unlock_time(pid, state); - device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)false); + device_notify(DEVICE_NOTIFIER_DISPLAY_LOCK, (void *)&value); } static int proc_condition(PMMsg *data) @@ -1056,15 +1525,11 @@ static int proc_condition(PMMsg *data) flags = GET_COND_FLAG(data->cond); if (flags == 0) { /* guard time for suspend */ - if (pm_cur_state == S_LCDOFF) { + if (pm_cur_state == S_LCDOFF) reset_timeout(states[S_LCDOFF].timeout); - _I("Margin timeout(%d ms)", states[S_LCDOFF].timeout); - } } else { - if (flags & PM_FLAG_RESET_TIMER) { + if (flags & PM_FLAG_RESET_TIMER) reset_timeout(states[pm_cur_state].timeout); - _I("Reset timeout(%d ms)", states[pm_cur_state].timeout); - } } if (!timeout_src_id) @@ -1077,13 +1542,13 @@ static int proc_condition(PMMsg *data) int check_processes(enum state_t prohibit_state) { dd_list *elem, *next; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; DD_LIST_FOREACH_SAFE(cond_head[prohibit_state], elem, next, t) { if (t->pid < INTERNAL_LOCK_BASE && kill(t->pid, 0) == -1) { - _E("Process(%d) does not exist, delete the REQ" - " - prohibit state=%d.", + _E("%d process does not exist, delete the REQ" + " - prohibit state %d ", t->pid, prohibit_state); if (t->pid == custom_change_pid) { get_lcd_timeout_from_settings(); @@ -1091,6 +1556,7 @@ int check_processes(enum state_t prohibit_state) custom_change_pid = -1; } ret = 1; + set_unlock_time(t->pid, prohibit_state); del_node(prohibit_state, t); } } @@ -1101,7 +1567,7 @@ int check_processes(enum state_t prohibit_state) int check_holdkey_block(enum state_t state) { dd_list *elem; - PmLockNode *t; + PmLockNode *t = NULL; int ret = 0; _I("Check holdkey block: state of %s", states[state].name); @@ -1126,11 +1592,9 @@ int check_holdkey_block(enum state_t state) int delete_condition(enum state_t state) { dd_list *elem, *next; - PmLockNode *t; - pid_t pid; - char pname[PATH_MAX]; + PmLockNode *t = NULL; - _I("Delete condition: state of %s", states[state].name); + _I("delete condition : state of %s", states[state].name); if (!cond_head[state]) return 0; @@ -1140,13 +1604,11 @@ int delete_condition(enum state_t state) g_source_remove(t->timeout_id); t->timeout_id = 0; } - pid = t->pid; if (state == S_LCDOFF) - set_process_active(FALSE, pid); - _I("Delete node of pid(%d).", pid); + set_process_active(false, t->pid); + _I("delete node of pid(%d)", t->pid); + set_unlock_time(t->pid, state); del_node(state, t); - get_pname(pid, pname); - set_unlock_time(pname, state-1); } DD_LIST_FREE_LIST(cond_head[state]); @@ -1188,8 +1650,9 @@ static pm_history pm_history_log[MAX_LOG_COUNT] = {{0, }, }; static int history_count = 0; static const char history_string[PM_LOG_MAX][15] = { - "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON FAIL", - "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF FAIL", "SLEEP"}; + "PRESS", "LONG PRESS", "RELEASE", "LCD ON", "LCD ON COMPL", "LCD ON FAIL", + "LCD DIM", "LCD DIM FAIL", "LCD OFF", "LCD OFF COMPL", "LCD OFF FAIL", + "LCD FAIL", "SLEEP"}; void pm_history_init() { @@ -1242,7 +1705,7 @@ void pm_history_print(int fd, int count) time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } #endif @@ -1266,13 +1729,13 @@ void print_info(int fd) "===========================\n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Timeout Info: Run[%dms] Dim[%dms] Off[%dms]\n", states[S_NORMAL].timeout, states[S_LCDDIM].timeout, states[S_LCDOFF].timeout); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Tran. Locked : %s %s %s\n", (trans_condition & MASK_NORMAL) ? states[S_NORMAL].name : "-", @@ -1280,18 +1743,18 @@ void print_info(int fd) (trans_condition & MASK_OFF) ? states[S_LCDOFF].name : "-"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current State: %s\n", states[pm_cur_state].name); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); snprintf(buf, sizeof(buf), "Current Lock Conditions: \n"); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); for (s_index = S_NORMAL; s_index < S_END; s_index++) { DD_LIST_FOREACH(cond_head[s_index], elem, t) { @@ -1302,7 +1765,7 @@ void print_info(int fd) i++, states[s_index].name, t->pid, pname, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("Write() failed: %d", errno); } } @@ -1313,37 +1776,39 @@ void print_info(int fd) #endif } -void save_display_log(void) +void save_display_log(char *path) { int fd, ret; char buf[255]; time_t now_time; char time_buf[30]; - _D("Internal state is saved."); + _D("internal state is saved!"); time(&now_time); ctime_r(&now_time, time_buf); - fd = open(PM_STATE_LOG_FILE, O_CREAT | O_TRUNC | O_WRONLY, 0644); + fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0644); if (fd != -1) { snprintf(buf, sizeof(buf), "\npm_state_log now-time : %d(s) %s\n\n", (int)now_time, time_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); snprintf(buf, sizeof(buf), "pm_status_flag: %x\n", pm_status_flag); ret = write(fd, buf, strlen(buf)); if (ret < 0) - _E("write() failed: %d", errno); + _E("write() failed (%d)", errno); - snprintf(buf, sizeof(buf), "screen lock status : %d\n", - __get_lock_screen_state()); - ret = write(fd, buf, strlen(buf)); - if (ret < 0) - _E("write() failed: %d", errno); + if (disp_plgn.get_lock_screen_state ) { + snprintf(buf, sizeof(buf), "screen lock status : %d\n", + disp_plgn.get_lock_screen_state()); + ret = write(fd, buf, strlen(buf)); + if (ret < 0) + _E("write() failed (%d)", errno); + } print_info(fd); close(fd); } @@ -1360,7 +1825,9 @@ void save_display_log(void) */ static void sig_hup(int signo) { - save_display_log(); + _I("received sig hub %d", signo); + + pm_save_logdump(); } int check_lcdoff_direct(void) @@ -1374,6 +1841,9 @@ int check_lcdoff_direct(void) if (pm_cur_state != S_LCDDIM) return false; + if (!display_conf.dimming) + return true; + lock = __get_lock_screen_state(); if (lock != VCONFKEY_IDLE_LOCK && hallic_open) return false; @@ -1388,7 +1858,7 @@ int check_lcdoff_direct(void) else if (ret < 0) _E("Failed to get vconf value for cradle status: %d", vconf_get_ext_errno()); - _D("Goto LCDOFF direct(lock=%d hdmi=%d cradle=%d).", lock, hdmi_state, cradle); + _D("Goto LCDOFF direct: lock(%d) hdmi(%d) cradle(%d).", lock, hdmi_state, cradle); return true; } @@ -1482,22 +1952,10 @@ static inline void stop_lock_timer(void) static void check_lock_screen(void) { - int lock_setting, lock_state, app_state, ret; + int lock_state, ret; stop_lock_timer(); - ret = vconf_get_int(VCONFKEY_CALL_STATE, &app_state); - if (ret >= 0 && app_state != VCONFKEY_CALL_OFF) - goto lcd_on; - else if (ret < 0) - _E("Failed to get vconf value for call state: %d", vconf_get_ext_errno()); - - /* check setting of lock screen is enabled. */ - ret = vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, - &lock_setting); - if (ret < 0) - _E("Failed to get vconf value for screen lock type: %d", vconf_get_ext_errno()); - /* check state of lock */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); if (ret < 0 || lock_state == VCONFKEY_IDLE_LOCK) { @@ -1552,10 +2010,12 @@ static int default_action(int timeout) } if (pm_cur_state != pm_old_state && pm_cur_state != S_SLEEP) { - if (power_ops.get_power_lock_support()) + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); power_ops.power_lock(); + } set_setting_pmstate(pm_cur_state); - device_notify(DEVICE_NOTIFIER_LCD, &pm_cur_state); + device_notify(DEVICE_NOTIFIER_LCD, (void *)&pm_cur_state); } if (pm_old_state == S_NORMAL && pm_cur_state != S_NORMAL) { @@ -1595,11 +2055,11 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) { stop_lock_timer(); /* lcd off state : turn off the backlight */ - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); } - if (backlight_ops.get_lcd_power() != DPMS_OFF + if (backlight_ops.get_lcd_power() == DPMS_ON || lcd_paneloff_mode) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); break; @@ -1608,7 +2068,7 @@ static int default_action(int timeout) if (pm_old_state != S_SLEEP && pm_old_state != S_LCDOFF) stop_lock_timer(); - if (backlight_ops.get_lcd_power() != DPMS_OFF) + if (backlight_ops.get_lcd_power() == DPMS_ON) lcd_off_procedure(LCD_OFF_BY_TIMEOUT); if (!power_ops.get_power_lock_support()) { @@ -1635,6 +2095,7 @@ go_suspend: #ifdef ENABLE_PM_LOG pm_history_save(PM_LOG_SLEEP, pm_cur_state); #endif + broadcast_pm_suspend(); if (power_ops.get_power_lock_support()) { if (power_ops.enable_autosleep) power_ops.enable_autosleep(); @@ -1642,24 +2103,9 @@ go_suspend: if (power_ops.power_unlock() < 0) _E("Power unlock state error."); } else { - dd_list *elem, *elem_n; - const struct device_ops *dev; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } - power_ops.suspend(); - - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } - - _I("System wakeup."); - disp_plgn.system_wakeup_flag = true; + _I("system wakeup!!"); + system_wakeup_flag = true; /* Resume !! */ if (power_ops.check_wakeup_src() == EVENT_DEVICE) /* system waked up by devices */ @@ -1740,7 +2186,7 @@ static int poll_callback(int condition, PMMsg *data) if (condition == INPUT_POLL_EVENT) { if (pm_cur_state == S_LCDOFF || pm_cur_state == S_SLEEP) - _I("Power key input."); + _I("Input event signal at Display Off"); time(&now); if (last_t != now || pm_cur_state == S_LCDOFF || @@ -1801,11 +2247,13 @@ static int update_setting(int key_idx, int val) } pm_status_flag |= CHRGR_FLAG; } else { - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { power_saving_func(true); pm_status_flag |= LOWBT_FLAG; @@ -1878,9 +2326,9 @@ static void check_seed_status(void) { int ret = -1; int tmp = 0; - int bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; + int bat_state; int brt = 0; - int lock_state = -1; + int lock_state; /* Charging check */ if ((get_charging_status(&tmp) == 0) && (tmp > 0)) @@ -1899,10 +2347,13 @@ static void check_seed_status(void) } _I("Set brightness(%d) from setting app.", tmp); backlight_ops.set_default_brt(tmp); + backlight_ops.set_brightness(tmp); ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat_state); - if (ret < 0) + if (ret < 0) { + bat_state = VCONFKEY_SYSMAN_BAT_NORMAL; _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); + } if (low_battery_state(bat_state)) { if (!(pm_status_flag & CHRGR_FLAG)) { power_saving_func(true); @@ -1912,9 +2363,10 @@ static void check_seed_status(void) /* lock screen check */ ret = vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state); - if (ret < 0) + if (ret < 0) { + lock_state = -1; _E("Failed to get vconf value for idle lock state: %d", vconf_get_ext_errno()); - + } set_lock_screen_state(lock_state); if (lock_state == VCONFKEY_IDLE_LOCK) { states[S_NORMAL].timeout = lock_screen_timeout; @@ -2048,39 +2500,39 @@ void reset_lcd_timeout(GDBusConnection *conn, static int booting_done(void *data) { - static int done; - - if (!data) - return done; + static bool done = false; + if (data != NULL) { done = *(int*)data; - if (!done) - return done; - - _I("Booting done. Release display and power lock."); - if (disp_plgn.pm_unlock_internal) { - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); - disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + if (done) + return 0; + _I("booting done, unlock LCD_OFF"); + if (disp_plgn.pm_unlock_internal) { + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, PM_SLEEP_MARGIN); + disp_plgn.pm_unlock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, PM_SLEEP_MARGIN); + } } - return done; + return 0; } -int device_poweroff(void *data) +static int process_background(void *data) { - static int off; + pid_t pid; + PmLockNode *node; - if (!data) - return off; + pid = *(pid_t *)data; - off = *(int *)data; - if (off) - _I("Poweroff"); + node = find_node(S_NORMAL, pid); + if (node) { + node->background = true; + _I("%d pid is background, then PM will be unlocked LCD_NORMAL", pid); + } - return off; + return 0; } -static int process_background(void *data) +static int process_foreground(void *data) { pid_t pid; PmLockNode *node; @@ -2089,7 +2541,7 @@ static int process_background(void *data) node = find_node(S_NORMAL, pid); if (node) { - node->background = true; + node->background = false; _I("Process(%d) is background, then PM will be unlocked LCD_NORMAL.", pid); } @@ -2116,22 +2568,6 @@ static int battery_health_changed(void *data) return 0; } -static int process_foreground(void *data) -{ - pid_t pid; - PmLockNode *node; - - pid = *(pid_t *)data; - - node = find_node(S_NORMAL, pid); - if (node) { - node->background = false; - _I("Process(%d) is foreground, then PM will be maintained locked LCD_NORMAL.", pid); - } - - return 0; -} - static int display_load_config(struct parse_result *result, void *user_data) { struct display_config *c = user_data; @@ -2146,49 +2582,58 @@ static int display_load_config(struct parse_result *result, void *user_data) if (MATCH(result->name, "LockScreenWaitingTime")) { SET_CONF(c->lock_wait_time, atof(result->value)); - _D("'lock wait time' is %.3f.", c->lock_wait_time); + _D("lock wait time is %.3f", c->lock_wait_time); } else if (MATCH(result->name, "LongPressInterval")) { SET_CONF(c->longpress_interval, atof(result->value)); - _D("'long press interval' is %.3f.", c->longpress_interval); + _D("long press interval is %.3f", c->longpress_interval); } else if (MATCH(result->name, "LightSensorSamplingInterval")) { SET_CONF(c->lightsensor_interval, atof(result->value)); - _D("'lightsensor interval' is %.3f.", c->lightsensor_interval); + _D("lightsensor interval is %.3f", c->lightsensor_interval); } else if (MATCH(result->name, "LCDOffTimeout")) { SET_CONF(c->lcdoff_timeout, atoi(result->value)); - _D("'lcdoff timeout' is %d ms.", c->lcdoff_timeout); + _D("lcdoff timeout is %d ms", c->lcdoff_timeout); } else if (MATCH(result->name, "BrightnessChangeStep")) { SET_CONF(c->brightness_change_step, atoi(result->value)); - _D("'brightness change step' is %d.", c->brightness_change_step); + _D("brightness change step is %d", c->brightness_change_step); } else if (MATCH(result->name, "LCDAlwaysOn")) { c->lcd_always_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'LCD always on' is %d.", c->lcd_always_on); + _D("LCD always on is %d", c->lcd_always_on); + } else if (MATCH(result->name, "Dimming")) { + c->dimming = (MATCH(result->value, "yes") ? 1 : 0); + _D("Dimming is %d", c->dimming); } else if (MATCH(result->name, "ChangedFrameRateAllowed")) { if (strstr(result->value, "setting")) { c->framerate_app[REFRESH_SETTING] = 1; - _D("'framerate app' is setting"); + _D("framerate app is Setting"); } if (strstr(result->value, "all")) { memset(c->framerate_app, 1, sizeof(c->framerate_app)); - _D("'framerate app' is all"); + _D("framerate app is All"); } } else if (MATCH(result->name, "ControlDisplay")) { c->control_display = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ControlDisplay' is %d.", c->control_display); + _D("ControlDisplay is %d", c->control_display); } else if (MATCH(result->name, "PowerKeyDoublePressSupport")) { c->powerkey_doublepress = (MATCH(result->value, "yes") ? 1 : 0); - _D("'PowerKeyDoublePressSupport' is %d.", c->powerkey_doublepress); + _D("PowerKeyDoublePressSupport is %d", c->powerkey_doublepress); } else if (MATCH(result->name, "AccelSensorOn")) { c->accel_sensor_on = (MATCH(result->value, "yes") ? 1 : 0); - _D("'AccelSensorOn' is %d.", c->accel_sensor_on); + _D("AccelSensorOn is %d", c->accel_sensor_on); } else if (MATCH(result->name, "ContinuousSampling")) { c->continuous_sampling = (MATCH(result->value, "yes") ? 1 : 0); - _D("'ContinuousSampling' is %d.", c->continuous_sampling); + _D("ContinuousSampling is %d", c->continuous_sampling); } else if (MATCH(result->name, "TimeoutEnable")) { c->timeout_enable = (MATCH(result->value, "yes") ? true : false); - _D("'Timeout' is %s.", c->timeout_enable ? "enalbed" : "disabled"); + _D("Timeout is %s", c->timeout_enable ? "enalbed" : "disabled"); } else if (MATCH(result->name, "InputSupport")) { c->input_support = (MATCH(result->value, "yes") ? true : false); - _D("'Input' is %s.", c->input_support ? "supported" : "NOT supported"); + _D("Input is %s", c->input_support ? "supported" : "NOT supported"); + } else if (MATCH(result->name, "LockCheckTimeout")) { + SET_CONF(c->lockcheck_timeout, atoi(result->value)); + _D("LockCheckTimeout is %d", c->lockcheck_timeout); + } else if (MATCH(result->name, "AODTSP")) { + c->aod_tsp = (MATCH(result->value, "yes") ? true : false); + _D("TSP control at is %d at aod", c->aod_tsp); } return 0; @@ -2251,9 +2696,58 @@ static int display_probe(void *data) return 0; } +static int input_init_handler(void) +{ + if (!display_conf.input_support) + return 0; + + g_idle_add(init_input, NULL); + + return 0; +} + +static void esd_action(void) +{ + const struct device_ops *touchscreen_ops = NULL; + + _I("ESD on"); + + touchscreen_ops = find_device("touchscreen"); + + if (!check_default(touchscreen_ops)) + touchscreen_ops->stop(NORMAL_MODE); + backlight_ops.off(NORMAL_MODE); + backlight_ops.on(NORMAL_MODE); + if (!check_default(touchscreen_ops)) + touchscreen_ops->start(NORMAL_MODE); +} + +static void lcd_uevent_changed(struct udev_device *dev) +{ + const char *devpath; + const char *action; + + devpath = udev_device_get_devpath(dev); + if (!devpath) + return; + + if (!fnmatch(LCD_ESD_PATH, devpath, 0)) { + action = udev_device_get_action(dev); + if (!strcmp(action, UDEV_CHANGE)) + esd_action(); + } +} + +static const struct uevent_handler lcd_uevent_ops = { + .subsystem = LCD_EVENT_SUBSYSTEM, + .uevent_func = lcd_uevent_changed, + .data = NULL, +}; + static void display_init(void *data) { int ret, i; + unsigned int flags = (WITHOUT_STARTNOTI | FLAG_X_DPMS); int timeout = 0; bool wm_ready; @@ -2269,11 +2763,16 @@ static void display_init(void *data) _W("Failed to load '%s', use default value: %d", DISPLAY_CONF_FILE, ret); + register_kernel_uevent_control(&lcd_uevent_ops); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); register_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); register_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - register_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); register_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + register_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); + register_notifier(DEVICE_NOTIFIER_LCD_AUTOBRT_SENSING, display_auto_brightness_sensing); + + init_save_userlock(); for (i = INIT_SETTING; i < INIT_END; i++) { switch (i) { @@ -2283,15 +2782,14 @@ static void display_init(void *data) case INIT_INTERFACE: if (display_conf.timeout_enable) get_lcd_timeout_from_settings(); - ret = init_sysfs(); + ret = init_sysfs(flags); break; case INIT_POLL: - _I("Input init."); + _I("input init"); pm_callback = poll_callback; - if (display_conf.input_support) - ret = init_input(); - else - ret = 0; + ret = input_init_handler(); + + pm_lock_detector_init(); break; case INIT_DBUS: _I("Dbus init."); @@ -2312,6 +2810,13 @@ static void display_init(void *data) init_lcd_operation(); check_seed_status(); + /* In smd test, TSP should be turned off if display panel is not existed. */ + if (backlight_ops.get_lcd_power() == -ENOENT) { + _I("Display panel is not existed."); + lcd_direct_control(DPMS_OFF, NORMAL_MODE); + exit_lcd_operation(); + } + /* wm_ready needs to be checked * since display manager can be launched later than deviced. * In the case, display cannot be turned on at the first booting */ @@ -2326,33 +2831,35 @@ static void display_init(void *data) trans_table[S_NORMAL][EVENT_TIMEOUT] = S_NORMAL; } - _I("Start Power managing without noti."); - if (power_ops.get_power_lock_support()) - power_ops.power_lock(); - - pm_cur_state = S_NORMAL; - set_setting_pmstate(pm_cur_state); - - if (display_conf.timeout_enable) { - timeout = states[S_NORMAL].timeout; - /* check minimun lcd on time */ - if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) - timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); - - reset_timeout(timeout); - } + if (flags & WITHOUT_STARTNOTI) { /* start without noti */ + _I("Start Power managing without noti"); + if (power_ops.get_power_lock_support()) { + broadcast_pm_wakeup(); + power_ops.power_lock(); + } + pm_cur_state = S_NORMAL; + vconf_set_int(VCONFKEY_PM_STATE, pm_cur_state); + + status = DEVICE_OPS_STATUS_START; + if (display_conf.timeout_enable) { + timeout = states[S_NORMAL].timeout; + /* check minimun lcd on time */ + if (timeout < SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT)) + timeout = SEC_TO_MSEC(DEFAULT_NORMAL_TIMEOUT); + + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, + STAY_CUR_STATE, timeout); + } - status = DEVICE_OPS_STATUS_START; - /* - * Lock lcd off until booting is done. - * deviced guarantees all booting script is executing. - * Last script of booting unlocks this suspend blocking state. - */ - if (disp_plgn.pm_lock_internal) { - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); - disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_NORMAL, - STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); + /* + * Lock lcd off until booting is done. + * deviced guarantees all booting script is executing. + * Last script of booting unlocks this suspend blocking state. + */ + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_lock_internal(INTERNAL_LOCK_BOOTING, LCD_OFF, + STAY_CUR_STATE, BOOTING_DONE_WATING_TIME); } if (display_conf.input_support) @@ -2376,6 +2883,8 @@ static void display_exit(void *data) if (CHECK_OPS(keyfilter_ops, exit)) keyfilter_ops->exit(); + unregister_kernel_uevent_control(&lcd_uevent_ops); + display_ops_exit(NULL); for (i = i - 1; i >= INIT_SETTING; i--) { @@ -2390,8 +2899,8 @@ static void display_exit(void *data) unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); unregister_notifier(DEVICE_NOTIFIER_PROCESS_BACKGROUND, process_background); unregister_notifier(DEVICE_NOTIFIER_PROCESS_FOREGROUND, process_foreground); - unregister_notifier(DEVICE_NOTIFIER_POWEROFF, device_poweroff); unregister_notifier(DEVICE_NOTIFIER_BATTERY_HEALTH, battery_health_changed); + unregister_notifier(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, display_brightness_changed); exit_input(); break; @@ -2409,6 +2918,8 @@ static void display_exit(void *data) static int display_start(enum device_flags flags) { + const struct display_ops *enhance_ops = NULL; + bool on = true; /* NORMAL MODE */ if (flags & NORMAL_MODE) { if (flags & LCD_PANEL_OFF_MODE) @@ -2417,6 +2928,9 @@ static int display_start(enum device_flags flags) else /* normal lcd on */ backlight_ops.on(flags); + FIND_DISPLAY(enhance_ops, "enhance"); + if (enhance_ops && enhance_ops->func) + enhance_ops->func(RESTORE_ENHANCE_OUTDOOR, &on); return 0; } @@ -2438,7 +2952,7 @@ static int display_start(enum device_flags flags) static int display_stop(enum device_flags flags) { /* NORMAL MODE */ - if (flags & NORMAL_MODE) { + if (flags & NORMAL_MODE || flags & FORCE_OFF_MODE) { backlight_ops.off(flags); return 0; } @@ -2462,7 +2976,7 @@ static int display_status(void) static const struct device_ops display_device_ops = { .priority = DEVICE_PRIORITY_HIGH, - .name = "display", + DECLARE_NAME_LEN("display"), .probe = display_probe, .init = display_init, .exit = display_exit, diff --git a/plugins/wearable/display/device-interface.c b/plugins/wearable/display/device-interface.c index f44c51a..06e101d 100644 --- a/plugins/wearable/display/device-interface.c +++ b/plugins/wearable/display/device-interface.c @@ -29,19 +29,21 @@ #include #include #include -#include +#include #include "ambient-mode.h" #include "core/log.h" #include "core/devices.h" -#include "core/list.h" #include "core/common.h" -#include "display/display-dpms.h" +#include "core/device-notifier.h" #include "util.h" #include "device-interface.h" #include "vconf.h" #include "core.h" #include "device-node.h" +#include "display/display-dpms.h" + +#define SET_SUSPEND_TIME 0.5 #define TOUCH_ON 1 #define TOUCH_OFF 0 @@ -49,7 +51,8 @@ #define LCD_PHASED_MIN_BRIGHTNESS 1 #define LCD_PHASED_MAX_BRIGHTNESS 100 #define LCD_PHASED_CHANGE_STEP 5 -#define LCD_PHASED_DELAY 35000 /* microsecond */ +#define LCD_PHASED_DELAY 10000 /* microsecond */ +#define DUMP_MODE_WAITING_TIME 600000 /* microsecond */ #define POWER_AUTOSLEEP_PATH "/sys/power/autosleep" #define POWER_LOCK_PATH "/sys/power/wake_lock" @@ -57,24 +60,58 @@ #define POWER_WAKEUP_PATH "/sys/power/wakeup_count" #define POWER_STATE_PATH "/sys/power/state" -enum { - POWER_UNLOCK = 0, - POWER_LOCK, -}; +#define DISPLAY_HAL_LIB_PATH "/usr/lib/libdisplay-hal.so" + +#define GESTURE_STR "gesture" +#define POWERKEY_STR "powerkey" +#define EVENT_STR "event" +#define TOUCH_STR "touch" +#define BEZEL_STR "bezel" +#define TIMEOUT_STR "timeout" +#define PROXIMITY_STR "proximity" +#define PALM_STR "palm" +#define UNKNOWN_STR "unknown" + +#define FREEZER_VITAL_WAKEUP_CGROUP "/sys/fs/cgroup/freezer/vital_wakeup/freezer.state" struct _backlight_ops backlight_ops; struct _power_ops power_ops; +static int mainlock_status = POWER_UNLOCK; static bool custom_status; static int custom_brightness; static int force_brightness; static int default_brightness; - +static int vital_support = -2; +static int vital_service; +static bool vital_sleep; +static int dpms_running_state = DPMS_SETTING_DONE; static struct display_device *display_dev; +static guint release_timer; + +struct display_device *display_dev_get(void) +{ + return display_dev; +} + +void dpms_set_running_state(int val) +{ + dpms_running_state = val; +} -static int bl_onoff(int on) +static int bl_onoff(int on, enum device_flags flags) { dpms_set_state(on); + +#ifdef ENABLE_PM_LOG + if (on == DPMS_ON) + pm_history_save(PM_LOG_LCD_ON_COMPLETE, pm_cur_state); + else if (on == DPMS_OFF || on == DPMS_FORCE_OFF) + pm_history_save(PM_LOG_LCD_OFF_COMPLETE, pm_cur_state); + else + pm_history_save(PM_LOG_LCD_CONTROL_FAIL, on); +#endif + return 0; } @@ -85,12 +122,6 @@ static int bl_brt(int brightness, int delay) if (delay > 0) usleep(delay); - if (force_brightness > 0) { - _I("brightness=%d force brightness=%d", - brightness, force_brightness); - brightness = force_brightness; - } - /* Update device brightness */ ret = backlight_ops.set_brightness(brightness); @@ -115,39 +146,96 @@ static int system_enable_autosleep(void) return sys_set_str(POWER_AUTOSLEEP_PATH, "mem"); } -static int system_power_lock(void) +static int vital_mode_support(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; - int ret; + if (vital_support < 0) { + FILE *fp; + + fp = fopen(FREEZER_VITAL_WAKEUP_CGROUP, "r"); + if (fp == NULL) { + _E("%s open failed", FREEZER_VITAL_WAKEUP_CGROUP); + /* read max 2 times to check if this file exist */ + vital_support++; + return 0; + } + vital_support = 1; + fclose(fp); + } + return vital_support; +} - _I("system power lock."); - ret = sys_set_str(POWER_LOCK_PATH, "mainlock"); +static int suspend_other_process(int type) +{ + int ret = 0; + char buf[8]; + const char *command[1]; - /* Devices Resume */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->resume) - dev->resume(); - } + if (vital_service == type) + return ret; + if (type == VITAL_WAKEUP && vital_service > VITAL_SLEEP) + return ret; + + vital_service = type; + + if (!vital_mode_support()) + return ret; + + if (type == VITAL_SLEEP) { + snprintf(buf, sizeof(buf), "%s", "sleep"); + command[0] = buf; + dbus_handle_method_sync_timeout(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", + command, + SET_SUSPEND_TIME*1000); + vital_sleep = true; + } else if (type == VITAL_WAKEUP) { + snprintf(buf, sizeof(buf), "%s", "wakeup"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + } else if (type == VITAL_EXIT) { + snprintf(buf, sizeof(buf), "%s", "exit"); + command[0] = buf; + ret = dbus_handle_method_async(RESOURCED_BUS_NAME, + RESOURCED_PATH_FREEZER, + RESOURCED_INTERFACE_FREEZER, + "SetSuspend", + "s", command); + vital_sleep = false; + } return ret; } -static int system_power_unlock(void) +static int system_power_lock(void) { - dd_list *elem, *elem_n; - const struct device_ops *dev; + _I("system power lock"); + suspend_other_process(VITAL_WAKEUP); + mainlock_status = POWER_LOCK; - /* Devices Suspend */ - DD_LIST_FOREACH_SAFE(dev_head, elem, elem_n, dev) { - if (dev->suspend) - dev->suspend(); - } + return sys_set_str(POWER_LOCK_PATH, "mainlock"); +} + +static int system_power_unlock(void) +{ + _I("system power unlock"); + suspend_other_process(VITAL_SLEEP); + mainlock_status = POWER_UNLOCK; - _I("system power unlock."); return sys_set_str(POWER_UNLOCK_PATH, "mainlock"); } +static int system_get_power_lock(void) +{ + return mainlock_status; +} + static int system_get_power_lock_support(void) { static int power_lock_support = -1; @@ -162,7 +250,7 @@ static int system_get_power_lock_support(void) else power_lock_support = true; - _I("system power lock: %s", + _I("System power lock: %s", (power_lock_support ? "support" : "not support")); out: @@ -174,9 +262,6 @@ static int get_lcd_power(void) enum display_state val; int ret; - if (ambient_get_state()) - return DPMS_OFF; - if (!display_dev || !display_dev->get_state) { _E("There is no display device."); return -ENOENT; @@ -186,6 +271,12 @@ static int get_lcd_power(void) if (ret < 0) return ret; + if (val == DISPLAY_ON && ambient_get_state()) + return DPMS_OFF; + + if (dpms_running_state != DPMS_SETTING_DONE) + return dpms_running_state; + switch (val) { case DISPLAY_ON: return DPMS_ON; @@ -202,13 +293,16 @@ static int get_lcd_power(void) bool display_dimstay_check(void) { + if (pm_status_flag & DIM_FLAG) + return true; + if ((pm_status_flag & PWRSV_FLAG) && !(pm_status_flag & BRTCH_FLAG)) return true; return false; } -void change_brightness(int start, int end, int step) +static void change_brightness(int start, int end, int step) { int diff, val; int ret = -1; @@ -226,7 +320,20 @@ void change_brightness(int start, int end, int step) if (prev == end) return; - _D("start=%d end=%d step=%d", start, end, step); + if (pm_status_flag & DIM_MASK) + end = 0; + + _I("start %d end %d step %d", start, end, step); + + if (display_dev && display_dev->set_multi_brightness) { + ret = display_dev->set_multi_brightness(end, step, LCD_PHASED_DELAY); + if (ret < 0) + _E("Failed to set_multi_brightness (%d)", ret); + + backlight_ops.set_brightness(end); + + return; + } diff = end - start; @@ -250,16 +357,15 @@ void change_brightness(int start, int end, int step) static int backlight_on(enum device_flags flags) { int ret = -1; + static int cnt; - _D("LCD on %x", flags); - - ret = bl_onoff(DPMS_ON); - if (ret < 0) - _E("Failed to turn on backlight."); + _I("[DPMS XLIB Backlight] LCD on %x cnt:%d", flags, cnt); - if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(LCD_PHASED_MIN_BRIGHTNESS, - default_brightness, LCD_PHASED_CHANGE_STEP); + cnt++; + ret = bl_onoff(DPMS_ON, flags); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_ON, pm_cur_state); +#endif return ret; } @@ -267,19 +373,30 @@ static int backlight_on(enum device_flags flags) static int backlight_off(enum device_flags flags) { int ret = -1; + static int cnt, ambient_cnt; - _D("LCD off %x", flags); + if (flags & AMBIENT_MODE) { + _I("[DPMS XLIB Backlight] LCD suspend %x cnt:%d", flags, ambient_cnt); + ambient_cnt++; + + return 0; + } + + _I("[DPMS XLIB Backlight] LCD off %x cnt:%d", flags, cnt); + cnt++; if (flags & LCD_PHASED_TRANSIT_MODE) - change_brightness(default_brightness, + backlight_ops.transit_brt(default_brightness, LCD_PHASED_MIN_BRIGHTNESS, LCD_PHASED_CHANGE_STEP); - if (flags & AMBIENT_MODE) - return 0; + if (flags & FORCE_OFF_MODE) + ret = bl_onoff(DPMS_FORCE_OFF, flags); + else + ret = bl_onoff(DPMS_OFF, flags); - ret = bl_onoff(DPMS_OFF); - if (ret < 0) - _E("Failed to turn off backlight."); +#ifdef ENABLE_PM_LOG + pm_history_save(PM_LOG_LCD_OFF, pm_cur_state); +#endif return ret; } @@ -287,15 +404,8 @@ static int backlight_off(enum device_flags flags) static int backlight_dim(void) { int ret; - int brightness; - ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_DIM_BRIGHTNESS, &brightness); - if (ret < 0) { - _E("Failed to get vconf value for lcd dim brightness: %d", vconf_get_ext_errno()); - return -EPERM; - } - - ret = bl_brt(brightness, 0); + ret = backlight_ops.set_brightness(PM_DIM_BRIGHTNESS); #ifdef ENABLE_PM_LOG if (!ret) pm_history_save(PM_LOG_LCD_DIM, pm_cur_state); @@ -335,11 +445,11 @@ static int custom_backlight_update(void) custom_brightness > PM_MAX_BRIGHTNESS) return -EINVAL; - if (display_dimstay_check()) { + if (display_dimstay_check()) ret = backlight_dim(); - } else { - _I("Custom brightness(%d) restored.", custom_brightness); - ret = bl_brt(custom_brightness, 0); + else { + _I("custom brightness restored! %d", custom_brightness); + ret = backlight_ops.set_brightness(custom_brightness); } return ret; @@ -358,16 +468,18 @@ static int set_force_brightness(int level) static int backlight_update(void) { int ret = 0; + int brt; if (get_custom_status()) { - _I("Custom brightness mode. brt no updated."); + _I("custom brightness mode! brt no updated"); return 0; } if (display_dimstay_check()) ret = backlight_dim(); - else - ret = bl_brt(default_brightness, 0); - + else { + brt = backlight_ops.get_default_brt(); + ret = backlight_ops.set_brightness(brt); + } return ret; } @@ -377,7 +489,7 @@ static int backlight_standby(int force) if ((get_lcd_power() == DPMS_ON) || force) { _I("LCD standby"); - ret = bl_onoff(DPMS_STANDBY); + ret = bl_onoff(DPMS_STANDBY, 0); } return ret; @@ -393,6 +505,11 @@ static int set_default_brt(int level) return 0; } +static int get_default_brt(void) +{ + return default_brightness; +} + static int check_wakeup_src(void) { /* TODO if nedded. @@ -470,10 +587,22 @@ static int set_brightness(int val) return max; } + if (force_brightness > 0 && val != PM_DIM_BRIGHTNESS) { + _I("brightness(%d), force brightness(%d)", + val, force_brightness); + val = force_brightness; + } + + if (pm_status_flag & DIM_MASK) + val = 0; + /* Maximum Brightness to users is 100. * Thus real brightness need to be calculated */ val = val * max / 100; + _I("set brightness %d (default:%d)", val, default_brightness); + device_notify(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, (void *)&val); + return display_dev->set_brightness(val); } @@ -550,7 +679,7 @@ static int get_image_effect(enum display_image_effect *effect) enum display_image_effect val; if (!display_dev || !display_dev->get_image_effect) { - _E("There is no display device"); + _E("There is no display device."); return -ENOENT; } @@ -570,7 +699,7 @@ static int set_image_effect(enum display_image_effect effect) int ret; if (!display_dev || !display_dev->set_image_effect) { - _E("There is no display device"); + _E("There is no display device."); return -ENOENT; } @@ -583,6 +712,45 @@ static int set_image_effect(enum display_image_effect effect) return 0; } +static int get_panel_mode(enum display_panel_mode *mode) +{ + int ret; + enum display_panel_mode val; + + if (!display_dev || !display_dev->get_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->get_panel_mode(&val); + if (ret < 0) { + _E("failed to get panel mode(%d)", ret); + return ret; + } + + *mode = val; + + return 0; +} + +static int set_panel_mode(enum display_panel_mode mode) +{ + int ret; + + if (!display_dev || !display_dev->set_panel_mode) { + _E("there is no display device"); + return -ENOENT; + } + + ret = display_dev->set_panel_mode(mode); + if (ret < 0) { + _E("failed to set panel mode(%d)", ret); + return ret; + } + + return 0; +} + static int get_frame_rate(int *rate) { if (!rate) @@ -634,6 +802,101 @@ static int set_frame_rate(int rate) return display_dev->set_frame_rate(rate); } +/* It was operated only AOD enter & leave */ +static int backlight_transit_state(int state) +{ + int brt, val; + int start, end; + + backlight_ops.get_brightness(&brt); + + if (state == DPMS_OFF) { + start = brt; + end = display_conf.aod_enter_level; + + /* + * The value of backlight_ops.get_brightness is system brightness. + * But when device is LBM, the value is not same with real brightness. + * So it should be read exactly value for transit smooth effect + */ + get_brightness(&val); + + if (val > display_conf.aod_enter_level) + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } else { + /* prevent transit effect when another effect is already executed */ + if (brt != display_conf.aod_enter_level) { + _W("effect is already executed brt(%d) aod_level(%d)", + brt, display_conf.aod_enter_level); + return 0; + } + + start = display_conf.aod_enter_level; + end = default_brightness; + backlight_ops.transit_brt(start, end, display_conf.brightness_change_step); + } + + return 0; +} + +static gboolean blink_cb(gpointer data) +{ + static bool flag; + + set_brightness(flag ? PM_MAX_BRIGHTNESS : PM_MIN_BRIGHTNESS); + + flag = !flag; + + return G_SOURCE_CONTINUE; +} + +static void blink(int timeout) +{ + static guint timer; + + if (timer) { + g_source_remove(timer); + timer = 0; + } + + if (timeout < 0) { + _E("timeout value is invalid %d", timeout); + return; + } + + if (timeout == 0) { + backlight_update(); + return; + } + + timer = g_timeout_add(timeout, blink_cb, NULL); +} + +static gboolean release_blink_cb(gpointer data) +{ + blink(0); + + release_timer = 0; + return G_SOURCE_REMOVE; +} + +static void release_blink(void) +{ + if (release_timer) { + g_source_remove(release_timer); + release_timer = 0; + } + + release_timer = g_timeout_add(DUMP_MODE_WAITING_TIME, release_blink_cb, NULL); +} + +static void restore_brightness_func(void) +{ + backlight_ops.set_brightness = set_brightness; + backlight_ops.get_brightness = get_brightness; + backlight_ops.transit_brt = change_brightness; +} + static void _init_ops(void) { backlight_ops.off = backlight_off; @@ -642,6 +905,7 @@ static void _init_ops(void) backlight_ops.update = backlight_update; backlight_ops.standby = backlight_standby; backlight_ops.set_default_brt = set_default_brt; + backlight_ops.get_default_brt = get_default_brt; backlight_ops.get_lcd_power = get_lcd_power; backlight_ops.set_custom_status = set_custom_status; backlight_ops.get_custom_status = get_custom_status; @@ -650,16 +914,24 @@ static void _init_ops(void) backlight_ops.set_force_brightness = set_force_brightness; backlight_ops.set_brightness = set_brightness; backlight_ops.get_brightness = get_brightness; + backlight_ops.restore_brightness_func = restore_brightness_func; backlight_ops.get_brightness_by_light_sensor = get_brightness_by_light_sensor; backlight_ops.get_image_effect = get_image_effect; backlight_ops.set_image_effect = set_image_effect; + backlight_ops.get_panel_mode = get_panel_mode; + backlight_ops.set_panel_mode = set_panel_mode; backlight_ops.get_frame_rate = get_frame_rate; backlight_ops.set_frame_rate = set_frame_rate; + backlight_ops.transit_state = backlight_transit_state; + backlight_ops.transit_brt = change_brightness; + backlight_ops.blink = blink; + backlight_ops.release_blink = release_blink; power_ops.suspend = system_suspend; power_ops.enable_autosleep = system_enable_autosleep; power_ops.power_lock = system_power_lock; power_ops.power_unlock = system_power_unlock; + power_ops.get_power_lock = system_get_power_lock; power_ops.get_power_lock_support = system_get_power_lock_support; power_ops.check_wakeup_src = check_wakeup_src; power_ops.get_wakeup_count = get_wakeup_count; @@ -677,12 +949,12 @@ int display_service_load(void) r = hw_get_info(DISPLAY_HARDWARE_DEVICE_ID, (const struct hw_info **)&info); if (r < 0) { - _I("Display shared library is not supported: %d", r); - return -ENODEV; + _I("display shared library is not supported: %d", r); + return 0; } if (!info->open) { - _E("Failed to open display device: open(NULL)"); + _E("Failed to open display device: open(NULL)."); return -EPERM; } @@ -713,17 +985,44 @@ int display_service_free(void) return 0; } -int init_sysfs() +bool vital_mode(void) +{ + return vital_sleep; +} + +static int vital_state_changed(void *data) +{ + int type; + + assert(data); + + type = *(int *)data; + if (type == VITAL_EXIT) + suspend_other_process(VITAL_EXIT); + + return 0; +} + +int init_sysfs(unsigned int flags) { _init_ops(); + register_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } int exit_sysfs(void) { + int fd; const struct device_ops *ops = NULL; + fd = open("/tmp/sem.pixmap_1", O_RDONLY); + if (fd == -1) { + _E("X server disable"); + backlight_on(NORMAL_MODE); + } + backlight_update(); disconnect_interface_with_dpms(); @@ -735,5 +1034,10 @@ int exit_sysfs(void) if (!check_default(ops)) ops->start(NORMAL_MODE); + if (fd != -1) + close(fd); + + unregister_notifier(DEVICE_NOTIFIER_VITAL_STATE, vital_state_changed); + return 0; } diff --git a/plugins/wearable/display/display-info.h b/plugins/wearable/display/display-info.h new file mode 100644 index 0000000..bf368da --- /dev/null +++ b/plugins/wearable/display/display-info.h @@ -0,0 +1,50 @@ +/* + * deviced + * + * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef __DISPLAY_INFO_H__ +#define __DISPLAY_INFO_H__ + +#define DISPLAY_FUNC(a, b) (((a) << 16) | (b)) +#define ENHANCE_CMD(x) DISPLAY_FUNC('E', (x)) +#define HBM_CMD(x) DISPLAY_FUNC('H', (x)) +#define LBM_CMD(x) DISPLAY_FUNC('L', (x)) + +enum hbm_state { + HBM_SET_STATE = HBM_CMD(1), + HBM_GET_STATE, + HBM_TURN_ON, + HBM_TURN_OFF, + HBM_SET_TIMEOUT_STATE, + HBM_TURN_OFF_STATE, +}; + +enum lbm_state { + LBM_TABLE_LOAD = LBM_CMD(1), +}; + +enum enhance_state { + RESTORE_ENHANCE_OUTDOOR = ENHANCE_CMD(1), +}; + +struct hbmsetstate { + int hbm; + int timeout; +}; + +#endif diff --git a/plugins/wearable/display/enhance.c b/plugins/wearable/display/enhance.c index 4b60807..d799711 100644 --- a/plugins/wearable/display/enhance.c +++ b/plugins/wearable/display/enhance.c @@ -36,6 +36,7 @@ static bool negative_status; static bool greyscale_status; +static bool greysacle_setting; static int enhance_update_state(void) { @@ -70,6 +71,7 @@ static void enhance_greyscale_cb(keynode_t *in_key, void *data) _I("Set greyscale scenario (%d)", val); greyscale_status = val; + greysacle_setting = val; enhance_update_state(); } @@ -108,13 +110,13 @@ static int enhance_ultrapowersaving_changed(void *data) mode = DATA_VALUE_BOOL(data); - greyscale_status = mode; + if (!greysacle_setting) + greyscale_status = mode; enhance_update_state(); _I("Set ultra power saving mode."); return 0; - } static void enhance_init(void *data) @@ -151,6 +153,7 @@ static void enhance_init(void *data) return; } greyscale_status = val; + greysacle_setting = val; state = enhance_update_state(); diff --git a/plugins/wearable/display/key-filter.c b/plugins/wearable/display/key-filter.c index 01e43ff..7835a17 100644 --- a/plugins/wearable/display/key-filter.c +++ b/plugins/wearable/display/key-filter.c @@ -25,6 +25,7 @@ #include #include #include +#include #include "ambient-mode.h" #include "util.h" @@ -36,11 +37,11 @@ #include "core/common.h" #include "core/devices.h" #include "core/device-notifier.h" +#include "shared/common.h" #include "power/power-handler.h" #include "led/touch-key.h" #include "apps/apps.h" -#include #ifndef KEY_SCREENLOCK #define KEY_SCREENLOCK 0x98 #endif @@ -50,23 +51,24 @@ #define PREDEF_LEAVESLEEP "leavesleep" #define POWEROFF_ACT "poweroff" +#define PWROFF_POPUP_ACT "pwroff_popup" #define USEC_PER_SEC 1000000 +#define CSC_CONFIG_MODE_RUNNING 1 #define CAPTURE_COMBINATION_INTERVAL 0.5 /* 0.5 second */ - -#define KEY_MAX_DELAY_TIME 700 /* ms */ - -#define KEY_RELEASED 0 -#define KEY_PRESSED 1 -#define KEY_BEING_PRESSED 2 +#define TORCH_COMBINATION_INTERVAL 0.1 /* 0.1 second */ +#define DEFAULT_COMBINATION_INTERVAL 0.1 /* 0.1 second */ #define LONGKEY_PRESSED_TIME 4 /* 4 second */ +#define KEY_MAX_DELAY_TIME 700 /* ms */ + #define SIGNAL_CHANGE_HARDKEY "ChangeHardkey" #define SIGNAL_LCDON_BY_POWERKEY "LCDOnByPowerkey" #define SIGNAL_LCDOFF_BY_POWERKEY "LCDOffByPowerkey" -#define TOUCH_RELEASE (-1) +#define NORMAL_POWER 0 +#define KEY_TEST_MODE_POWER 2 #define GLOVE_MODE 1 @@ -74,19 +76,21 @@ enum key_combination_flags { KEY_COMBINATION_STOP = 0, KEY_COMBINATION_POWERKEY = BIT(0), KEY_COMBINATION_MENUKEY = BIT(1), + KEY_COMBINATION_VOLUMEUP = BIT(2), + KEY_COMBINATION_VOLUMEDOWN = BIT(3), }; enum combination_process { COMBINATION_STOP = KEY_COMBINATION_STOP, COMBINATION_SCREENCAPTURE = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_MENUKEY, + COMBINATION_TORCH = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEUP, + COMBINATION_QUICKTALK = KEY_COMBINATION_POWERKEY | KEY_COMBINATION_VOLUMEDOWN, }; -int __WEAK__ get_glove_state(void); -void __WEAK__ switch_glove_key(int val); - static struct timeval pressed_time; static guint longkey_timeout_id = 0; static guint longkey_restore_id = 0; +static guint displayon_by_powerkey_timeout_id = 0; static int cancel_lcdoff; static int key_combination = KEY_COMBINATION_STOP; static double combination_pressed_time; @@ -95,27 +99,7 @@ static int skip_lcd_off = false; static int skip_combination = false; static int bezel_wakeup = true; static const struct device_ops *touchled; - -static int bezel_wakeup_cb(void *data) -{ - bezel_wakeup = (int)data; - - return 0; -} - -static int booting_done(void *data) -{ - static int done = 0; - - if (!data) - return done; - - done = *(int *)data; - - _I("Booting done(%d)", done); - - return done; -} +static int booting_check = true; static inline int current_state_in_on(void) { @@ -139,7 +123,7 @@ static void pwroff_popup(void) _E("Failed to launch power off popup."); } -static void longkey_pressed() +static void longkey_pressed(void) { unsigned int caps; @@ -225,7 +209,10 @@ static inline bool switch_on_lcd(enum device_flags flags) return false; } - broadcast_lcdon_by_powerkey(); + if (flags & LCD_ON_BY_POWER_KEY) + broadcast_lcdon_by_powerkey(); + else if (flags & LCD_ON_BY_TOUCH) + _I("Display on by Touch_wakeup event"); lcd_on_direct(flags); @@ -249,15 +236,37 @@ static void check_key_combination(struct input_event *pinput) { double press_time, diff_time; press_time = (pinput->time).tv_sec + USEC_TO_SEC((pinput->time).tv_usec); + diff_time = press_time - combination_pressed_time; switch (key_combination) { case COMBINATION_SCREENCAPTURE: - diff_time = press_time - combination_pressed_time; if (diff_time <= CAPTURE_COMBINATION_INTERVAL) { _I("Combination key : SCREENCAPTURE mode"); skip_combination = true; } break; + case COMBINATION_TORCH: + if (diff_time <= TORCH_COMBINATION_INTERVAL) { + /* When torch combination, display control should be not change. */ + if (displayon_by_powerkey_timeout_id) { + g_source_remove(displayon_by_powerkey_timeout_id); + displayon_by_powerkey_timeout_id = 0; + } + _I("Combination key : TORCH mode"); + skip_combination = true; + } else + key_combination = COMBINATION_STOP; + break; + case COMBINATION_QUICKTALK: + if (diff_time <= DEFAULT_COMBINATION_INTERVAL) { + _I("Combination key : QUICK-TALK mode"); + skip_combination = true; + if (longkey_timeout_id) { + g_source_remove(longkey_timeout_id); + longkey_timeout_id = 0; + } + } + break; default: combination_pressed_time = press_time; return; @@ -274,6 +283,12 @@ static void start_key_combination(struct input_event *pinput) case KEY_MENU: key_combination |= KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination |= KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination |= KEY_COMBINATION_VOLUMEDOWN; + break; default: return; } @@ -295,8 +310,14 @@ static void stop_key_combination(struct input_event *pinput) case KEY_MENU: key_combination &= ~KEY_COMBINATION_MENUKEY; break; + case KEY_VOLUMEUP: + key_combination &= ~KEY_COMBINATION_VOLUMEUP; + break; + case KEY_VOLUMEDOWN: + key_combination &= ~KEY_COMBINATION_VOLUMEDOWN; + break; default: - _E("Thid code(%d) is not combination type", pinput->code); + _E("This code(%d) is not combination type.", pinput->code); break; } } @@ -320,9 +341,8 @@ static int process_menu_key(struct input_event *pinput) return false; _D("No lcd-on capability!"); return true; - } else if (pinput->value == KEY_PRESSED) { + } else if (pinput->value == KEY_PRESSED) switch_on_lcd(LCD_ON_BY_POWER_KEY); - } return false; } @@ -355,7 +375,7 @@ static int decide_lcdoff(void) return false; /* At booting time, display must do not turn off */ - if (!booting_done(NULL)) + if (booting_check) return false; return true; @@ -389,6 +409,37 @@ static int lcdoff_powerkey(void) return ignore; } +static bool key_check_display_on(void) +{ + if (current_state_in_on()) + return false; + + if (backlight_ops.get_lcd_power() == DPMS_ON) { + _W("display power was on"); + return false; + } + + return true; +} + +static gboolean display_on_cb(void *data) +{ + if (displayon_by_powerkey_timeout_id == 0) + return G_SOURCE_REMOVE; + + displayon_by_powerkey_timeout_id = 0; + if (backlight_ops.get_lcd_power() != DPMS_ON || + current_state_in_on() == false) { + broadcast_lcdon_by_powerkey(); + lcd_on_direct(LCD_ON_BY_POWER_KEY); + + if (pm_callback) + (*pm_callback) (INPUT_POLL_EVENT, NULL); + } + + return G_SOURCE_REMOVE; +} + static int process_back_key(struct input_event *pinput) { int ignore = true; @@ -419,9 +470,8 @@ static int process_power_key(struct input_event *pinput) lcdoff_powerkey(); else _D("No lcdoff capability!"); - } else if (skip_lcd_off) { + } else if (skip_lcd_off) ignore = false; - } if (!display_has_caps(caps, DISPLAY_CAPA_LCDON)) ignore = true; @@ -439,7 +489,24 @@ static int process_power_key(struct input_event *pinput) break; case KEY_PRESSED: if (display_has_caps(caps, DISPLAY_CAPA_LCDON)) { - skip_lcd_off = switch_on_lcd(LCD_ON_BY_POWER_KEY); + if (wearable_mode()) + skip_lcd_off = switch_on_lcd(LCD_ON_BY_POWER_KEY); + else { + /* + * LCD does not turn on immediately at mobile. + * It will be turned on after 0.1 second because of torch concept. + */ + skip_lcd_off = key_check_display_on(); + ignore = true; + + if (!displayon_by_powerkey_timeout_id && + backlight_ops.get_lcd_power() != DPMS_ON && + key_combination != COMBINATION_TORCH) { + displayon_by_powerkey_timeout_id = g_timeout_add( + 100, + display_on_cb, NULL); + } + } } else { _D("No lcdon capability!"); skip_lcd_off = false; @@ -458,8 +525,6 @@ static int process_power_key(struct input_event *pinput) LONGKEY_PRESSED_TIME, longkey_restore_cb, NULL); } - if (skip_lcd_off) - ignore = false; cancel_lcdoff = 0; break; @@ -520,10 +585,12 @@ static void process_hardkey_backlight(struct input_event *pinput) _I("Touch is pressed, then hard key is not working!"); return; } - /* Sound & Vibrate only in unlock state */ - if (__get_lock_screen_state() == VCONFKEY_IDLE_UNLOCK - || get_lock_screen_bg_state()) - sound_vibrate_hardkey(); + if (!wearable_mode()) { + /* Sound & Vibrate only in unlock state */ + if (__get_lock_screen_state() == VCONFKEY_IDLE_UNLOCK + || get_lock_screen_bg_state()) + sound_vibrate_hardkey(); + } if (touchled && touchled->execute) { opt = TOUCHLED_PRESS; @@ -543,6 +610,23 @@ static void process_hardkey_backlight(struct input_event *pinput) } } +static void update_vital_state(struct input_event *pinput) +{ + int type; + + /* Change vital state to VITAL_EXIT only if vital mode is active */ + if (!vital_mode()) + return; + + /* Touch or Menu Key Release Event */ + if (pinput->type == EV_ABS || (pinput->type == EV_KEY && + pinput->value == KEY_RELEASED && pinput->code == KEY_MENU)) { + /* Enable all services upon receiving user input, else maintain same state */ + type = VITAL_EXIT; + device_notify(DEVICE_NOTIFIER_VITAL_STATE, &type); + } +} + static int check_key(struct input_event *pinput, int fd) { int ignore = true; @@ -577,6 +661,9 @@ static int check_key(struct input_event *pinput, int fd) break; case KEY_VOLUMEUP: case KEY_VOLUMEDOWN: + if (current_state_in_on()) + ignore = false; + break; case KEY_CAMERA: case KEY_EXIT: case KEY_CONFIG: @@ -642,6 +729,7 @@ static int check_key_filter(void *data, int fd) code = pinput->code; value = pinput->value; + update_vital_state(pinput); ignore = check_key(pinput, fd); restore_custom_brightness(); @@ -650,31 +738,27 @@ static int check_key_filter(void *data, int fd) if (pm_cur_state == S_LCDOFF && bezel_wakeup) { switch_on_lcd(LCD_ON_BY_BEZEL); ignore = false; - } else if (pm_cur_state != S_LCDOFF) { + } else if (pm_cur_state != S_LCDOFF) ignore = false; - } break; case EV_ABS: - if (current_state_in_on()) - ignore = false; - - if (ambient_get_condition() && pinput->value == KEY_PRESSED) { + update_vital_state(pinput); + if (pinput->value == KEY_PRESSED) { switch_on_lcd(LCD_ON_BY_TOUCH); ignore = false; } + if (current_state_in_on()) + ignore = false; + restore_custom_brightness(); - touch_pressed = - (pinput->value == TOUCH_RELEASE ? false : true); + if (pinput->value == KEY_PRESSED) + touch_pressed = true; + else if (pinput->value == KEY_RELEASED) + touch_pressed = false; break; case EV_SW: - if (!get_glove_state || !switch_glove_key) - break; - if (pinput->code == SW_GLOVE && - get_glove_state() == GLOVE_MODE) { - switch_glove_key(pinput->value); - } break; } @@ -684,6 +768,20 @@ static int check_key_filter(void *data, int fd) return 0; } +static int booting_done_cb(void *data) +{ + booting_check = 0; + + return 0; +} + +static int bezel_wakeup_cb(void *data) +{ + bezel_wakeup = (int)data; + + return 0; +} + /* * Default capability * powerkey := LCDON | LCDOFF | POWEROFF @@ -708,15 +806,10 @@ static void keyfilter_init(void) touchled = find_device(TOUCHLED_NAME); - register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); + register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done_cb); register_notifier(DEVICE_NOTIFIER_BEZEL_WAKEUP, bezel_wakeup_cb); } -static void keyfilter_exit(void) -{ - unregister_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); -} - static void key_backlight_enable(bool enable) { int opt; @@ -734,7 +827,6 @@ static void key_backlight_enable(bool enable) static const struct display_keyfilter_ops normal_keyfilter_ops = { .init = keyfilter_init, - .exit = keyfilter_exit, .check = check_key_filter, .set_powerkey_ignore = NULL, .powerkey_lcdoff = NULL, diff --git a/plugins/wearable/display/swim.c b/plugins/wearable/display/swim.c index 3c98ed3..2cbb1e7 100644 --- a/plugins/wearable/display/swim.c +++ b/plugins/wearable/display/swim.c @@ -25,38 +25,41 @@ #include "display/display-ops.h" #include -/* CoreApps */ -#define COREAPPS_PATH_HOME "/Org/Tizen/Coreapps/home" -#define COREAPPS_INTERFACE_HOME "org.tizen.coreapps.home" - -#define COREAPPS_PATH_SWIMMODE COREAPPS_PATH_HOME"/swimmode" -#define COREAPPS_INTERFACE_SWIMMODE COREAPPS_INTERFACE_HOME".swimmode" -#define COREAPPS_SIGNAL_STATUS "status" +#define DBUS_COREAPPS_SWIMMODE_PATH "/Org/Tizen/Coreapps/home/swimmode" +#define DBUS_COREAPPS_SWIMMODE_INTERFACE "org.tizen.coreapps.home.swimmode" +#define DBUS_SWIMMODE_MEMBER_STATUS "status" static const struct device_ops *touchscreen_ops; +static int swimmode_status; static int swim_execute(void *data) { - int state, ret; - static int old_state = -1; + int state; if (check_default(touchscreen_ops)) return 0; state = (int) data; - if (old_state == state) + if (swimmode_status == state) return 0; - if (state) { - _D("Stop touchscreen"); - ret = touchscreen_ops->stop(NORMAL_MODE); + swimmode_status = state; + + /** + * When it is enable, TSP have to change to off and it must not control. + * So if this signal is received, tsp mode would be stopped. + * After that, module would be changed to suspend(execute(STATUS_STOP)). + * The opposite case, the module should be enabled first. + */ + if (swimmode_status) { + touchscreen_ops->stop(TOUCH_SCREEN_OFF_MODE); + touchscreen_ops->execute((void *)DEVICE_OPS_STATUS_STOP); } else { - _D("Start touchscreen"); - ret = touchscreen_ops->start(NORMAL_MODE); + touchscreen_ops->execute((void *)DEVICE_OPS_STATUS_START); + touchscreen_ops->start(NORMAL_MODE); } - old_state = state; - return ret; + return 0; } static void swimmode_signal_handler(GDBusConnection *conn, @@ -69,7 +72,7 @@ static void swimmode_signal_handler(GDBusConnection *conn, { int val; pid_t pid; - bool lcd_on = false; + bool lcd_state = false; g_variant_get(param, "(i)", &val); pid = dbus_connection_get_sender_pid(conn, sender); @@ -78,12 +81,12 @@ static void swimmode_signal_handler(GDBusConnection *conn, if (backlight_ops.get_lcd_power != DPMS_ON) { if (disp_plgn.pm_change_internal) disp_plgn.pm_change_internal(INTERNAL_LOCK_SWIM, S_NORMAL); - lcd_on = true; + lcd_state = true; } swim_execute((void *)val); - if (lcd_on) { + if (lcd_state) { if (disp_plgn.pm_change_internal) disp_plgn.pm_change_internal(INTERNAL_LOCK_SWIM, S_LCDOFF); } @@ -91,7 +94,7 @@ static void swimmode_signal_handler(GDBusConnection *conn, static int swim_restore_cb(void *data) { - _I("Restore swim mode"); + _I("Swim mode is restored."); swim_execute((void *)0); return 0; @@ -104,9 +107,9 @@ static void swim_init(void *data) touchscreen_ops = find_device("touchscreen"); ret = subscribe_dbus_signal(NULL, - COREAPPS_PATH_SWIMMODE, - COREAPPS_INTERFACE_SWIMMODE, - COREAPPS_SIGNAL_STATUS, + DBUS_COREAPPS_SWIMMODE_PATH, + DBUS_COREAPPS_SWIMMODE_INTERFACE, + DBUS_SWIMMODE_MEMBER_STATUS, swimmode_signal_handler, NULL, NULL); if (ret <= 0) @@ -116,7 +119,7 @@ static void swim_init(void *data) } static const struct device_ops swim_device_ops = { - .name = "swim", + DECLARE_NAME_LEN("swim"), .init = swim_init, .execute = swim_execute, }; diff --git a/src/battery/battery-time.c b/src/battery/battery-time.c index d7bc170..7966247 100644 --- a/src/battery/battery-time.c +++ b/src/battery/battery-time.c @@ -29,7 +29,6 @@ #include "core/devices.h" #include "core/log.h" #include "core/udev.h" -#include "display/setting.h" #include "display/display-ops.h" #include "power-supply.h" diff --git a/src/battery/lowbat-handler.c b/src/battery/lowbat-handler.c index b2a491a..4a2934b 100644 --- a/src/battery/lowbat-handler.c +++ b/src/battery/lowbat-handler.c @@ -160,8 +160,6 @@ static int power_execute(void *data) static const struct device_ops *ops; FIND_DEVICE_INT(ops, POWER_OPS_NAME); - if (NOT_SUPPORT_OPS(ops)) - return -EINVAL; return ops->execute(data); } @@ -910,9 +908,6 @@ static int lowbat_probe(void *data) int ret = -EINVAL; FIND_DEVICE_INT(ops, "power_supply"); - if (NOT_SUPPORT_OPS(ops)) - return ret; - ret = ops->probe(data); if (ret == 0) _I("Support lowbat handler."); @@ -945,7 +940,7 @@ static int lowbat_execute(void *data) } static const struct device_ops lowbat_device_ops = { - .name = "lowbat", + DECLARE_NAME_LEN("lowbat"), .probe = lowbat_probe, .init = lowbat_init, .execute = lowbat_execute, diff --git a/src/battery/power-supply.c b/src/battery/power-supply.c index 2bf2db1..33e170f 100644 --- a/src/battery/power-supply.c +++ b/src/battery/power-supply.c @@ -1720,7 +1720,7 @@ static void power_supply_exit(void *data) } static const struct device_ops power_supply_ops = { - .name = "power_supply", + DECLARE_NAME_LEN("power_supply"), .probe = power_supply_probe, .init = power_supply_init, .exit = power_supply_exit, diff --git a/src/board/board-info.c b/src/board/board-info.c index 6f72ca8..c8d630c 100644 --- a/src/board/board-info.c +++ b/src/board/board-info.c @@ -99,10 +99,9 @@ static GVariant *dbus_num_handler(GDBusConnection *conn, } p = strchr(info.num, ','); - if (p) { - ++p; - strcpy(info.num, p); - } + if (p) + *p = '\0'; + _D("Num(%s) len(%zu).", info.num, strlen(info.num)); num_out: @@ -162,7 +161,7 @@ static void board_init(void *data) } static const struct device_ops board_device_ops = { - .name = "board", + DECLARE_NAME_LEN("board"), .probe = board_probe, .init = board_init, }; diff --git a/src/control/control.c b/src/control/control.c index 6112898..6aa82cd 100644 --- a/src/control/control.c +++ b/src/control/control.c @@ -200,7 +200,7 @@ static void control_init(void *data) } static const struct device_ops control_device_ops = { - .name = "control", + DECLARE_NAME_LEN("control"), .init = control_init, }; diff --git a/src/core/common.c b/src/core/common.c index 0208c5e..fbfa480 100644 --- a/src/core/common.c +++ b/src/core/common.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -110,6 +111,70 @@ int is_vip(int pid) return 0; } +static int remove_dir_internal(int fd) +{ + DIR *dir; + struct dirent *de = NULL; + int subfd, ret = 0; + + dir = fdopendir(fd); + if (!dir) + return -1; + while (1) { + de = readdir(dir); + if (ret != 0 || de == NULL) + break; + if (de->d_type == DT_DIR) { + if (!strncmp(de->d_name, ".", 2) || !strncmp(de->d_name, "..", 3)) + continue; + subfd = openat(fd, de->d_name, O_RDONLY | O_DIRECTORY); + if (subfd < 0) { + _SE("Couldn't openat %s: %d\n", de->d_name, errno); + ret = -1; + continue; + } + if (remove_dir_internal(subfd)) + ret = -1; + + close(subfd); + if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) { + _SE("Couldn't unlinkat %s: %d\n", de->d_name, errno); + ret = -1; + } + } else { + if (unlinkat(fd, de->d_name, 0) < 0) { + _SE("Couldn't unlinkat %s: %d\n", de->d_name, errno); + ret = -1; + } + } + } + closedir(dir); + return ret; +} + +int remove_dir(const char *path, int del_dir) +{ + int fd, ret = 0; + + if (!path) + return -1; + fd = open(path, O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW); + if (fd < 0) { + _SE("Couldn't opendir %s: %d\n", path, errno); + return -errno; + } + ret = remove_dir_internal(fd); + close(fd); + + if (del_dir) { + if (rmdir(path)) { + _SE("Couldn't rmdir %s: %d\n", path, errno); + ret = -1; + } + } + return ret; +} + /* * Helper function * - Read from sysfs entry @@ -127,7 +192,7 @@ int sys_check_node(char *path) return 0; } -static int sys_read_buf(char *file, char *buf) +static int sys_read_buf(char *file, char *buf, int len) { int fd; int r; @@ -137,11 +202,13 @@ static int sys_read_buf(char *file, char *buf) if (fd == -1) return -ENOENT; - r = read(fd, buf, BUFF_MAX); - if ((r >= 0) && (r < BUFF_MAX)) + r = read(fd, buf, len); + if ((r >= 0) && (r < len)) buf[r] = '\0'; - else + else { + buf[0] = '\0'; ret = -EIO; + } close(fd); @@ -172,7 +239,10 @@ int sys_get_int(char *fname, int *val) char buf[BUFF_MAX]; int ret = 0; - if (sys_read_buf(fname, buf) == 0) { + if (!fname || !val) + return -EINVAL; + + if (sys_read_buf(fname, buf, sizeof(buf)) == 0) { *val = atoi(buf); } else { *val = -1; @@ -195,16 +265,17 @@ int sys_set_int(char *fname, int val) return ret; } -int sys_get_str(char *fname, char *str) +int sys_get_str(char *fname, char *str, int len) { - char buf[BUFF_MAX] = {0}; + int ret; - if (sys_read_buf(fname, buf) == 0) { - strncpy(str, buf, strlen(buf)+1); - return 0; - } + if (!fname || !str || len < 0) + return -EINVAL; - return -1; + ret = sys_read_buf(fname, str, len); + if (ret < 0) + return ret; + return 0; } int sys_set_str(char *fname, char *val) @@ -336,6 +407,7 @@ void umount_partition_by_kill(const char *path, const int max_retry) retry++; } while (remain > 0 && retry < max_retry); + sync(); pclose(fp); return; @@ -514,7 +586,7 @@ int get_privilege(pid_t pid, char *name, size_t len) attr_len = fread(attr, 1, sizeof(attr) - 1, fp); fclose(fp); - if (attr_len == 0) + if (attr_len <= 0) return -ENOENT; attr[attr_len] = '\0'; @@ -551,6 +623,79 @@ bool is_emulator(void) return emul; } +int do_mkdir(const char *path, mode_t mode) +{ + char d[PATH_MAX]; + size_t s, l; + int r, p; + + assert(path); + + l = strlen(path); + + for (p = 0, s = 0; p < l; p += s + 1) { + s = strcspn(path + p, "/"); + if (!s) + continue; + + assert(PATH_MAX > p + s + 1); + + r = snprintf(d, p + s + 1, "%s", path); + if (r < 0) + return r; + + r = mkdir(d, mode); + if (r < 0 && errno != EEXIST) + return -errno; + } + + return 0; +} + +static int do_copy_internal(const char *src, const char *dst, mode_t mode, bool force) +{ + _cleanup_close_ int rfd = -1, wfd = -1; + char buf[1024]; + ssize_t red; + int r; + + assert(src); + assert(dst); + + if (!force) { + r = access(dst, F_OK); + if (r == 0) + return -EALREADY; + else if (errno != ENOENT) + return -errno; + } + + wfd = open(dst, O_CREAT | O_WRONLY | O_TRUNC, mode); + if (wfd < 0) + return -errno; + + rfd = open(src, O_RDONLY); + if (rfd < 0) + return -errno; + + while ((red = read(rfd, buf, 1024)) > 0) + if (write(wfd, buf, red) != red) + return -errno; + + if (red < 0) + return -errno; + + return 0; +} + +int do_copy_force(const char *src, const char *dst) +{ + assert(src); + assert(dst); + + return do_copy_internal(src, dst, 0644, true); +} + #if 0 int print_open_files(const char *mount_point) { diff --git a/src/core/common.h b/src/core/common.h index 749b6f8..7f471e0 100644 --- a/src/core/common.h +++ b/src/core/common.h @@ -25,6 +25,7 @@ #include #include #include +#include #define ARRAY_SIZE(name) (sizeof(name)/sizeof(name[0])) #define BITS_PER_LONG (sizeof(long) * 8) @@ -138,23 +139,55 @@ static inline void safe_free_memory(void** mem) } \ } while (0) +#ifndef _cleanup_ +#define _cleanup_(x) __attribute__((cleanup(x))) +#endif + +#ifndef _cleanup_close_ +static inline void __cleanup_close_func(int *fd) { + if (*fd >= 0) + close(*fd); +} +#define _cleanup_close_ _cleanup_(__cleanup_close_func) +#endif + +#ifndef _cleanup_closedir_ +static inline void __cleanup_closedir_func(DIR **d) { + if (*d) + closedir(*d); +} +#define _cleanup_closedir_ _cleanup_(__cleanup_closedir_func) +#endif + +#ifndef _cleanup_fclose_ +static inline void __cleanup_fclose_func(FILE **f) { + if (*f) + fclose(*f); +} +#define _cleanup_fclose_ _cleanup_(__cleanup_fclose_func) +#endif + FILE * open_proc_oom_score_adj_file(int pid, const char *mode); int get_exec_pid(const char *execpath); int get_cmdline_name(pid_t pid, char *cmdline, size_t cmdline_size); int is_vip(int pid); int run_child(int argc, const char *argv[]); +int remove_dir(const char *path, int del_dir); int sys_check_node(char *path); int sys_get_int(char *fname, int *val); int sys_set_int(char *fname, int val); -int sys_get_str(char *fname, char *str); +int sys_get_str(char *fname, char *str, int len); int sys_set_str(char *fname, char *val); -void umount_partition_by_kill(const char *path, const int max_retry); +int terminate_process(const char *partition, bool force); int mount_check(const char* path); void suspend_path(const char *frz_name, const char *path, const int max_retry); void resume_path(const char *frz_name, const char *path); void print_time(const char *prefix); +void umount_partition_by_kill(const char *path, const int max_retry); int get_privilege(pid_t pid, char *name, size_t len); bool is_emulator(void); +int do_mkdir(const char *path, mode_t mode); +int do_copy_force(const char *src, const char *dst); void watchdog_notify(void); int print_open_files(const char *mount_point); diff --git a/src/core/config-parser.c b/src/core/config-parser.c index 070f2ba..02f07d0 100644 --- a/src/core/config-parser.c +++ b/src/core/config-parser.c @@ -91,8 +91,11 @@ int config_parse(const char *file_name, int cb(struct parse_result *result, /* parse name & value */ end = strchr(start, '='); if (!end || *end != '=') { - ret = -EBADMSG; - goto error; + end = strchr(start, ':'); + if (!end || *end != ':') { + ret = -EBADMSG; + goto error; + } } *end = '\0'; name = trim_str(start); diff --git a/src/core/device-notifier.c b/src/core/device-notifier.c index 6da2212..778a707 100644 --- a/src/core/device-notifier.c +++ b/src/core/device-notifier.c @@ -26,7 +26,7 @@ struct device_notifier { bool deleted; - enum device_notifier_type status; + enum device_notifier_type type; int (*func)(void *data); }; @@ -34,36 +34,77 @@ static dd_list *device_notifier_list; static guint idl; static guint late_init_timer; -#define LATE_INIT_TIME 30 +#define LATE_INIT_WAIT_TIME 30 +#define DEFAULT_LATE_INIT_VALUE (guint)0x0DEF0DEF + #define FIND_NOTIFIER(a, b, d, e, f) \ DD_LIST_FOREACH(a, b, d) \ if (e == d->e && f == (d->f)) -int register_notifier(enum device_notifier_type status, int (*func)(void *data)) +#define NOTIFY_STR(x) [(x)] = __stringify((x)) + +static const char *device_notifier_type_str[DEVICE_NOTIFIER_MAX] = { + NOTIFY_STR(DEVICE_NOTIFIER_DAEMON_RESTARTED), + NOTIFY_STR(DEVICE_NOTIFIER_BOOTING_DONE), + NOTIFY_STR(DEVICE_NOTIFIER_LCD), + NOTIFY_STR(DEVICE_NOTIFIER_LCD_OFF), + NOTIFY_STR(DEVICE_NOTIFIER_LOWBAT), + NOTIFY_STR(DEVICE_NOTIFIER_FULLBAT), + NOTIFY_STR(DEVICE_NOTIFIER_POWER_SUPPLY), + NOTIFY_STR(DEVICE_NOTIFIER_BATTERY_HEALTH), + NOTIFY_STR(DEVICE_NOTIFIER_BATTERY_PRESENT), + NOTIFY_STR(DEVICE_NOTIFIER_BATTERY_OVP), + NOTIFY_STR(DEVICE_NOTIFIER_BATTERY_CHARGING), + NOTIFY_STR(DEVICE_NOTIFIER_DISPLAY_AMBIENT_CONDITION), + NOTIFY_STR(DEVICE_NOTIFIER_DISPLAY_AMBIENT_STATE), + NOTIFY_STR(DEVICE_NOTIFIER_DISPLAY_LOCK), + NOTIFY_STR(DEVICE_NOTIFIER_POWER_RESUME), + NOTIFY_STR(DEVICE_NOTIFIER_POWEROFF), + NOTIFY_STR(DEVICE_NOTIFIER_PROCESS_BACKGROUND), + NOTIFY_STR(DEVICE_NOTIFIER_PROCESS_FOREGROUND), + NOTIFY_STR(DEVICE_NOTIFIER_USB_DEBUG_MODE), + NOTIFY_STR(DEVICE_NOTIFIER_USB_TETHERING_MODE), + NOTIFY_STR(DEVICE_NOTIFIER_EVENT_HANDLER), + NOTIFY_STR(DEVICE_NOTIFIER_EARLY_BOOTING_DONE), + NOTIFY_STR(DEVICE_NOTIFIER_PMQOS), + NOTIFY_STR(DEVICE_NOTIFIER_PMQOS_ULTRAPOWERSAVING), + NOTIFY_STR(DEVICE_NOTIFIER_PMQOS_POWERSAVING), + NOTIFY_STR(DEVICE_NOTIFIER_COOL_DOWN), + NOTIFY_STR(DEVICE_NOTIFIER_VITAL_STATE), + NOTIFY_STR(DEVICE_NOTIFIER_LONGKEY_RESTORE), + NOTIFY_STR(DEVICE_NOTIFIER_UPSM), + NOTIFY_STR(DEVICE_NOTIFIER_UPSM_OFF), + NOTIFY_STR(DEVICE_NOTIFIER_BEZEL_WAKEUP), + NOTIFY_STR(DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS), + NOTIFY_STR(DEVICE_NOTIFIER_CRITICAL_LOG), + NOTIFY_STR(DEVICE_NOTIFIER_ULTRAPOWERSAVING), +}; + +int __register_notifier(enum device_notifier_type type, notify_cb func, const char *caller) { dd_list *n; struct device_notifier *notifier; - _I("notifier type=%d func=%p", status, func); + _I("%s, %p by %s", device_notifier_type_str[type], func, caller); if (!func) { - _E("Invalid func address."); + _E("invalid func address! by %s", caller); return -EINVAL; } - FIND_NOTIFIER(device_notifier_list, n, notifier, status, func) { - _E("Function is already registered. type=%d func=%p", - status, func); + FIND_NOTIFIER(device_notifier_list, n, notifier, type, func) { + _E("function is already registered! [%s, %p] by %s", + device_notifier_type_str[type], func, caller); return -EINVAL; } notifier = calloc(1, sizeof(struct device_notifier)); if (!notifier) { - _E("Failed to malloc for notifier."); + _E("Fail to malloc for %s notifier! by %s", device_notifier_type_str[type], caller); return -ENOMEM; } - notifier->status = status; + notifier->type = type; notifier->func = func; DD_LIST_APPEND(device_notifier_list, notifier); @@ -71,18 +112,18 @@ int register_notifier(enum device_notifier_type status, int (*func)(void *data)) return 0; } -int unregister_notifier(enum device_notifier_type status, int (*func)(void *data)) +int __unregister_notifier(enum device_notifier_type type, notify_cb func, const char *caller) { dd_list *n; struct device_notifier *notifier; if (!func) { - _E("Invalid func address."); + _E("invalid func address of %s! by %s", device_notifier_type_str[type], caller); return -EINVAL; } - FIND_NOTIFIER(device_notifier_list, n, notifier, status, func) { - _I("notifier type=%d func=%p", status, func); + FIND_NOTIFIER(device_notifier_list, n, notifier, type, func) { + _I("[%s, %p] by %s", device_notifier_type_str[type], func, caller); notifier->deleted = true; } @@ -106,13 +147,13 @@ static gboolean delete_unused_notifier_cb(void *data) return G_SOURCE_REMOVE; } -void device_notify(enum device_notifier_type status, void *data) +void device_notify(enum device_notifier_type type, void *data) { dd_list *n; struct device_notifier *notifier; DD_LIST_FOREACH(device_notifier_list, n, notifier) { - if (!notifier->deleted && status == notifier->status) { + if (!notifier->deleted && type == notifier->type) { if (notifier->func) notifier->func(data); } @@ -122,13 +163,13 @@ void device_notify(enum device_notifier_type status, void *data) idl = g_idle_add(delete_unused_notifier_cb, NULL); } -void device_notify_once(enum device_notifier_type status, void *data) +void device_notify_once(enum device_notifier_type type, void *data) { dd_list *n; struct device_notifier *notifier; DD_LIST_FOREACH(device_notifier_list, n, notifier) { - if (!notifier->deleted && status == notifier->status) { + if (!notifier->deleted && type == notifier->type) { if (notifier->func) notifier->func(data); @@ -142,7 +183,7 @@ void device_notify_once(enum device_notifier_type status, void *data) static void late_init_stop(void) { - if (!late_init_timer) + if (late_init_timer == 0 || late_init_timer == DEFAULT_LATE_INIT_VALUE) return; g_source_remove(late_init_timer); @@ -157,10 +198,21 @@ static int booting_done(void *data) goto out; done = *(int *)data; - if (!late_init_timer) + if (late_init_timer == 0) return done; late_init_stop(); +out: + return done; +} +static int early_booting_done(void *data) +{ + static int done; + + if (data == NULL) + goto out; + + done = *(int *)data; out: return done; } @@ -170,13 +222,16 @@ static gboolean late_init_timer_cb(void *data) int done; late_init_stop(); + done = early_booting_done(NULL); + if (!done) + device_notify(DEVICE_NOTIFIER_EARLY_BOOTING_DONE, (void *)&done); done = booting_done(NULL); + late_init_timer = 0; if (done) return G_SOURCE_REMOVE; - _I("Late booting done."); + _I("late booting done"); done = TRUE; - device_notify_once(DEVICE_NOTIFIER_BOOTING_DONE, (void *)&done); - + device_notify(DEVICE_NOTIFIER_BOOTING_DONE, (void *)&done); return G_SOURCE_REMOVE; } @@ -186,15 +241,16 @@ static void device_notifier_init(void *data) ret = check_systemd_active(); if (ret == TRUE) { - _I("Restart booting done."); + _I("restart booting done"); return; } register_notifier(DEVICE_NOTIFIER_BOOTING_DONE, booting_done); + register_notifier(DEVICE_NOTIFIER_EARLY_BOOTING_DONE, early_booting_done); + late_init_timer = g_timeout_add(LATE_INIT_WAIT_TIME, + late_init_timer_cb, NULL); - late_init_timer = g_timeout_add_seconds(LATE_INIT_TIME, - late_init_timer_cb, NULL); if (!late_init_timer) - _E("Failed to set 'late_init_timer'."); + late_init_timer = DEFAULT_LATE_INIT_VALUE; } static void device_notifier_exit(void *data) @@ -203,7 +259,7 @@ static void device_notifier_exit(void *data) } static const struct device_ops notifier_device_ops = { - .name = "notifier", + DECLARE_NAME_LEN("notifier"), .init = device_notifier_init, .exit = device_notifier_exit, }; diff --git a/src/core/device-notifier.h b/src/core/device-notifier.h index fe89950..e1f7b65 100644 --- a/src/core/device-notifier.h +++ b/src/core/device-notifier.h @@ -21,13 +21,14 @@ #define __DEVICE_NOTIFIER_H__ enum device_notifier_type { + DEVICE_NOTIFIER_DAEMON_RESTARTED, DEVICE_NOTIFIER_BOOTING_DONE, DEVICE_NOTIFIER_LCD, - DEVICE_NOTIFIER_TA, + DEVICE_NOTIFIER_LCD_OFF, + DEVICE_NOTIFIER_LCD_OFF_COMPLETE, + DEVICE_NOTIFIER_LCD_AUTOBRT_SENSING, DEVICE_NOTIFIER_LOWBAT, DEVICE_NOTIFIER_FULLBAT, - DEVICE_NOTIFIER_TOUCH_HARDKEY, - DEVICE_NOTIFIER_PROCESS_TERMINATED, DEVICE_NOTIFIER_POWER_SUPPLY, DEVICE_NOTIFIER_BATTERY_HEALTH, DEVICE_NOTIFIER_BATTERY_PRESENT, @@ -38,39 +39,25 @@ enum device_notifier_type { DEVICE_NOTIFIER_DISPLAY_LOCK, DEVICE_NOTIFIER_POWER_RESUME, DEVICE_NOTIFIER_POWEROFF, - DEVICE_NOTIFIER_POWEROFF_HAPTIC, DEVICE_NOTIFIER_PROCESS_BACKGROUND, DEVICE_NOTIFIER_PROCESS_FOREGROUND, DEVICE_NOTIFIER_USB_DEBUG_MODE, DEVICE_NOTIFIER_USB_TETHERING_MODE, DEVICE_NOTIFIER_EVENT_HANDLER, - DEVICE_NOTIFIER_CPU_BOOST, DEVICE_NOTIFIER_CPU_BOOST_LOWBAT, DEVICE_NOTIFIER_CPU_BOOST_POWEROFF, /* Experimental for Specific device - contact to deviced owner */ DEVICE_NOTIFIER_EARLY_BOOTING_DONE, - DEVICE_NOTIFIER_SETTING_BRT_CHANGED, - DEVICE_NOTIFIER_HALLIC_OPEN, - DEVICE_NOTIFIER_BATTERY_CRITICAL_POPUP, DEVICE_NOTIFIER_PMQOS, DEVICE_NOTIFIER_PMQOS_ULTRAPOWERSAVING, DEVICE_NOTIFIER_PMQOS_POWERSAVING, - DEVICE_NOTIFIER_PMQOS_LOWBAT, - DEVICE_NOTIFIER_PMQOS_EMERGENCY, - DEVICE_NOTIFIER_PMQOS_POWEROFF, - DEVICE_NOTIFIER_PMQOS_OOM, - DEVICE_NOTIFIER_PMQOS_HALL, DEVICE_NOTIFIER_COOL_DOWN, - DEVICE_NOTIFIER_FLIGHT_MODE, - DEVICE_NOTIFIER_MOBILE_HOTSPOT_MODE, DEVICE_NOTIFIER_VITAL_STATE, - DEVICE_NOTIFIER_LED, - DEVICE_NOTIFIER_SLUGGISH, - DEVICE_NOTIFIER_MONOTONE_HAPTIC, + DEVICE_NOTIFIER_LONGKEY_RESTORE, DEVICE_NOTIFIER_UPSM, - DEVICE_NOTIFIER_UDEV, + DEVICE_NOTIFIER_UPSM_OFF, DEVICE_NOTIFIER_BEZEL_WAKEUP, - DEVICE_NOTIFIER_LONGKEY_RESTORE, + DEVICE_NOTIFIER_DISPLAY_BRIGHTNESS, DEVICE_NOTIFIER_ULTRAPOWERSAVING, DEVICE_NOTIFIER_CRITICAL_LOG, DEVICE_NOTIFIER_MAX, @@ -83,12 +70,15 @@ typedef enum _device_notifier_state { /* add more states here */ } device_notifier_state_e; +typedef int (*notify_cb)(void *data); /* * This is for internal callback method. */ -int register_notifier(enum device_notifier_type status, int (*func)(void *data)); -int unregister_notifier(enum device_notifier_type status, int (*func)(void *data)); -void device_notify(enum device_notifier_type status, void *value); +int __register_notifier(enum device_notifier_type type, notify_cb func, const char *caller); +#define register_notifier(type, func) __register_notifier(type, func, __func__) +int __unregister_notifier(enum device_notifier_type type, notify_cb func, const char *caller); +#define unregister_notifier(type, func) __unregister_notifier(type, func, __func__) +void device_notify(enum device_notifier_type type, void *value); void device_notify_once(enum device_notifier_type status, void *data); #endif /* __DEVICE_NOTIFIER_H__ */ diff --git a/src/core/devices.c b/src/core/devices.c index e19f524..6d5480d 100644 --- a/src/core/devices.c +++ b/src/core/devices.c @@ -26,21 +26,16 @@ #include "devices.h" static const struct device_ops default_ops = { - .name = "default-ops", + DECLARE_NAME_LEN("default-ops"), }; -dd_list *dev_head; +static dd_list *dev_head; dd_list *get_device_list_head(void) { return dev_head; } -void remove_device(const struct device_ops *dev) -{ - DD_LIST_REMOVE(dev_head, dev); -} - void add_device(const struct device_ops *dev) { const struct device_ops *ops; @@ -55,13 +50,30 @@ void add_device(const struct device_ops *dev) DD_LIST_APPEND(dev_head, dev); } +void remove_device(const struct device_ops *dev) +{ + DD_LIST_REMOVE(dev_head, dev); +} + const struct device_ops *find_device(const char *name) { dd_list *elem; const struct device_ops *dev; + int len; + + if (!name) { + _E("there is no name"); + return NULL; + } + + len = strlen(name); DD_LIST_FOREACH(dev_head, elem, dev) { - if (!strcmp(dev->name, name)) + if (dev->len != len) + continue; + if (dev->len == 0) + _E("%s len is not defined", dev->name); + if (!strncmp(dev->name, name, len)) return dev; } diff --git a/src/core/devices.h b/src/core/devices.h index 5ee2713..8a8f4cd 100644 --- a/src/core/devices.h +++ b/src/core/devices.h @@ -32,6 +32,7 @@ enum device_priority { enum device_flags { NORMAL_MODE = 0x00000001, AMBIENT_MODE = 0x00000002, + FORCE_OFF_MODE = 0x00000004, CORE_LOGIC_MODE = 0x00010000, TOUCH_SCREEN_OFF_MODE = 0x00020000, LCD_PANEL_OFF_MODE = 0x00040000, @@ -45,11 +46,15 @@ enum device_flags { LCD_OFF_BY_TIMEOUT = 0x04000000, LCD_OFF_BY_EVENT = 0x08000000, LCD_OFF_LATE_MODE = 0x10000000, + LCD_OFF_BY_PROXIMITY = 0x20000000, + LCD_OFF_BY_GESTURE = 0x40000000, + LCD_OFF_BY_PALM = 0x80000000, }; struct device_ops { enum device_priority priority; char *name; + int len; int (*probe) (void *data); void (*init) (void *data); void (*exit) (void *data); @@ -70,8 +75,6 @@ enum device_ops_status { DEVICE_OPS_STATUS_MAX, }; -extern dd_list *dev_head; - void devices_init(void *data); void devices_exit(void *data); @@ -155,4 +158,7 @@ int check_default(const struct device_ops *dev); ret = dev->status ? dev->status() : defaults; \ } while (0) +#define DECLARE_NAME_LEN(x) \ + .name = (x), \ + .len = __builtin_strlen(x) #endif diff --git a/src/core/event-handler.c b/src/core/event-handler.c index 844ceea..a4871b7 100644 --- a/src/core/event-handler.c +++ b/src/core/event-handler.c @@ -99,7 +99,7 @@ static void event_handler_init(void *data) } static const struct device_ops event_handler_device_ops = { - .name = "event-handler", + DECLARE_NAME_LEN("event-handler"), .init = event_handler_init, }; diff --git a/src/core/launch.c b/src/core/launch.c index 136ed47..68007ae 100644 --- a/src/core/launch.c +++ b/src/core/launch.c @@ -26,6 +26,7 @@ #include #include #include +#include #include "log.h" #include "launch.h" @@ -138,13 +139,22 @@ int launch_app_with_nice(const char *file, char *const argv[], pid_t *pid, int _ { int ret; int _pid; + int fd; - if (file == NULL || access(file, X_OK) != 0) { - _E("Launch app error: Invalid input"); + if (file == NULL) { + _E("launch app error: There is no file"); errno = EINVAL; return -1; } + fd = open(file, O_RDONLY); + if (fd == -1) { + _E("launch app error: Invalid file"); + errno = EIO; + return -1; + } + close(fd); + if (pid && (*pid > 0 && kill(*pid, 0) != -1)) return *pid; diff --git a/src/core/log.h b/src/core/log.h index 915e4a9..60c363e 100644 --- a/src/core/log.h +++ b/src/core/log.h @@ -32,6 +32,13 @@ #include "shared/log-macro.h" #endif +/* Indirect stringification. Doing two levels allows the parameter to be a + * macro itself. For example, compile with -DFOO=bar, __stringify(FOO) + * converts to "bar". + */ +#define __stringify_1(x...) #x +#define __stringify(x...) __stringify_1(x) + void critical_log_internal(const char *caller, const char *fmt, ...); #define critical_log(fmt, arg...) critical_log_internal(__func__, fmt, ##arg) diff --git a/src/core/sig-handler.c b/src/core/sig-handler.c index e48f1ec..527e6f5 100644 --- a/src/core/sig-handler.c +++ b/src/core/sig-handler.c @@ -68,7 +68,7 @@ static void signal_init(void *data) } static const struct device_ops signal_device_ops = { - .name = "signal", + DECLARE_NAME_LEN("signal"), .init = signal_init, }; diff --git a/src/core/udev.c b/src/core/udev.c index edb630e..40571e0 100644 --- a/src/core/udev.c +++ b/src/core/udev.c @@ -312,7 +312,7 @@ static void udev_exit(void *data) static const struct device_ops udev_device_ops = { .priority = DEVICE_PRIORITY_NORMAL, - .name = "udev", + DECLARE_NAME_LEN("udev"), .init = udev_init, .exit = udev_exit, }; diff --git a/src/core/udev.h b/src/core/udev.h index d432766..267a892 100644 --- a/src/core/udev.h +++ b/src/core/udev.h @@ -59,6 +59,10 @@ #define BLOCK_DEVTYPE_DISK "disk" #define BLOCK_DEVTYPE_PARTITION "partition" +/* lcd esd device */ +#define LCD_EVENT_SUBSYSTEM "lcd_event" +#define LCD_ESD_PATH "*/lcd_event/esd" + /* power supply status */ enum { POWER_SUPPLY_STATUS_UNKNOWN = 0, @@ -76,6 +80,11 @@ enum { POWER_SUPPLY_TYPE_USB, }; +enum dock_type { + DOCK_NONE = 0, + DOCK_SOUND = 7, +}; + struct uevent_handler { char *subsystem; void (*uevent_func)(struct udev_device *dev); diff --git a/src/cpu/pmqos.c b/src/cpu/pmqos.c index 49b93ee..421e1bd 100644 --- a/src/cpu/pmqos.c +++ b/src/cpu/pmqos.c @@ -524,7 +524,7 @@ static void pmqos_exit(void *data) } static const struct device_ops pmqos_device_ops = { - .name = "pmqos", + DECLARE_NAME_LEN("pmqos"), .probe = pmqos_probe, .init = pmqos_init, .exit = pmqos_exit, diff --git a/src/display/ambient-mode.c b/src/display/ambient-mode.c index 7192f44..1469d5c 100644 --- a/src/display/ambient-mode.c +++ b/src/display/ambient-mode.c @@ -37,12 +37,13 @@ #define CLOCK_START "clockstart" #define CLOCK_END "clockend" +#define CLOCK_CHANGED "clockchanged" #define TIMEOUT_NONE (-1) #define AMBIENT_CLOCK_WAITING_TIME 5000 /* ms */ static int ambient_state; +static int ambient_condition; /* Setting Value */ static pid_t ambient_pid; /* Ambient Clock pid */ -static int ambient_condition; static unsigned int update_count; void broadcast_ambient_state(int state) @@ -57,7 +58,7 @@ void broadcast_ambient_state(int state) signal, NULL); if (ret < 0) - _E("Failed to send dbus signal(%s)", signal); + _E("Failed to send dbus signal(%s).", signal); } int ambient_get_condition(void) @@ -82,7 +83,8 @@ static void ambient_set_condition(keynode_t *key_nodes, void *data) val = vconf_keynode_get_bool(key_nodes); if (val != ambient_condition) { if (backlight_ops.get_lcd_power() != DPMS_ON) - lcd_on_procedure(LCD_NORMAL, LCD_ON_BY_EVENT); + if (disp_plgn.pm_lock_internal) + disp_plgn.pm_change_internal(INTERNAL_LOCK_PM, LCD_NORMAL); } ambient_condition = val; @@ -144,7 +146,8 @@ void ambient_check_invalid_state(pid_t pid) /* If lcd_power is on and ambient state is true * when pm state is changed to sleep, * deviced doesn't get the clock signal. - * deviced just turns off lcd in this case. */ + * deviced just turns off lcd in this case. + */ reset_timeout(TIMEOUT_NONE); ambient_set_state(false); @@ -212,14 +215,14 @@ static void ambient_lcdoff_signal_handler(GDBusConnection *conn, gpointer data) { if (ambient_state == false) { - _E("It is not alpm mode"); + _E("It is not alpm mode."); return; } if (disp_plgn.pm_lock_internal) disp_plgn.pm_lock_internal(INTERNAL_LOCK_AMBIENT, LCD_OFF, GOTO_STATE_NOW, 0); - _I("Display off in suspend state"); + _I("Display off in suspend state."); ambient_set_state(false); lcd_direct_control(DPMS_OFF, NORMAL_MODE); @@ -233,8 +236,7 @@ static void ambient_init(void *data) { int ret; - ret = vconf_get_bool(VCONFKEY_SETAPPL_AMBIENT_MODE_BOOL, - &ambient_condition); + ret = vconf_get_bool(VCONFKEY_SETAPPL_AMBIENT_MODE_BOOL, &ambient_condition); if (ret < 0) { _E("Failed to get vconf value for ambient mode: %d", vconf_get_ext_errno()); ambient_condition = false; @@ -268,4 +270,3 @@ static const struct display_ops ambient_ops = { }; DISPLAY_OPS_REGISTER(&ambient_ops) - diff --git a/src/display/auto-brightness.c b/src/display/auto-brightness.c index a9d4100..c2207db 100644 --- a/src/display/auto-brightness.c +++ b/src/display/auto-brightness.c @@ -521,7 +521,7 @@ static void update_auto_brightness(bool update) static int prepare_lsensor(void *data) { int status, ret; - int brt = -1; + int brt; ret = vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &status); @@ -535,9 +535,10 @@ static int prepare_lsensor(void *data) set_alc_function, NULL); ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS, &brt); - if (ret < 0) + if (ret < 0) { + brt = -1; _E("Failed to get vconf value for automatic lcd brightness: %d", vconf_get_ext_errno()); - + } if (brt < PM_MIN_BRIGHTNESS || brt > PM_MAX_BRIGHTNESS) { _E("Failed to get automatic brightness."); } else { diff --git a/src/display/core.h b/src/display/core.h index 1bb77df..166eb2a 100644 --- a/src/display/core.h +++ b/src/display/core.h @@ -28,6 +28,7 @@ #include "device-interface.h" #include "setting.h" +#define WITHOUT_STARTNOTI 0x1 #define MASK_BIT 0x7 /* 111 */ #define MASK_NORMAL 0x1 /* 001 */ #define MASK_DIM 0x2 /* 010 */ @@ -40,10 +41,13 @@ #define BRTCH_FLAG 0x00002000 #define PWROFF_FLAG 0x00004000 #define DIMSTAY_FLAG 0x00008000 +#define DIM_FLAG 0x00010000 #define BATTERY_FLAG 0x00020000 +#define COOLDOWN_FLAG 0x00040000 #define DEFAULT_NORMAL_TIMEOUT 30 +#define DIM_MASK 0x000f0000 #define MASK32 0xffffffff #define CHECK_OPS(d, op) (d != NULL && d->op != NULL) @@ -57,11 +61,14 @@ enum pm_log_type { PM_LOG_KEY_LONG_PRESS, PM_LOG_KEY_RELEASE, PM_LOG_LCD_ON, /* lcd log */ + PM_LOG_LCD_ON_COMPLETE, PM_LOG_LCD_ON_FAIL, PM_LOG_LCD_DIM, PM_LOG_LCD_DIM_FAIL, PM_LOG_LCD_OFF, + PM_LOG_LCD_OFF_COMPLETE, PM_LOG_LCD_OFF_FAIL, + PM_LOG_LCD_CONTROL_FAIL, PM_LOG_SLEEP, PM_LOG_MAX }; @@ -120,14 +127,19 @@ struct display_config { int lcdoff_timeout; int brightness_change_step; int lcd_always_on; + int dimming; int framerate_app[4]; int control_display; int powerkey_doublepress; int alpm_on; int accel_sensor_on; int continuous_sampling; + int lockcheck_timeout; + int aod_enter_level; + bool aod_tsp; bool timeout_enable; bool input_support; + bool touch_wakeup; }; /* @@ -144,6 +156,7 @@ struct display_function_info { int (*set_autobrightness_min)(int, char *); GBusNameAppearedCallback reset_autobrightness_min; int (*face_detection)(int, int, int); + void (*set_brightness_level)(int); }; extern struct display_function_info display_info; @@ -168,6 +181,7 @@ void reset_lcd_timeout(GDBusConnection *conn, const gchar *sender, const gchar *unique_name, gpointer data); +int check_lcdoff_lock_state(void); /* setting.c */ int get_lock_screen_bg_state(void); @@ -186,29 +200,37 @@ void change_proc_change_state(int (*func)(unsigned int cond, pid_t pid)); bool check_lock_state(int state); int delete_condition(enum state_t state); +int custom_lcdoff(enum device_flags flag); +int display_platform_control(int type, char *reason, int timeout); void update_lcdoff_source(int source); int low_battery_state(int val); int set_lcd_timeout(int on, int dim, int holdkey_block, const char *name); -void save_display_log(void); +void save_display_log(char *path); int custom_lcdon(int timeout); void set_stay_touchscreen_off(int val); void set_lcd_paneloff_mode(int val); void lcd_on_direct(enum device_flags flags); void lcd_on_procedure(int state, enum device_flags flag); void lcd_off_procedure(enum device_flags flag); +void lcd_direct_control(enum dpms_state state, int flags); int check_holdkey_block(enum state_t state); bool touch_event_blocked(void); -int device_poweroff(void *data); void broadcast_lcd_off_late(enum device_flags flags); void set_dim_state(bool on); void reset_timeout(int timeout); +/* auto-brightness.c */ +void set_brightness_changed_state(void); + /* poll.c */ int check_dimstay(int next_state, int flag); /* display-dbus.c */ int init_pm_dbus(void); +/* slave-logging.c */ +int save_pmlock(enum state_t state, bool on, pid_t pid); + /** * @} */ diff --git a/src/display/device-interface.h b/src/display/device-interface.h index 81e8150..2806bc0 100644 --- a/src/display/device-interface.h +++ b/src/display/device-interface.h @@ -28,11 +28,14 @@ #include #include "core/devices.h" +#define FLAG_X_DPMS 0x2 + #define DEFAULT_DISPLAY 0 #define PM_MAX_BRIGHTNESS 100 #define PM_MIN_BRIGHTNESS 1 -#define PM_DEFAULT_BRIGHTNESS 60 +#define PM_DEFAULT_BRIGHTNESS 80 +#define PM_DIM_BRIGHTNESS 0 #define DISP_INDEX_SHIFT 16 #define DISP_CMD(prop, index) ((index << DISP_INDEX_SHIFT) | prop) @@ -41,6 +44,8 @@ #define DEFAULT_DISPLAY_MAX_BRIGHTNESS 100 #define DEFAULT_DISPLAY_MAX_DIM_BRIGHTNESS 50 +#define DPMS_SETTING_DONE -1 + /* * Event type enumeration */ @@ -51,10 +56,22 @@ enum { EVENT_END, }; -int init_sysfs(void); + +/* + * Vital state enumeration + */ +enum vital_state { + VITAL_SLEEP, /* suspend state */ + VITAL_WAKEUP, /* resume state */ + VITAL_DISPLAY_WAKEUP, + VITAL_EXIT, +}; + +int init_sysfs(unsigned int); int exit_sysfs(void); int display_service_load(void); int display_service_free(void); +bool vital_mode(void); struct _backlight_ops { int (*off)(enum device_flags); @@ -63,6 +80,7 @@ struct _backlight_ops { int (*update)(void); int (*standby)(int); int (*set_default_brt)(int level); + int (*get_default_brt)(void); int (*get_lcd_power)(void); int (*set_custom_status)(bool on); bool (*get_custom_status)(void); @@ -71,11 +89,18 @@ struct _backlight_ops { int (*set_force_brightness)(int level); int (*set_brightness)(int val); int (*get_brightness)(int *val); + void (*restore_brightness_func)(void); int (*get_brightness_by_light_sensor)(float lmax, float lmin, float light, int *brt); int (*get_image_effect)(enum display_image_effect *effect); int (*set_image_effect)(enum display_image_effect effect); + int (*get_panel_mode)(enum display_panel_mode *mode); + int (*set_panel_mode)(enum display_panel_mode mode); int (*get_frame_rate)(int *rate); int (*set_frame_rate)(int rate); + int (*transit_state)(int state); + void (*transit_brt)(int start, int end, int step); + void (*blink)(int timeout); + void (*release_blink)(void); }; struct _power_ops { @@ -83,6 +108,7 @@ struct _power_ops { int (*enable_autosleep)(void); int (*power_lock)(void); int (*power_unlock)(void); + int (*get_power_lock)(void); int (*get_power_lock_support)(void); int (*check_wakeup_src)(void); int (*get_wakeup_count)(int *cnt); @@ -97,6 +123,17 @@ enum dpms_state { DPMS_STANDBY, /* Blanked, low power */ DPMS_SUSPEND, /* Blanked, lower power */ DPMS_OFF, /* Shut off, awaiting activity */ + DPMS_FORCE_OFF,/* Force Shut off */ +}; + +enum mainlock_state { + POWER_UNLOCK = 0, + POWER_LOCK, }; + +struct display_device *display_dev_get(void); +bool display_dimstay_check(void); +void dpms_set_running_state(int val); + #endif diff --git a/src/display/display-dbus.c b/src/display/display-dbus.c index 8e1a2eb..773825f 100644 --- a/src/display/display-dbus.c +++ b/src/display/display-dbus.c @@ -25,50 +25,56 @@ #include #include -#include -#include #include #include +#include #include "ambient-mode.h" #include "core/log.h" #include "util.h" #include "core.h" +#include "lock-detector.h" #include "core/common.h" #include "core/devices.h" #include "core/device-idler.h" +#include "core/device-notifier.h" #include "apps/apps.h" #include "dd-display.h" #include "display-actor.h" #include "display-ops.h" -#include #define SIGNAL_HOMESCREEN "HomeScreen" +#define AUL_APPSTATUS_PATH "/Org/Tizen/Aul/AppStatus" +#define AUL_APPSTATUS_INTERFACE "org.tizen.aul.AppStatus" +#define APP_CHANGE_STATE "AppStatusChange" + +#define TELEPHONY_PATH "/org/tizen/telephony" +#define TELEPHONY_INTERFACE_SIM "org.tizen.telephony.Manager" +#define SIGNAL_SIM_STATUS "SimInserted" +#define SIM_CARD_NOT_PRESENT (0x0) + +#ifndef VCONFKEY_LCD_BRIGHTNESS_INIT +#define VCONFKEY_LCD_BRIGHTNESS_INIT "db/private/deviced/lcd_brightness_init" +#endif + +#define DISPLAY_DIM_BRIGHTNESS 0 #define DUMP_MODE_WATING_TIME 600000 +#define LCDOFF_PROXI_STR "proximity" +#define LCDOFF_GESTURE_STR "gesture" + #define EXPIRED_POPUP_TYPE_POWER "power_lock_expired" #define EXPIRED_POPUP_PID "_APP_PID_" #define EXPIRED_POPUP_COMM "_APP_COMM_" #define EXPIRED_POPUP_ID "_REQUEST_ID_" -#define CHECK_POWEROFF() \ - do { \ - if (device_poweroff(NULL)) { \ - _E("Ignore requests for display during power off"); \ - return g_variant_new("(i)", -EBUSY); \ - } \ - } while (0) - GVariant *dbus_start(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { static const struct device_ops *display_device_ops = NULL; - if (device_poweroff(NULL)) - goto out; - if (!display_device_ops) display_device_ops = find_device("display"); if (NOT_SUPPORT_OPS(display_device_ops)) @@ -85,9 +91,6 @@ GVariant *dbus_stop(GDBusConnection *conn, { static const struct device_ops *display_device_ops = NULL; - if (device_poweroff(NULL)) - goto out; - if (!display_device_ops) display_device_ops = find_device("display"); if (NOT_SUPPORT_OPS(display_device_ops)) @@ -112,8 +115,6 @@ GVariant *dbus_lockstate(GDBusConnection *conn, int ret = 0; unsigned int caps; - CHECK_POWEROFF(); - g_variant_get(param, "(sssi)", &state_str, &option1_str, &option2_str, &timeout); if (!state_str || timeout < 0) { @@ -139,7 +140,7 @@ GVariant *dbus_lockstate(GDBusConnection *conn, else if (!strcmp(state_str, PM_LCDOFF_STR)) state = LCD_OFF; else { - _E("%s state is invalid, dbus ignored!", state_str); + _E("%s state is invalid, dbus ignored.", state_str); ret = -EINVAL; goto out; } @@ -199,8 +200,6 @@ GVariant *dbus_unlockstate(GDBusConnection *conn, int flag; int ret = 0; - CHECK_POWEROFF(); - g_variant_get(param, "(ss)", &state_str, &option_str); if (!state_str) { @@ -221,8 +220,6 @@ GVariant *dbus_unlockstate(GDBusConnection *conn, if (!strcmp(state_str, PM_LCDON_STR)) state = LCD_NORMAL; - else if (!strcmp(state_str, PM_LCDDIM_STR)) - state = LCD_DIM; else if (!strcmp(state_str, PM_LCDOFF_STR)) state = LCD_OFF; else { @@ -257,11 +254,9 @@ GVariant *dbus_changestate(GDBusConnection *conn, char *state_str; pid_t pid; int state; - int ret = 0; + int ret = 0, len; unsigned int caps; - CHECK_POWEROFF(); - g_variant_get(param, "(s)", &state_str); if (!state_str) { @@ -280,6 +275,12 @@ GVariant *dbus_changestate(GDBusConnection *conn, goto out; } + len = strlen(state_str); + if (len == 0) { + ret = -EINVAL; + goto out; + } + if (!strcmp(state_str, PM_LCDON_STR)) state = LCD_NORMAL; else if (!strcmp(state_str, PM_LCDDIM_STR)) @@ -312,7 +313,7 @@ GVariant *dbus_changestate(GDBusConnection *conn, } if (check_dimstay(state, GOTO_STATE_NOW) == true) { - _E("LCD state can not be changed to OFF state!"); + _E("LCD state can not be changed to OFF state! by %d", pid); ret = -EBUSY; goto out; } @@ -333,8 +334,6 @@ GVariant *dbus_getdisplaycount(GDBusConnection *conn, { int ret; - CHECK_POWEROFF(); - ret = DEFAULT_DISPLAY_COUNT; return g_variant_new("(i)", ret); @@ -346,8 +345,6 @@ GVariant *dbus_getmaxbrightness(GDBusConnection *conn, { int ret, state; - CHECK_POWEROFF(); - g_variant_get(param, "(i)", &state); if (state == DISPLAY_STATE_NORMAL) ret = DEFAULT_DISPLAY_MAX_BRIGHTNESS; @@ -365,8 +362,6 @@ GVariant *dbus_setmaxbrightness(GDBusConnection *conn, { int ret; - CHECK_POWEROFF(); - ret = -ENOTSUP; return g_variant_new("(i)", ret); @@ -378,8 +373,6 @@ GVariant *dbus_getbrightness(GDBusConnection *conn, { int brt = -1, state, ret; - CHECK_POWEROFF(); - g_variant_get(param, "(i)", &state); if (state == DISPLAY_STATE_NORMAL) @@ -388,8 +381,10 @@ GVariant *dbus_getbrightness(GDBusConnection *conn, ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_DIM_BRIGHTNESS, &brt); if (ret < 0) _E("Failed to get vconf value for lcd dim brightness: %d", vconf_get_ext_errno()); - } else - ret = -EINVAL; + } else { + ret = backlight_ops.get_default_brt(); + brt = 0; + } if (ret >= 0) ret = brt; @@ -405,8 +400,6 @@ GVariant *dbus_setbrightness(GDBusConnection *conn, { int state, brt, autobrt, ret = 0, caps; - CHECK_POWEROFF(); - caps = display_get_caps(DISPLAY_ACTOR_API); if (!display_has_caps(caps, DISPLAY_CAPA_BRIGHTNESS)) { @@ -418,7 +411,7 @@ GVariant *dbus_setbrightness(GDBusConnection *conn, g_variant_get(param, "(ii)", &state, &brt); //Check if brt is same with DIM - if (brt == 0) { + if (brt == DISPLAY_DIM_BRIGHTNESS) { _E("application can not set this value(DIM VALUE:%d)", brt); ret = -EPERM; goto error; @@ -436,6 +429,9 @@ GVariant *dbus_setbrightness(GDBusConnection *conn, goto error; } + pm_status_flag &= ~DIM_MASK; + + backlight_ops.set_default_brt(brt); if (state == DISPLAY_STATE_NORMAL) { ret = backlight_ops.set_brightness(brt); if (ret < 0) @@ -469,8 +465,6 @@ GVariant *dbus_holdbrightness(GDBusConnection *conn, { int brt, autobrt, ret, caps; - CHECK_POWEROFF(); - caps = display_get_caps(DISPLAY_ACTOR_API); if (!display_has_caps(caps, DISPLAY_CAPA_BRIGHTNESS)) { @@ -481,6 +475,12 @@ GVariant *dbus_holdbrightness(GDBusConnection *conn, g_variant_get(param, "(i)", &brt); + if (brt == DISPLAY_DIM_BRIGHTNESS) { + _E("application can not set this value(DIM VALUE:%d)", brt); + ret = -EPERM; + goto error; + } + ret = vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &autobrt); if (ret < 0) { _E("Failed to get vconf value for automatic brightness: %d", vconf_get_ext_errno()); @@ -514,8 +514,6 @@ GVariant *dbus_releasebrightness(GDBusConnection *conn, { int bat, charger, changed, setting, brt, autobrt, ret = 0; - CHECK_POWEROFF(); - ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &bat); if (ret < 0) { _E("Failed to get vconf value for battery status low: %d", vconf_get_ext_errno()); @@ -588,8 +586,6 @@ GVariant *dbus_setrefreshrate(GDBusConnection *conn, { int app, val, ret, control; - CHECK_POWEROFF(); - g_variant_get(param, "(ii)", &app, &val); if (app < 0 || app >= ARRAY_SIZE(display_conf.framerate_app) || val < 0) { @@ -628,8 +624,6 @@ GVariant *dbus_setautobrightnessmin(GDBusConnection *conn, pid_t pid; int id = 0; - CHECK_POWEROFF(); - if (!display_info.set_autobrightness_min) { ret = -EIO; goto error; @@ -662,8 +656,6 @@ GVariant *dbus_setlcdtimeout(GDBusConnection *conn, pid_t pid; int id = 0; - CHECK_POWEROFF(); - g_variant_get(param, "(iii)", &on, &dim, &holdkey_block); pid = dbus_connection_get_sender_pid(conn, sender); @@ -690,8 +682,6 @@ GVariant *dbus_lockscreenbgon(GDBusConnection *conn, int ret = 0; char *on = NULL; - CHECK_POWEROFF(); - g_variant_get(param, "(s)", &on); if (!strcmp(on, "true")) { @@ -714,8 +704,6 @@ GVariant *dbus_dumpmode(GDBusConnection *conn, int ret = 0; char *on; - CHECK_POWEROFF(); - g_variant_get(param, "(s)", &on); if (!strcmp(on, "on")) { @@ -736,8 +724,7 @@ GVariant *dbus_savelog(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) { - if (!device_poweroff(NULL)) - save_display_log(); + pm_save_logdump(); return dbus_handle_new_g_variant_tuple(); } @@ -748,8 +735,6 @@ GVariant *dbus_powerkeyignore(GDBusConnection *conn, int ret = 0; int on; - CHECK_POWEROFF(); - g_variant_get(param, "(i)", &on); if (CHECK_OPS(keyfilter_ops, set_powerkey_ignore)) @@ -764,8 +749,6 @@ GVariant *dbus_powerkeylcdoff(GDBusConnection *conn, { int ret; - CHECK_POWEROFF(); - if (CHECK_OPS(keyfilter_ops, powerkey_lcdoff)) ret = keyfilter_ops->powerkey_lcdoff(); else @@ -781,8 +764,6 @@ GVariant *dbus_customlcdon(GDBusConnection *conn, int ret = 0; int timeout; - CHECK_POWEROFF(); - g_variant_get(param, "(i)", &timeout); ret = custom_lcdon(timeout); @@ -790,6 +771,47 @@ GVariant *dbus_customlcdon(GDBusConnection *conn, return g_variant_new("(i)", ret); } +GVariant *dbus_customlcdoff(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int ret = 0; + enum device_flags flag; + char *reason_str; + + g_variant_get(param, "(s)", &reason_str); + + if (!strcmp(reason_str, LCDOFF_PROXI_STR)) + flag = LCD_OFF_BY_PROXIMITY; + else if (!strcmp(reason_str, LCDOFF_GESTURE_STR)) + flag = LCD_OFF_BY_GESTURE; + else { + _E("%s resean is invalid, dbus ignored!", reason_str); + ret = -EINVAL; + goto out; + } + + ret = custom_lcdoff(flag); + +out: + return g_variant_new("(i)", ret); +} + +GVariant *dbus_platformlcdcontrol(GDBusConnection *conn, + const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, + GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) +{ + int ret = 0; + int type, timeout; + char *reason; + + g_variant_get(param, "(isi)", &type, &reason, &timeout); + + ret = display_platform_control(type, reason, timeout); + + return g_variant_new("(i)", ret); +} + GVariant *dbus_staytouchscreenoff(GDBusConnection *conn, const gchar *sender, const gchar *path, const gchar *iface, const gchar *name, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data) @@ -797,8 +819,6 @@ GVariant *dbus_staytouchscreenoff(GDBusConnection *conn, int ret = 0; int val; - CHECK_POWEROFF(); - g_variant_get(param, "(i)", &val); set_stay_touchscreen_off(val); @@ -813,8 +833,6 @@ GVariant *dbus_lcdpaneloffmode(GDBusConnection *conn, int ret = 0; int val; - CHECK_POWEROFF(); - g_variant_get(param, "(i)", &val); set_lcd_paneloff_mode(val); @@ -829,8 +847,6 @@ GVariant *dbus_actorcontrol(GDBusConnection *conn, int ret = 0, val, actor; char *op; - CHECK_POWEROFF(); - g_variant_get(param, "(sii)", &op, &actor, &val); if (!strcmp(op, "set")) @@ -850,8 +866,6 @@ GVariant *dbus_getcustombrightness(GDBusConnection *conn, { int status = 0; - CHECK_POWEROFF(); - status = backlight_ops.get_custom_status(); return g_variant_new("(i)", status); @@ -913,8 +927,6 @@ GVariant *dbus_locktimeout_expired(GDBusConnection *conn, struct pmlock_expired_s *ex = NULL; GVariant *gvar = NULL; - CHECK_POWEROFF(); - g_variant_get(param, "(s)", &req_id); pid = dbus_connection_get_sender_pid(conn, sender); @@ -1036,8 +1048,6 @@ GVariant *dbus_locktimeout_input(GDBusConnection *conn, struct pmlock_expired_s *ex; int value; - CHECK_POWEROFF(); - g_variant_get(param, "(si)", &req_id, &value); ex = calloc(1, sizeof(struct pmlock_expired_s)); @@ -1087,6 +1097,8 @@ static const dbus_method_s dbus_methods[] = { { "PowerKeyIgnore", "i", "i", dbus_powerkeyignore }, { "PowerKeyLCDOff", NULL, "i", dbus_powerkeylcdoff }, { "CustomLCDOn", "i", "i", dbus_customlcdon }, + { "CustomLCDOff", "s", "i", dbus_customlcdoff }, + { "PlatformLCDControl", "isi", "i", dbus_platformlcdcontrol }, { "StayTouchScreenOff", "i", "i", dbus_staytouchscreenoff }, { "LCDPanelOffMode", "i", "i", dbus_lcdpaneloffmode }, { "ActorControl", "sii", "i", dbus_actorcontrol }, @@ -1124,6 +1136,63 @@ static void homescreen_signal_handler(GDBusConnection *conn, g_free(screen); } +static void sim_signal_handler(GDBusConnection *conn, + const gchar *sender, + const gchar *path, + const gchar *iface, + const gchar *name, + GVariant *param, + gpointer data) +{ + int ret, val; + static int state = false; + + ret = vconf_get_bool(VCONFKEY_LCD_BRIGHTNESS_INIT, &state); + if (ret < 0 || state) { + _E("Failed to get %s", VCONFKEY_LCD_BRIGHTNESS_INIT); + return; + } + + g_variant_get(param, "(i)", &val); + + if (val != SIM_CARD_NOT_PRESENT) { + state = true; + vconf_set_bool(VCONFKEY_LCD_BRIGHTNESS_INIT, state); + vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, PM_DEFAULT_BRIGHTNESS); + backlight_ops.set_brightness(PM_DEFAULT_BRIGHTNESS); + _I("SIM card is inserted at first."); + } +} + +static void changestate_signal_handler(GDBusConnection *conn, + const gchar *sender, + const gchar *path, + const gchar *iface, + const gchar *name, + GVariant *param, + gpointer data) +{ + int val; + char *appid, *pkgid, *state, *type; + pid_t pid; + + g_variant_get(param, "(issss)", &val, &appid, &pkgid, &state, &type); + + pid = (pid_t)val; + + if (!strcmp(state, "bg")) { + _D("process(%d) was going background.", pid); + device_notify(DEVICE_NOTIFIER_PROCESS_BACKGROUND, &pid); + } else if (!strcmp(state, "fg")) { + _D("process(%d) was going foreground.", pid); + device_notify(DEVICE_NOTIFIER_PROCESS_FOREGROUND, &pid); + } + g_free(appid); + g_free(pkgid); + g_free(state); + g_free(type); +} + /* * Default capability * api := LCDON | LCDOFF | BRIGHTNESS @@ -1152,16 +1221,34 @@ int init_pm_dbus(void) if (ret < 0) _E("fail to init dbus method(%d)", ret); +#ifndef MICRO_DD + ret = subscribe_dbus_signal(NULL, + TELEPHONY_PATH, + TELEPHONY_INTERFACE_SIM, + SIGNAL_SIM_STATUS, + sim_signal_handler, + NULL, NULL); + if (ret <= 0) + _E("Failed to register signal handler: %d", ret); +#endif + ret = subscribe_dbus_signal(NULL, DEVICED_OBJECT_PATH, DEVICED_INTERFACE_NAME, SIGNAL_HOMESCREEN, homescreen_signal_handler, NULL, NULL); - if (ret <= 0) { - _E("Failed to register signal handler! %d", ret); - return ret; - } + if (ret <= 0) + _E("Failed to register signal handler: %d", ret); + + ret = subscribe_dbus_signal(NULL, + AUL_APPSTATUS_PATH, + AUL_APPSTATUS_INTERFACE, + APP_CHANGE_STATE, + changestate_signal_handler, + NULL, NULL); + if (ret <= 0) + _E("Failed to register signal handler: %d", ret); return 0; } diff --git a/src/display/display-ops.h b/src/display/display-ops.h index 93f8abe..ee60d5f 100644 --- a/src/display/display-ops.h +++ b/src/display/display-ops.h @@ -27,6 +27,7 @@ struct display_ops { char *name; void (*init) (void *data); void (*exit) (void *data); + int (*func) (unsigned int cmd, void *arg); }; void display_ops_init(void *data); @@ -46,6 +47,16 @@ void add_display(const struct display_ops *disp); void remove_display(const struct display_ops *disp); const struct display_ops *find_display_feature(const char *name); +#define FIND_DISPLAY(dev, name) do { \ + if (!dev) dev = find_display_feature(name); \ +} while (0) + +#define FIND_DISPLAY_INT(dev, name)do { \ + if (!dev) dev = find_display_feature(name); if (!dev) return -ENODEV; \ +} while (0) + +#define DISPLAY_FUNC(a, b) (((a) << 16) | (b)) + struct display_plugin { void *handle; int (*pm_lock_internal) (pid_t pid, int s_bits, int flag, int timeout); diff --git a/src/display/input.c b/src/display/input.c index a986504..a55d05b 100644 --- a/src/display/input.c +++ b/src/display/input.c @@ -26,6 +26,7 @@ #include "util.h" #include "core.h" #include "poll.h" +#include "ambient-mode.h" #define SEAT_NAME "seat0" @@ -42,7 +43,7 @@ static inline void process_event(struct libinput_event *ev) struct libinput *li; struct libinput_event_keyboard *k; unsigned int time; - int fd; + int fd = 0; if (!pm_callback) return; @@ -61,8 +62,6 @@ static inline void process_event(struct libinput_event *ev) } switch (libinput_event_get_type(ev)) { - case LIBINPUT_EVENT_DEVICE_ADDED: - return; case LIBINPUT_EVENT_KEYBOARD_KEY: k = libinput_event_get_keyboard_event(ev); time = libinput_event_keyboard_get_time(k); @@ -78,35 +77,34 @@ static inline void process_event(struct libinput_event *ev) _D("time %ld.%06ld type %d code %d value %d fd %d", input.time.tv_sec, input.time.tv_usec, input.type, input.code, input.value, fd); - - if (CHECK_OPS(keyfilter_ops, check) && - keyfilter_ops->check(&input, fd) != 0) - return; break; case LIBINPUT_EVENT_POINTER_MOTION: case LIBINPUT_EVENT_POINTER_BUTTON: - case LIBINPUT_EVENT_POINTER_AXIS: - li = libinput_event_get_context(ev); input.type = EV_REL; - - fd = libinput_get_fd(li); - _D("type %d fd %d", input.type, fd); - - if (CHECK_OPS(keyfilter_ops, check) && - keyfilter_ops->check(&input, fd) != 0) - return; break; case LIBINPUT_EVENT_TOUCH_DOWN: + input.type = EV_ABS; + input.value = KEY_PRESSED; + break; case LIBINPUT_EVENT_TOUCH_UP: + input.type = EV_ABS; + input.value = KEY_RELEASED; + break; case LIBINPUT_EVENT_TOUCH_MOTION: case LIBINPUT_EVENT_TOUCH_FRAME: - if (touch_event_blocked()) - return ; + if (touch_event_blocked() && !ambient_get_state() && !display_conf.touch_wakeup) + return; + input.type = EV_ABS; + input.value = KEY_BEING_PRESSED; break; default: - break; + return; } + if (CHECK_OPS(keyfilter_ops, check) && + keyfilter_ops->check(&input, fd) != 0) + return; + /* lcd on or update lcd timeout */ (*pm_callback) (INPUT_POLL_EVENT, NULL); } @@ -116,10 +114,6 @@ static gboolean input_handler(gint fd, GIOCondition cond, void *data) struct libinput_event *ev; struct libinput *input = (struct libinput *)data; - /* Ignore input during poweroff */ - if (device_poweroff(NULL)) - return G_SOURCE_CONTINUE; - if (!input) return G_SOURCE_CONTINUE; @@ -163,7 +157,7 @@ static const struct libinput_interface interface = { .close_restricted = close_restricted, }; -int init_input(void) +gboolean init_input(gpointer data) { int ret; int fd; @@ -171,25 +165,25 @@ int init_input(void) udev = udev_new(); if (!udev) { _E("fail to create udev library context"); - return -EPERM; + return G_SOURCE_REMOVE; } li = libinput_udev_create_context(&interface, NULL, udev); if (!li) { _E("fail to create a new libinput context from udev"); - return -EPERM; + return G_SOURCE_REMOVE; } ret = libinput_udev_assign_seat(li, SEAT_NAME); if (ret < 0) { _E("fail to assign a seat"); - return -EPERM; + return G_SOURCE_REMOVE; } fd = libinput_get_fd(li); if (fd < 0) { _E("fail to get file descriptor from libinput context"); - return -EPERM; + return G_SOURCE_REMOVE; } /* add to poll handler */ @@ -200,10 +194,10 @@ int init_input(void) _E("fail to g_unix_fd_add"); /* TODO Does it really need close()? */ close(fd); - return -EPERM; + return G_SOURCE_REMOVE; } - return 0; + return G_SOURCE_REMOVE; } int exit_input(void) diff --git a/src/display/lock-detector.c b/src/display/lock-detector.c index 0560ef4..b2fa365 100644 --- a/src/display/lock-detector.c +++ b/src/display/lock-detector.c @@ -34,26 +34,42 @@ #include "util.h" #include "core.h" #include "core/list.h" +#include "core/device-notifier.h" struct lock_info { unsigned long hash; char *name; int state; + int pid; int count; - long locktime; - long unlocktime; - long time; + time_t locktime; + time_t unlocktime; + time_t time; }; +#define DEVICED_RUN_PATH "/run/deviced" +#define PMLOCK_HISTORY_RUN_PATH "/run/deviced/pmlock_detail.log" +#define PMLOCK_HISTORY_GHOST_PATH "/var/log/ghost/boot/current/pmlock_detail.log" +#define PMLOCK_HISTORY_FILE "/var/log/pmlock_detail.log" + +#define PM_STATE_LOG_GHOST_PATH "/var/log/ghost/boot/current/pm_state.log" +#define PM_STATE_LOG_FILE "/var/log/pm_state.log" + +#define SAVE_PMLOCK_OVER_TIME 60 /* seconds */ #define LIMIT_COUNT 128 static dd_list *lock_info_list; +static const char state_string[5][8] = { + "START", "NORMAL", "LCDDIM", "LCDOFF", "SLEEP" +}; -static long get_time(void) +static time_t get_time(void) { - struct timeval now; - gettimeofday(&now, NULL); - return (long)(now.tv_sec * 1000 + now.tv_usec / 1000); + struct timespec tspec; + + clock_gettime(CLOCK_REALTIME, &tspec); + + return (time_t)tspec.tv_sec; } static void shrink_lock_info_list(void) @@ -69,7 +85,7 @@ static void shrink_lock_info_list(void) DD_LIST_REVERSE_FOREACH_SAFE(lock_info_list, l, l_prev, info) { if (info->locktime == 0) { - DD_LIST_REMOVE_LIST(lock_info_list, l); + DD_LIST_REMOVE(lock_info_list, info); if (info->name) free(info->name); free(info); @@ -80,11 +96,12 @@ static void shrink_lock_info_list(void) } } -int set_lock_time(const char *pname, int state) +int set_lock_time(pid_t pid, const char *pname, int state) { struct lock_info *info; dd_list *l; unsigned long val; + char ht[15]; if (!pname) return -EINVAL; @@ -92,20 +109,23 @@ int set_lock_time(const char *pname, int state) if (state < S_NORMAL || state > S_SLEEP) return -EINVAL; - val = g_str_hash(pname); + save_pmlock(state, true, pid); + snprintf(ht, sizeof(ht), "[%d]%d", state, pid); + val = g_str_hash(ht); - DD_LIST_FOREACH(lock_info_list, l, info) - if (info->hash == val && - !strncmp(info->name, pname, strlen(pname)+1) && - info->state == state) { - info->count += 1; - if (info->locktime == 0) - info->locktime = get_time(); - info->unlocktime = 0; - DD_LIST_REMOVE(lock_info_list, info); - DD_LIST_PREPEND(lock_info_list, info); - return 0; - } + DD_LIST_FOREACH(lock_info_list, l, info) { + if (!(info->hash == val) || !(info->state == state)) + continue; + + info->count += 1; + if (info->locktime == 0) + info->locktime = get_time(); + info->unlocktime = 0; + DD_LIST_REMOVE(lock_info_list, info); + DD_LIST_PREPEND(lock_info_list, info); + + return 0; + } info = malloc(sizeof(struct lock_info)); if (!info) { @@ -114,7 +134,15 @@ int set_lock_time(const char *pname, int state) } info->hash = val; - info->name = strndup(pname, strlen(pname)); + if (pid < INTERNAL_LOCK_BASE) + info->name = strndup(pname, strlen(pname)); + else { + char internal_case[25]; + + snprintf(internal_case, sizeof(internal_case), "%s(%d)", pname, pid); + info->name = strndup(internal_case, strlen(internal_case)); + } + info->pid = pid; info->state = state; info->count = 1; info->locktime = get_time(); @@ -126,31 +154,63 @@ int set_lock_time(const char *pname, int state) return 0; } -int set_unlock_time(const char *pname, int state) +static void pmlock_info_detail(char *pname, pid_t pid, time_t locktime, + time_t unlocktime, long diff) +{ + _cleanup_fclose_ FILE *fp = NULL; + char *lock, *unlock, *tmp; + int ret; + + fp = fopen(PMLOCK_HISTORY_RUN_PATH, "a"); + if (fp == NULL) { + _E("Can not open detail path"); + return; + } + + lock = ctime(&locktime); + tmp = strchr(lock, '\n'); + if (tmp) + *tmp = '\0'; + + if (unlocktime != 0) { + unlock = ctime(&unlocktime); + tmp = strchr(unlock, '\n'); + if (tmp) + *tmp = '\0'; + } else + unlock = "continue.."; + + ret = fprintf(fp, "%6d [%24s] ~ [%24s] %5lu sec %s \n", + pid, lock, unlock, diff, pname); + if (ret < 0) + _E("write failed %d", ret); +} + +int set_unlock_time(pid_t pid, int state) { bool find = false; long diff; struct lock_info *info; dd_list *l; unsigned long val; - - if (!pname) - return -EINVAL; + char ht[15]; if (state < S_NORMAL || state > S_SLEEP) return -EINVAL; - val = g_str_hash(pname); + save_pmlock(state, false, pid); + + snprintf(ht, sizeof(ht), "[%d]%d", state, pid); + val = g_str_hash(ht); - DD_LIST_FOREACH(lock_info_list, l, info) - if (info->hash == val && - !strncmp(info->name, pname, strlen(pname)+1) && - info->state == state) { + DD_LIST_FOREACH(lock_info_list, l, info) { + if (info->hash == val && info->state == state) { DD_LIST_REMOVE(lock_info_list, info); DD_LIST_PREPEND(lock_info_list, info); find = true; break; } + } if (!find) return -EINVAL; @@ -163,6 +223,9 @@ int set_unlock_time(const char *pname, int state) diff = info->unlocktime - info->locktime; if (diff > 0) info->time += diff; + if (diff > SAVE_PMLOCK_OVER_TIME) + pmlock_info_detail(info->name, info->pid, info->locktime, info->unlocktime, diff); + info->locktime = 0; if (DD_LIST_LENGTH(lock_info_list) > LIMIT_COUNT) @@ -191,42 +254,124 @@ void free_lock_info_list(void) void print_lock_info_list(int fd) { struct lock_info *info; + time_t cur_time; dd_list *l; - char buf[255]; + long time; + char cur_buf[30], lock_buf[30], unlock_buf[30], buf[255]; + char *tmp; int ret; if (!lock_info_list) return; - snprintf(buf, sizeof(buf), - "current time : %ld ms\n", get_time()); + cur_time = get_time(); + ctime_r(&cur_time, cur_buf); + snprintf(buf, sizeof(buf), "current time : %s\n", cur_buf); ret = write(fd, buf, strlen(buf)); if (ret < 0) _E("write() failed (%d)", errno); snprintf(buf, sizeof(buf), - "[%10s %6s] %6s %10s %10s %10s %s\n", "hash", "state", - "count", "locktime", "unlocktime", "time", "process name"); + "[%10s %6s] %6s %-20s %-20s %10s %15s\n", "hash", "state", + "count", "last locktime", "last unlocktime", "time(s)", "process name"); ret = write(fd, buf, strlen(buf)); if (ret < 0) _E("write() failed (%d)", errno); DD_LIST_FOREACH(lock_info_list, l, info) { - long time = 0; + time = 0; if (info->locktime != 0 && info->unlocktime == 0) time = get_time() - info->locktime; + + *lock_buf = '\0'; + *unlock_buf = '\0'; + + if (info->locktime) { + ctime_r(&info->locktime, lock_buf); + tmp = strchr(lock_buf, '\n'); + if (!tmp) + continue; + *tmp = '\0'; + } + if (info->unlocktime) { + ctime_r(&info->unlocktime, unlock_buf); + tmp = strchr(unlock_buf, '\n'); + if (!tmp) + continue; + *tmp = '\0'; + } + snprintf(buf, sizeof(buf), - "[%10lu %6d] %6d %10ld %10ld %10ld %s\n", - info->hash, - info->state, - info->count, - info->locktime, - info->unlocktime, - info->time + time, - info->name); + "[%10lu %6s] %6d %25s %25s %10ld %s\n", + info->hash, + state_string[info->state], + info->count, + lock_buf, + unlock_buf, + info->time + time, + info->name); ret = write(fd, buf, strlen(buf)); if (ret < 0) _E("write() failed (%d)", errno); } } +static void cleanup_pmlock_statistics(void) +{ + struct lock_info *info; + GList *n; + time_t time; + long diff; + + time = get_time(); + + DD_LIST_FOREACH(lock_info_list, n, info) { + if (info->unlocktime != 0) + continue; + + diff = time - info->locktime; + if (diff > SAVE_PMLOCK_OVER_TIME) + pmlock_info_detail(info->name, info->pid, info->locktime, 0, diff); + } +} + +int pm_save_logdump(void) +{ + int ret; + + cleanup_pmlock_statistics(); + ret = do_copy_force(PMLOCK_HISTORY_RUN_PATH, PMLOCK_HISTORY_FILE); + if (ret < 0) + _W("Can not move(%d)", ret); + + save_display_log(PM_STATE_LOG_FILE); + + return ret; +} + +static int pmlock_detector_poweroff_cb(void *data) +{ + int ret; + + cleanup_pmlock_statistics(); + ret = do_copy_force(PMLOCK_HISTORY_RUN_PATH, PMLOCK_HISTORY_GHOST_PATH); + if (ret < 0) + _W("Can not move(%d)", ret); + + save_display_log(PM_STATE_LOG_GHOST_PATH); + + return 0; +} + +void pm_lock_detector_init(void) +{ + int ret; + + ret = do_mkdir(DEVICED_RUN_PATH, 0770); + if (ret < 0) { + _E("Fail to make directory %d", ret); + return; + } + + register_notifier(DEVICE_NOTIFIER_POWEROFF, pmlock_detector_poweroff_cb); +} diff --git a/src/display/lock-detector.h b/src/display/lock-detector.h index 681b896..d7305e0 100644 --- a/src/display/lock-detector.h +++ b/src/display/lock-detector.h @@ -26,10 +26,15 @@ #ifndef _LOCK_DETECTOR_H_ #define _LOCK_DETECTOR_H_ -int set_lock_time(const char *pname, int state); -int set_unlock_time(const char *pname, int state); +int set_lock_time(pid_t pid, const char *pname, int state); +int set_unlock_time(pid_t pid, int state); void free_lock_info_list(void); void print_lock_info_list(int fd); +int pm_save_logdump(void); +void pm_lock_detector_init(void); + +#define PM_STATE_LOG_FILE "/var/log/pm_state.log" + #endif //_LOCK_DETECTOR_H_ diff --git a/src/display/poll.h b/src/display/poll.h index 93afe57..9815191 100644 --- a/src/display/poll.h +++ b/src/display/poll.h @@ -26,7 +26,7 @@ #ifndef __PM_POLL_H__ #define __PM_POLL_H__ - +#include #include /** * @addtogroup POWER_MANAGER @@ -63,8 +63,14 @@ enum { INTERNAL_LOCK_PM, INTERNAL_LOCK_HALLIC, INTERNAL_LOCK_SWIM, + INTERNAL_LOCK_OVERHEAT, + INTERNAL_LOCK_OVERCOOL, }; +#define KEY_RELEASED 0 +#define KEY_PRESSED 1 +#define KEY_BEING_PRESSED 2 + #define SIGNAL_NAME_LCD_CONTROL "lcdcontol" #define LCD_NORMAL 0x01 /**< NORMAL state */ @@ -145,7 +151,7 @@ typedef struct { extern int (*pm_callback) (int, PMMsg *); -int init_input(void); +gboolean init_input(gpointer data); int exit_input(void); /** diff --git a/src/display/setting.c b/src/display/setting.c index b109d8c..f5a1cb3 100644 --- a/src/display/setting.c +++ b/src/display/setting.c @@ -21,14 +21,13 @@ #include #include #include -#include -#include #include "ambient-mode.h" #include "core.h" #include "util.h" #include "setting.h" #include "display-ops.h" +#include "shared/eventsystem.h" #define LCD_DIM_RATIO 0.3 #define LCD_MAX_DIM_TIMEOUT 7000 @@ -48,10 +47,12 @@ static int custom_on_timeout = 0; static int custom_normal_timeout = 0; static int custom_dim_timeout = 0; -static void display_state_send_system_event(int state) +int (*update_pm_setting) (int key_idx, int val); + +static gboolean display_state_send_system_event(gpointer data) { - bundle *b; const char *str; + int state = (int)data; if (state == S_NORMAL) str = EVT_VAL_DISPLAY_NORMAL; @@ -60,14 +61,13 @@ static void display_state_send_system_event(int state) else if (state == S_LCDOFF) str = EVT_VAL_DISPLAY_OFF; else - return; + return G_SOURCE_REMOVE; + + _I("Set pmstate of eventsystem : [%s]", str); - _I("eventsystem (%s)", str); + event_system_send(SYS_EVENT_DISPLAY_STATE, EVT_KEY_DISPLAY_STATE, str); - b = bundle_create(); - bundle_add_str(b, EVT_KEY_DISPLAY_STATE, str); - eventsystem_send_system_event(SYS_EVENT_DISPLAY_STATE, b); - bundle_free(b); + return G_SOURCE_REMOVE; } int set_force_lcdtimeout(int timeout) @@ -108,32 +108,32 @@ void set_lock_screen_bg_state(bool state) lock_screen_bg_state = state; } +int get_lowbatt_status(int *val) +{ + return vconf_get_int(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, val); +} + +int get_usb_status(int *val) +{ + return vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, val); +} + int set_setting_pmstate(int val) { - static int old = -1; - int ret; + static int prev = S_NORMAL; - if (old == val) + if (prev == val) return 0; - old = val; - display_state_send_system_event(val); - ret = vconf_set_int(VCONFKEY_PM_STATE, val); - if (ret < 0) - _E("Failed to set vconf value for pm state: %d", vconf_get_ext_errno()); + prev = val; - return ret; + g_idle_add(display_state_send_system_event, (gpointer)val); + return vconf_set_int(VCONFKEY_PM_STATE, val); } int get_setting_brightness(int *level) { - int ret; - - ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, level); - if (ret < 0) - _E("Failed to get vconf value for lcd brightness: %d", vconf_get_ext_errno()); - - return ret; + return vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, level); } void get_dim_timeout(int *dim_timeout) @@ -145,14 +145,14 @@ void get_dim_timeout(int *dim_timeout) return; } - if (ambient_get_condition() == true) { + if (!display_conf.dimming || ambient_get_condition()) { *dim_timeout = LCD_MIN_DIM_TIMEOUT; return; } ret = vconf_get_int(setting_keys[SETTING_TO_NORMAL], &vconf_timeout); - if (ret < 0) { - _E("Failed to get vconf value for setting timeout: %d", vconf_get_ext_errno()); + if (ret != 0) { + _E("Failed ro get setting timeout!"); vconf_timeout = DEFAULT_NORMAL_TIMEOUT; } @@ -212,7 +212,11 @@ int set_custom_lcdon_timeout(int timeout) return changed; } - custom_dim_timeout = (double)timeout * LCD_DIM_RATIO; + if (display_conf.dimming) + custom_dim_timeout = (double)timeout * LCD_DIM_RATIO; + else + custom_dim_timeout = LCD_MIN_DIM_TIMEOUT; + custom_normal_timeout = timeout - custom_dim_timeout; _I("custom normal(%d), dim(%d)", custom_normal_timeout, diff --git a/src/display/setting.h b/src/display/setting.h index 31dc03d..b34b21c 100644 --- a/src/display/setting.h +++ b/src/display/setting.h @@ -47,6 +47,8 @@ enum { SETTING_END }; +extern int (*update_pm_setting) (int key_idx, int val); + int get_setting_brightness(int *level); /* @@ -96,6 +98,15 @@ extern int get_usb_status(int *val); */ extern int set_setting_pmstate(int val); +/* + * get current battery low status at SLP-setting "memory/Battery/Status/Low" + * + * @internal + * @param[in] val current low battery status + * @return 0 : success, -1 : error + */ +extern int get_lowbatt_status(int *val); + //FIXME int __get_lock_screen_state(void); diff --git a/src/display/slave-logging.c b/src/display/slave-logging.c new file mode 100644 index 0000000..f02bcd0 --- /dev/null +++ b/src/display/slave-logging.c @@ -0,0 +1,94 @@ +/* + * deviced + * + * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include + +#include "core/common.h" +#include "core/log.h" +#include "display/core.h" +#include "display/poll.h" + +#define BUFF_MAX 255 +#define LOCK_STR_MAX 20 +#define DISP_LOCK_STR "displock" +#define MAIN_LOCK_STR "mainlock" +#define DIM_LOCK_STR "dimlock" + +#define USER_WAKELOCK_NODE "/sys/power/slave_wake_lock" +#define USER_WAKEUNLOCK_NODE "/sys/power/slave_wake_unlock" + +static bool userlock_saving_support; + +int save_pmlock(enum state_t state, bool on, pid_t pid) +{ + int ret = 0; + char *node, *state_str; + char str[LOCK_STR_MAX]; + + if (!userlock_saving_support) + return -ENOSYS; + + switch (state) { + case S_NORMAL: + state_str = DISP_LOCK_STR; + break; + case S_LCDDIM: + state_str = DIM_LOCK_STR; + break; + case S_LCDOFF: + state_str = MAIN_LOCK_STR; + break; + default: + return -EINVAL; + } + + node = (on ? USER_WAKELOCK_NODE : USER_WAKEUNLOCK_NODE); + + snprintf(str, LOCK_STR_MAX, "%s %d", state_str, pid); + + ret = sys_set_str(node, str); + if (ret < 0) + _E("Failed to set disp userlock state!"); + + return ret; +} + +void init_save_userlock(void) +{ + int ret; + char str[BUFF_MAX]; + + userlock_saving_support = false; + + ret = sys_get_str(USER_WAKELOCK_NODE, str, sizeof(str)); + if (ret < 0) { + _E("Failed to load userlock(lock)!"); + return; + } + + ret = sys_get_str(USER_WAKEUNLOCK_NODE, str, sizeof(str)); + if (ret < 0) { + _E("Failed to load userlock(unlock)!"); + return; + } + + userlock_saving_support = true; + _I("userlock-saving is enabled!"); +} + diff --git a/src/dump/dump.c b/src/dump/dump.c index 1695628..7a0e69d 100644 --- a/src/dump/dump.c +++ b/src/dump/dump.c @@ -121,7 +121,7 @@ static void dump_init(void *data) } static const struct device_ops dump_device_ops = { - .name = "dump", + DECLARE_NAME_LEN("dump"), .init = dump_init, }; diff --git a/src/extcon/extcon.c b/src/extcon/extcon.c index 145eeda..5bdfc45 100644 --- a/src/extcon/extcon.c +++ b/src/extcon/extcon.c @@ -512,7 +512,7 @@ static void extcon_exit(void *data) } static const struct device_ops extcon_device_ops = { - .name = "extcon", + DECLARE_NAME_LEN("extcon"), .probe = extcon_probe, .init = extcon_init, .exit = extcon_exit, diff --git a/src/extcon/extcon.h b/src/extcon/extcon.h index 23505e6..e6b3ab9 100644 --- a/src/extcon/extcon.h +++ b/src/extcon/extcon.h @@ -56,11 +56,6 @@ typedef enum { } extcon_hdmi_state_e; typedef enum { - DOCK_NONE = 0, - DOCK_SOUND = 7 -} extcon_dock_state_e; - -typedef enum { USBHOST_DISCONNECTED, USBHOST_CONNECTED } extcon_usbhost_state_e; diff --git a/src/ir/ir.c b/src/ir/ir.c index 2b8d37d..3f69d31 100644 --- a/src/ir/ir.c +++ b/src/ir/ir.c @@ -189,7 +189,7 @@ static void ir_exit(void *data) } static const struct device_ops ir_device_ops = { - .name = "ir", + DECLARE_NAME_LEN("ir"), .probe = ir_probe, .init = ir_init, .exit = ir_exit, diff --git a/src/led/rgb.c b/src/led/rgb.c index 5b115da..0386ab6 100644 --- a/src/led/rgb.c +++ b/src/led/rgb.c @@ -404,7 +404,7 @@ static int rgb_probe(void *data) } static const struct device_ops rgbled_device_ops = { - .name = "rgbled", + DECLARE_NAME_LEN("rgbled"), .probe = rgb_probe, .init = rgb_init, .exit = rgb_exit, diff --git a/src/led/torch.c b/src/led/torch.c index 2024ebd..ca0a0df 100644 --- a/src/led/torch.c +++ b/src/led/torch.c @@ -216,7 +216,7 @@ static void torch_exit(void *data) } static const struct device_ops torchled_device_ops = { - .name = "torchled", + DECLARE_NAME_LEN("torchled"), .probe = torch_probe, .init = torch_init, .exit = torch_exit, diff --git a/src/led/touch-key.c b/src/led/touch-key.c index 2852ac2..281f0a8 100644 --- a/src/led/touch-key.c +++ b/src/led/touch-key.c @@ -317,7 +317,7 @@ static int touchled_execute(void *data) } static const struct device_ops touchled_device_ops = { - .name = TOUCHLED_NAME, + DECLARE_NAME_LEN(TOUCHLED_NAME), .probe = touchled_probe, .init = touchled_init, .exit = touchled_exit, diff --git a/src/power/power-handler.c b/src/power/power-handler.c index 4303a4d..8bdba86 100644 --- a/src/power/power-handler.c +++ b/src/power/power-handler.c @@ -753,7 +753,7 @@ static void power_init(void *data) } static const struct device_ops power_device_ops = { - .name = POWER_OPS_NAME, + DECLARE_NAME_LEN(POWER_OPS_NAME), .init = power_init, .execute = power_execute, }; diff --git a/src/shared/common.h b/src/shared/common.h index 5a3ef23..f505204 100644 --- a/src/shared/common.h +++ b/src/shared/common.h @@ -26,6 +26,12 @@ extern "C" { #endif +#ifdef MICRO_DD +#define wearable_mode() 1 +#else +#define wearable_mode() 0 +#endif + #ifndef API #define API __attribute__ ((visibility("default"))) #endif diff --git a/src/shared/deviced-systemd.c b/src/shared/deviced-systemd.c index fe65226..df10e1c 100644 --- a/src/shared/deviced-systemd.c +++ b/src/shared/deviced-systemd.c @@ -31,7 +31,6 @@ #include "core/log.h" - #define SYSTEMD_UNIT_ESCAPE_CHAR ".-" typedef unsigned int uint; @@ -295,6 +294,48 @@ GVariant * deviced_systemd_get_service_property(const char *unit, return val; } +int check_systemd_active(void) +{ + GVariant *msg, inner; + int ret = FALSE; + const char *state; + char *pa[2]; + + pa[0] = "org.freedesktop.systemd1.Unit"; + pa[1] = "ActiveState"; + + _I("%s %s", pa[0], pa[1]); + + msg = dbus_handle_method_sync_with_reply_var("org.freedesktop.systemd1", + "/org/freedesktop/systemd1/unit/default_2etarget", + "org.freedesktop.DBus.Properties", + "Get", g_variant_new("(ss)", pa[0], pa[1])); + + if (!msg) + return -EBADMSG; + + if (!dh_get_param_from_var(msg, "(v)", &inner)) { + _E("Failed to get signature(%s): no message", g_variant_get_type_string(msg)); + ret = -EBADMSG; + goto out2; + } + + if (!dh_get_param_from_var(inner, "s", &state)) { + _E("Failed to get signature(%s): no message", g_variant_get_type_string(inner)); + ret = -EBADMSG; + goto out1; + } + + if (strncmp(state, "active", 6) == 0) + ret = TRUE; +out1: + g_variant_unref(inner); + +out2: + g_variant_unref(msg); + return ret; +} + #if 0 #define DEFINE_SYSTEMD_GET_PROPERTY(iface, type, value) \ int deviced_systemd_get_##iface##_property_as_##type( \ diff --git a/src/shared/deviced-systemd.h b/src/shared/deviced-systemd.h index 715bb46..5a6f44f 100644 --- a/src/shared/deviced-systemd.h +++ b/src/shared/deviced-systemd.h @@ -35,12 +35,13 @@ int deviced_systemd_start_unit(char *name); int deviced_systemd_stop_unit(char *name); +int check_systemd_active(void); GVariant * deviced_systemd_get_manager_property(const char *property); GVariant * deviced_systemd_get_unit_property(const char *unit, const char *property); GVariant * deviced_systemd_get_service_property(const char* unit, const char* property); -#if 0 +#if 0 int deviced_systemd_get_manager_property_as_int32(const char *iface, const char *property, int *result); int deviced_systemd_get_manager_property_as_uint32(const char *iface, const char *property, unsigned int *result); int deviced_systemd_get_manager_property_as_int64(const char *iface, const char *property, long long *result); diff --git a/src/thermal/thermal.c b/src/thermal/thermal.c index 3de70b9..8b5bdea 100644 --- a/src/thermal/thermal.c +++ b/src/thermal/thermal.c @@ -142,7 +142,7 @@ static int thermal_probe(void *data) } static const struct device_ops thermal_ops = { - .name = "thermal", + DECLARE_NAME_LEN("thermal"), .probe = thermal_probe, .init = thermal_init, .exit = thermal_exit, diff --git a/src/touchscreen/sensitivity.c b/src/touchscreen/sensitivity.c index e9830a4..d3d14d6 100644 --- a/src/touchscreen/sensitivity.c +++ b/src/touchscreen/sensitivity.c @@ -218,7 +218,7 @@ static void sensitivity_init(void *data) } static const struct device_ops sensitivity_device_ops = { - .name = "sensitivity", + DECLARE_NAME_LEN("sensitivity"), .init = sensitivity_init, }; diff --git a/src/touchscreen/touchscreen.c b/src/touchscreen/touchscreen.c index 5d696c2..45caf74 100644 --- a/src/touchscreen/touchscreen.c +++ b/src/touchscreen/touchscreen.c @@ -133,7 +133,7 @@ static int touchscreen_dump(FILE *fp, int mode, void *dump_data) } static const struct device_ops touchscreen_device_ops = { - .name = "touchscreen", + DECLARE_NAME_LEN("touchscreen"), .probe = touchscreen_probe, .exit = touchscreen_exit, .start = touchscreen_start, diff --git a/src/tzip/tzip.c b/src/tzip/tzip.c index f66aa76..3887537 100644 --- a/src/tzip/tzip.c +++ b/src/tzip/tzip.c @@ -1086,7 +1086,7 @@ static void tzip_resume(void) } static const struct device_ops tzip_device_ops = { - .name = "tzip", + DECLARE_NAME_LEN("tzip"), .init = tzip_init, .exit = tzip_exit, .suspend = tzip_suspend, diff --git a/src/usb-host-test/usb-host-test.c b/src/usb-host-test/usb-host-test.c index 5ba6d91..45b2797 100644 --- a/src/usb-host-test/usb-host-test.c +++ b/src/usb-host-test/usb-host-test.c @@ -597,7 +597,7 @@ static int usb_host_test_status(void) } static const struct device_ops usb_host_test_device_ops = { - .name = "usb-host-test", + DECLARE_NAME_LEN("usb-host-test"), .init = usb_host_test_init, .exit = usb_host_test_exit, .start = usb_host_test_start, -- 2.7.4 From d510890a2268fbe18e74f1eccfc5c199fb93ef6f Mon Sep 17 00:00:00 2001 From: lokilee73 Date: Fri, 30 Aug 2019 10:56:27 +0900 Subject: [PATCH 15/16] Add Dimming=no to disable dim in wearable target Change-Id: Ia848a6c20008fcd681785d808ef70bd8015ff552 Signed-off-by: lokilee73 --- conf/wearable-display.conf | 1 + 1 file changed, 1 insertion(+) diff --git a/conf/wearable-display.conf b/conf/wearable-display.conf index 3c190ae..f17b4ca 100644 --- a/conf/wearable-display.conf +++ b/conf/wearable-display.conf @@ -40,3 +40,4 @@ ControlDisplay=no PowerKeyDoublePressSupport=yes AccelSensorOn=no ContinuousSampling=no +Dimming=no \ No newline at end of file -- 2.7.4 From 2eb281abdf2a2da87fd9735e70dc8e6b483f67fb Mon Sep 17 00:00:00 2001 From: Baumann Date: Fri, 30 Aug 2019 15:50:30 +0200 Subject: [PATCH 16/16] Restrict signal policy Change-Id: I2864bd37fe36e58207d04ffd23ea1de22fd59556 Signed-off-by: Hyotaek Shim --- conf/org.tizen.system.deviced.conf | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/conf/org.tizen.system.deviced.conf b/conf/org.tizen.system.deviced.conf index 53535a8..0fa137a 100644 --- a/conf/org.tizen.system.deviced.conf +++ b/conf/org.tizen.system.deviced.conf @@ -4,6 +4,15 @@ + + + @@ -61,5 +70,15 @@ + + + + -- 2.7.4