From a9ba41e975ca64c8b8ef4ee521114bc5ed1e5e06 Mon Sep 17 00:00:00 2001 From: HyungKyu Song Date: Sat, 16 Feb 2013 01:00:30 +0900 Subject: [PATCH] Tizen 2.0 Release --- 92-devman.rules.in | 4 + CMakeLists.txt | 44 ++ device-manager-plugin-mfld.manifest | 5 + include/devman_define_node_path.h | 83 ++ include/devman_plugin_intf.h | 168 ++++ include/vibrator.h | 23 + packaging/device-manager-plugin-mfld.spec | 48 ++ src/device_manager_io.c | 179 +++++ src/device_manager_plugin_mfld.c | 1190 +++++++++++++++++++++++++++++ src/test/slp_plugin_test.c | 333 ++++++++ src/vibrator.c | 770 +++++++++++++++++++ vibrator.ini | 49 ++ 12 files changed, 2896 insertions(+) create mode 100644 92-devman.rules.in create mode 100644 CMakeLists.txt create mode 100644 device-manager-plugin-mfld.manifest create mode 100644 include/devman_define_node_path.h create mode 100644 include/devman_plugin_intf.h create mode 100644 include/vibrator.h create mode 100644 packaging/device-manager-plugin-mfld.spec create mode 100644 src/device_manager_io.c create mode 100644 src/device_manager_plugin_mfld.c create mode 100644 src/test/slp_plugin_test.c create mode 100644 src/vibrator.c create mode 100644 vibrator.ini diff --git a/92-devman.rules.in b/92-devman.rules.in new file mode 100644 index 0000000..5c3c777 --- /dev/null +++ b/92-devman.rules.in @@ -0,0 +1,4 @@ +#Jack +ACTION=="change" DEVPATH=="/devices/ipc/msic_battery/power_supply/msic_charger", ENV{CHARGERFLAG}=="Y", RUN+="/usr/bin/sys_event device_ta_chgdet" + +ACTION=="change" DEVPATH=="/devices/pci0000:00/0000:00:00.4/i2c-1/1-0036/power_supply/max170xx_battery", ENV{CHARGERFLAG}=="Y", RUN+="/usr/bin/sys_event device_ta_chgdet" diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..d125783 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,44 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(slp_devman_plugin C) + +SET(SRCS + src/device_manager_io.c + src/vibrator.c + src/device_manager_plugin_mfld.c) + +IF("${CMAKE_BUILD_TYPE}" STREQUAL "") + SET(CMAKE_BUILD_TYPE "Release") +ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "") +MESSAGE("Build type: ${CMAKE_BUILD_TYPE}") + +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include) + +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_C_FLAGS_RELEASE "-O2") + +INCLUDE(FindPkgConfig) +pkg_check_modules(pkgs REQUIRED devman_plugin alsa dlog iniparser svi) + +FOREACH(flag ${pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") + +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS}) + +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) + +SET(UDEV_RULES_PATH share/devman) +SET(UDEV_RULES 92-devman.rules) +CONFIGURE_FILE(${UDEV_RULES}.in ${UDEV_RULES} @ONLY) + +ADD_EXECUTABLE(slp_plugin_test src/test/slp_plugin_test.c) +TARGET_LINK_LIBRARIES(slp_plugin_test ${pkgs_LDFLAGS} ${PROJECT_NAME}) + +INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${UDEV_RULES} DESTINATION ${UDEV_RULES_PATH}) +INSTALL(TARGETS slp_plugin_test DESTINATION bin) +INSTALL(FILES vibrator.ini DESTINATION etc) +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION lib COMPONENT RuntimeLibraries) diff --git a/device-manager-plugin-mfld.manifest b/device-manager-plugin-mfld.manifest new file mode 100644 index 0000000..af9b883 --- /dev/null +++ b/device-manager-plugin-mfld.manifest @@ -0,0 +1,5 @@ + + + + + diff --git a/include/devman_define_node_path.h b/include/devman_define_node_path.h new file mode 100644 index 0000000..04e8e9a --- /dev/null +++ b/include/devman_define_node_path.h @@ -0,0 +1,83 @@ +/* +* Copyright (c) 2012 Intel 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 __DEVMAN_DEFINE_NODE_PATH_H +#define __DEVMAN_DEFINE_NODE_PATH_H + +#define BACKLIGHT_PATH "/sys/class/backlight/" +#define BACKLIGHT_MAX_BRIGHTNESS_PATH BACKLIGHT_PATH"%s/max_brightness" +#define BACKLIGHT_MIN_BRIGHTNESS_PATH BACKLIGHT_PATH"%s/min_brightness" +#define BACKLIGHT_BRIGHTNESS_PATH BACKLIGHT_PATH"%s/brightness" +#define BACKLIGHT_DIMMING_PATH BACKLIGHT_PATH"%s/dimming" +#define LCD_PATH "/sys/class/lcd/" +#define LCD_ACL_CONTROL_PATH LCD_PATH"%s/acl_control" +#define LCD_POWER_PATH LCD_PATH"%s/lcd_power" +#define IMAGE_ENHANCE_PATH "/sys/class/extension/mdnie/%s" +#define IMAGE_ENHANCE_PATH_INFO "/sys/class/extension/mdnie" + +#define DISPLAY_FRAME_RATE_PATH "/sys/devices/platform/mfld4412-display/devfreq/mfld4412-display/max_freq" + +#define UART_PATH "/sys/devices/virtual/sec/switch/uart_sel" +#define USB_PATH "/sys/devices/virtual/sec/switch/usb_sel" +#define UART_PATH_TRATS "/sys/devices/platform/uart-select/path" +#define USB_PATH_TRATS "/sys/devices/platform/usb-select/path" + +#define HAPTIC_MOTOR_LEVEL_PATH "/sys/class/haptic/motor/level" +#define HAPTIC_MOTOR_LEVEL_MAX_PATH "/sys/class/haptic/motor/level_max" +#define HAPTIC_MOTOR_ENABLE_PATH "/sys/class/haptic/motor/enable" +#define HAPTIC_MOTOR_ONESHOT_PATH "/sys/class/haptic/motor/oneshot" + +#define BATTERY_CAPACITY_PATH "/sys/class/power_supply/max170xx_battery/capacity" +#define BATTERY_CAPACITY_RAW_PATH "/sys/class/power_supply/max170xx_battery/capacity_raw" +#define BATTERY_CHARGE_FULL_PATH "/sys/class/power_supply/max170xx_battery/charge_full" +#define BATTERY_CHARGE_NOW_PATH "/sys/class/power_supply/max170xx_battery/charge_now" +#define BATTERY_CHARGE_STATUS_PATH "/sys/class/power_supply/max170xx_battery/status" +#define BATTERY_PRESENT_PATH "/sys/class/power_supply/max170xx_battery/present" +#define BATTERY_HEALTH_PATH "/sys/class/power_supply/max170xx_battery/health" + +#define JACK_CHARGER_ONLINE_PATH "/sys/class/power_supply/msic_charger/online" +#define JACK_EARJACK_ONLINE_PATH "/sys/devices/platform/jack/earjack_online" +#define JACK_EARKEY_ONLINE_PATH "/sys/devices/platform/jack/earkey_online" +#define JACK_HDMI_ONLINE_PATH "/sys/devices/platform/jack/hdmi_online" +#define JACK_USB_ONLINE_PATH "/sys/devices/platform/jack/usb_online" +#define JACK_CRADLE_ONLINE_PATH "/sys/devices/platform/jack/cradle_online" +#define JACK_TVOUT_ONLINE_PATH "/sys/devices/platform/jack/tvout_online" +#define JACK_KEYBOARD_ONLINE_PATH "/sys/devices/platform/jack/keyboard_online" + +#define LEDS_TORCH_MAX_BRIGHTNESS_PATH "/sys/class/camera/flash/max_brightness" +#define LEDS_TORCH_BRIGHTNESS_PATH "/sys/class/camera/flash/rear_flash" + +#define POWER_STATE_PATH "/sys/power/state" +#define POWER_WAKEUP_COUNT_PATH "/sys/power/wakeup_count" + +#define MEMNOTIFY_NODE "/dev/memnotify" +#define MEMNOTIFY_VICTIM_TASK_PATH "/sys/class/memnotify/victim_task" +#define MEMNOTIFY_THRESHOLD_LV1_PATH "/sys/class/memnotify/threshold_lv1" +#define MEMNOTIFY_THRESHOLD_LV2_PATH "/sys/class/memnotify/threshold_lv2" + +#define TOUCH_EVENT_NODE "/dev/event2" + +#define PROCESS_MONITOR_NODE "/dev/pmon" +#define PROCESS_MONITOR_MP_PNP_PATH "/sys/class/pmon/mp_pnp" +#define PROCESS_MONITOR_MP_VIP_PATH "/sys/class/pmon/mp_vip" + +#define CPUFREQ_CPUINFO_MAX_FREQ_PATH "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq" +#define CPUFREQ_CPUINFO_MIN_FREQ_PATH "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_min_freq" +#define CPUFREQ_SCALING_MAX_FREQ_PATH "/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq" +#define CPUFREQ_SCALING_MIN_FREQ_PATH "/sys/devices/system/cpu/cpu0/cpufreq/scaling_min_freq" + +#endif /* __DEVMAN_DEFINE_NODE_PATH_H */ diff --git a/include/devman_plugin_intf.h b/include/devman_plugin_intf.h new file mode 100644 index 0000000..2770f18 --- /dev/null +++ b/include/devman_plugin_intf.h @@ -0,0 +1,168 @@ +/* +* Copyright (c) 2012 Intel 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 __DEVMAN_PLUGIN_INTF_H__ +#define __DEVMAN_PLUGIN_INTF_H__ + +enum { + STATUS_OFFLINE = 0, + STATUS_ONLINE, +}; + +enum { + STATUS_OFF = 0, + STATUS_ON, +}; + +enum { + PATH_CP = 0, + PATH_AP, +}; + +enum { + BATTERY_NOT_FULLY_CHARGED = 0, + BATTERY_FULLY_CHARGED, +}; + +enum { + BATTERY_UNKNOWN = 0, + BATTERY_GOOD, + BATTERY_OVERHEAT, + BATTERY_DEAD, + BATTERY_OVERVOLTAGE, + BATTERY_UNSPECIFIED, + BATTERY_COLD, + BATTERY_HEALTH_MAX, +}; + +enum { + POWER_STATE_SUSPEND = 0, + POWER_STATE_PRE_SUSPEND, + POWER_STATE_POST_RESUME, +}; + +enum { + LUX_DECREMENT, + LUX_NOCHANGE, + LUX_INCREMENT, +}; + +typedef struct { + int (*OEM_sys_get_display_count) (int *value); + + int (*OEM_sys_get_backlight_min_brightness) (int index, int *value); + int (*OEM_sys_get_backlight_max_brightness) (int index, int *value); + int (*OEM_sys_get_backlight_brightness) (int index, int *value, int power_saving); + int (*OEM_sys_set_backlight_brightness) (int index, int value, int power_saving); + + int (*OEM_sys_set_backlight_dimming) (int index, int value); + + int (*OEM_sys_get_backlight_acl_control) (int index, int *value); + int (*OEM_sys_set_backlight_acl_control) (int index, int value); + + int (*OEM_sys_get_lcd_power) (int index, int *value); + int (*OEM_sys_set_lcd_power) (int index, int value); + + int (*OEM_sys_get_image_enhance_mode) (int *value); + int (*OEM_sys_set_image_enhance_mode) (int value); + int (*OEM_sys_get_image_enhance_scenario) (int *value); + int (*OEM_sys_set_image_enhance_scenario) (int value); + int (*OEM_sys_get_image_enhance_tone) (int *value); + int (*OEM_sys_set_image_enhance_tone) (int value); + int (*OEM_sys_get_image_enhance_outdoor) (int *value); + int (*OEM_sys_set_image_enhance_outdoor) (int value); + + int (*OEM_sys_get_image_enhance_tune) (int *value); + int (*OEM_sys_set_image_enhance_tune) (int value); + + int (*OEM_sys_image_enhance_info) (int *value); + + int (*OEM_sys_set_display_frame_rate) (int value); + + int (*OEM_sys_get_uart_path) (int *value); + int (*OEM_sys_set_uart_path) (int value); + + int (*OEM_sys_get_usb_path) (int *value); + int (*OEM_sys_set_usb_path) (int value); + + int (*OEM_sys_get_haptic_motor_level_max) (int *value); + int (*OEM_sys_get_haptic_motor_level) (int *value); + int (*OEM_sys_set_haptic_motor_level) (int value); + int (*OEM_sys_set_haptic_motor_enable) (int value); + int (*OEM_sys_set_haptic_motor_oneshot) (int value); + + int (*OEM_sys_get_haptic_vibetones_level_max) (int *value); + int (*OEM_sys_get_haptic_vibetones_level) (int *value); + int (*OEM_sys_set_haptic_vibetones_level) (int value); + int (*OEM_sys_set_haptic_vibetones_enable) (int value); + int (*OEM_sys_set_haptic_vibetones_oneshot) (int value); + + int (*OEM_sys_get_battery_capacity) (int *value); + int (*OEM_sys_get_battery_capacity_raw) (int *value); + int (*OEM_sys_get_battery_charge_full) (int *value); + int (*OEM_sys_get_battery_charge_now) (int *value); + int (*OEM_sys_get_battery_present) (int *value); + int (*OEM_sys_get_battery_health) (int *value); + int (*OEM_sys_get_battery_polling_required) (int *value); + int (*OEM_sys_get_battery_support_insuspend_charging) (int *value); + + int (*OEM_sys_get_jack_charger_online) (int *value); + int (*OEM_sys_get_jack_earjack_online) (int *value); + int (*OEM_sys_get_jack_earkey_online) (int *value); + int (*OEM_sys_get_jack_hdmi_online) (int *value); + int (*OEM_sys_get_jack_usb_online) (int *value); + int (*OEM_sys_get_jack_cradle_online) (int *value); + int (*OEM_sys_get_jack_tvout_online) (int *value); + int (*OEM_sys_get_jack_keyboard_online) (int *value); + + int (*OEM_sys_get_hdmi_support) (int *value); + + int (*OEM_sys_get_leds_torch_max_brightness) (int *value); + int (*OEM_sys_get_leds_torch_brightness) (int *value); + int (*OEM_sys_set_leds_torch_brightness) (int value); + + /* TODO: Change args type */ + int (*OEM_sys_set_power_state) (int value); + + /* TODO: Should determine enum values of wakeup_count nodes */ + int (*OEM_sys_get_power_wakeup_count) (int *value); + int (*OEM_sys_set_power_wakeup_count) (int value); + + int (*OEM_sys_get_memnotify_node) (char *node); + int (*OEM_sys_get_memnotify_victim_task) (int *value); + int (*OEM_sys_set_memnotify_threshold_lv1) (int value); + int (*OEM_sys_set_memnotify_threshold_lv2) (int value); + + int (*OEM_sys_get_process_monitor_node) (char *node); + int (*OEM_sys_set_process_monitor_mp_pnp) (int value); + int (*OEM_sys_set_process_monitor_mp_vip) (int value); + + int (*OEM_sys_get_cpufreq_cpuinfo_max_freq) (int *value); + int (*OEM_sys_get_cpufreq_cpuinfo_min_freq) (int *value); + int (*OEM_sys_get_cpufreq_scaling_max_freq) (int *value); + int (*OEM_sys_set_cpufreq_scaling_max_freq) (int value); + int (*OEM_sys_get_cpufreq_scaling_min_freq) (int *value); + int (*OEM_sys_set_cpufreq_scaling_min_freq) (int value); + + int (*OEM_sys_get_backlight_brightness_by_lux) (int lux, int status); + +} OEM_sys_devman_plugin_interface; + +const OEM_sys_devman_plugin_interface *OEM_sys_get_devman_plugin_interface(); + +#endif /* __DEVMAN_PLUGIN_INTF_H__ */ diff --git a/include/vibrator.h b/include/vibrator.h new file mode 100644 index 0000000..349d642 --- /dev/null +++ b/include/vibrator.h @@ -0,0 +1,23 @@ +#ifndef __VIBRATOR_H__ +#define __VIBRATOR_H__ + +typedef enum { + VIBRA_BOOST_TIME = 0, + VIBRA_DUTY_CYCLE, + VIBRA_BRAKE, + VIBRA_DIRECTION, + VIBRA_ON_TIME, + VIBRA_OFF_TIME = 5, + VIBRA_CYCLE_COUNT, + VIBRA_ENABLE_MUX, + VIBRA_START, + VIBRA_GET_LEVEL_MAX, + VIBRA_GET_NUM_CYCLECOUNT = 10, + VIBRA_GET_NUM_ON_TIME, + VIBRA_GET_LITERAL_VALUE_CYCLECOUNT, + VIBRA_GET_LITERAL_VALUE_ON_TIME, +}vib_ctl_type_e; + +int vib_hw_ctrl(int, int, int, int *, char **); + +#endif /* __VIBRATOR_H__ */ diff --git a/packaging/device-manager-plugin-mfld.spec b/packaging/device-manager-plugin-mfld.spec new file mode 100644 index 0000000..2a1b7d4 --- /dev/null +++ b/packaging/device-manager-plugin-mfld.spec @@ -0,0 +1,48 @@ +#sbs-git:slp/pkgs/d/device-manager-plugin-mfld device-manager-plugin-mfld 0.0.1 5bf2e95e0bb15c43ff928f7375e1978b0accb0f8 +Name: device-manager-plugin-mfld-blackbay +Summary: Device manager plugin mfld +Version: 0.0.26 +Release: 0 +Group: System/Adaptation +License: Apache v2.0 +Source0: %{name}-%{version}.tar.gz +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig +BuildRequires: cmake +BuildRequires: pkgconfig(devman) +BuildRequires: pkgconfig(devman_plugin) +BuildRequires: pkgconfig(alsa) +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(iniparser) +BuildRequires: pkgconfig(svi) + +%description +Device manager plugin mfld + + +%prep +%setup -q + +%build +cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +%make_install + + +%post +/sbin/ldconfig +ln -sf /usr/share/devman/92-devman.rules /etc/udev/rules.d/ + +%postun +/sbin/ldconfig + +%files +%manifest device-manager-plugin-mfld.manifest +/usr/lib/libslp_devman_plugin.so +/usr/share/devman/92-devman.rules +/usr/bin/slp_plugin_test +%config(noreplace) /usr/etc/vibrator.ini diff --git a/src/device_manager_io.c b/src/device_manager_io.c new file mode 100644 index 0000000..874dc1f --- /dev/null +++ b/src/device_manager_io.c @@ -0,0 +1,179 @@ +/* +* Copyright (c) 2012 Intel 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 +#include +#include +#include +#include +#include + +#define EXPORT_API __attribute__((visibility("default"))) + +#define BUFF_MAX 255 +#define SUCCESS 0 +#define FAIL 1 + +int sys_check_node(char *path) +{ + int fd = -1; + + fd = open(path, O_RDONLY); + + if (fd == -1) + return -1; + + close(fd); + return 0; +} + +int sys_get_node(char *path, char *node) +{ + if (0 >= snprintf(node, strlen(path) + 1, "%s", path)) + return -1; + + return 0; +} + +int sys_get_int_wo_convert(char *path, int *value) +{ + int fd = -1; + + fd = open(path, O_RDONLY); + if (fd == -1) { + return -1; + } + + if (0 > read(fd, value, sizeof(int))) { + close(fd); + return -1; + } + close (fd); + + return 0; +} + +int sys_set_int_wo_convert(char *path, int value) +{ + int fd = -1; + + fd = open(path, O_WRONLY); + if (fd == -1) { + return -1; + } + + if (0 > write(fd, &value, sizeof(int))) { + close(fd); + return -1; + } + close(fd); + + return 0; +} + +static int sys_read_buf(char *file, char *buf) +{ + int fd; + int r; + + fd = open(file, O_RDONLY); + if (fd == -1) { + return -ENOENT; + } + + r = read(fd, buf, BUFF_MAX-1); + if ((r >= 0) && (r < BUFF_MAX)) + buf[r] = '\0'; + else { + return -EIO; + } + + close(fd); + + return 0; +} + +static int sys_write_buf(char *file, char *buf) +{ + int fd; + int r; + + fd = open(file, O_WRONLY); + if (fd == -1) { + return -1; + } + + r = write(fd, buf, strlen(buf)); + close(fd); + if (r < 0) { + return -1; + } + + return 0; +} + +int sys_get_int(char *fname, int *val) +{ + char buf[BUFF_MAX]; + + if (sys_read_buf(fname, buf) == 0) { + *val = atoi(buf); + return 0; + } else { + *val = -1; + return -1; + } +} + +int sys_get_str(char *fname, char *str) +{ + char buf[BUFF_MAX] = {0}; + + if (sys_read_buf(fname, buf) == 0) + { + strncpy(str, buf, strlen(buf)); + return 0; + } + + return -1; +} + +int sys_set_int(char *fname, int val) +{ + char buf[BUFF_MAX]; + int r = -1; + snprintf(buf, sizeof(buf), "%d", val); + + if (sys_write_buf(fname, buf) == 0) + r = 0; + + return r; +} + +int sys_set_str(char *fname, char *val) +{ + int r = -1; + + if (val != NULL) { + if (sys_write_buf(fname, val) == 0) + r = 0; + } + + return r; +} diff --git a/src/device_manager_plugin_mfld.c b/src/device_manager_plugin_mfld.c new file mode 100644 index 0000000..f98d606 --- /dev/null +++ b/src/device_manager_plugin_mfld.c @@ -0,0 +1,1190 @@ +/* +* Copyright (c) 2012 Intel 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 +#include +#include +#include + +#include "devman_define_node_path.h" +#include "vibrator.h" + +#define EXPORT_API __attribute__((visibility("default"))) + +#define BUFF_MAX 255 +#define MAX_NAME 255 + +/* TODO: Add APIs has (char *) params */ + +#define GENERATE_ACCESSORS_INT_RW(_suffix, _item) \ +int OEM_sys_get_##_suffix(int *value) \ +{ \ + return sys_get_int(_item, value); \ +} \ + \ +int OEM_sys_set_##_suffix(int value) \ +{ \ + return sys_set_int(_item, value); \ +} + +#define GENERATE_ACCESSORS_INT_R(_suffix, _item) \ +int OEM_sys_get_##_suffix(int *value) \ +{ \ + return sys_get_int(_item, value); \ +} + +#define GENERATE_ACCESSORS_INT_W(_suffix, _item) \ +int OEM_sys_set_##_suffix(int value) \ +{ \ + return sys_set_int(_item, value); \ +} + +/* +GENERATE_ACCESSORS_INT_R(backlight_max_brightness, BACKLIGHT_MAX_BRIGHTNESS_PATH) +GENERATE_ACCESSORS_INT_RW(backlight_brightness, BACKLIGHT_BRIGHTNESS_PATH) +GENERATE_ACCESSORS_INT_RW(backlight_acl_control, LCD_ACL_CONTROL_PATH) +GENERATE_ACCESSORS_INT_RW(lcd_power, LCD_POWER_PATH) +*/ +#if defined(DEVMGR_LOG) +#define devmgr_log(fmt, args...) \ + do { \ + printf("%s:"fmt"\n", __func__, ##args); \ + }while(0); +#else +#define devmgr_log(fmt, args...) +#endif + +enum display_type +{ + DISP_MAIN = 0, + DISP_SUB, + DISP_MAX +}; + +enum lux_status { + decrement, + no_change, + increment, +}; + +struct display_info +{ + enum display_type etype; /* FIXME:!! Main LCD or Sub LCD node */ + char bl_name[MAX_NAME]; /* backlight name */ + char lcd_name[MAX_NAME]; /* lcd name */ +}; + +#define MAX_CANDELA_CRITERION 300 +#define PWR_SAVING_CANDELA_CRITERION 20 + +/* FIXME:!! change to global_ctx */ +__thread int lcd_index; +__thread int bl_index; +__thread struct display_info disp_info[DISP_MAX]; + +int OEM_sys_get_backlight_brightness_by_lux(unsigned int lux, enum lux_status status) +{ + static __thread int brightness = -1; + + if (status == no_change) { + if (brightness == -1) + status = increment; + else + return brightness; + } + if (status == decrement) { + switch (lux) { + case 10000 ... 0xffffffff: + brightness = 100; + break; + case 1000 ... 9999: + brightness = 80; + break; + case 75 ... 999: + brightness = 60; + break; + case 7 ... 74: + brightness = 40; + break; + case 0 ... 6: + brightness = 1; + break; + default: + return -1; + } + } else if (status == increment) { + switch (lux) { + case 15001 ... 0xffffffff: + brightness = 100; + break; + case 1501 ... 15000: + brightness = 80; + break; + case 151 ... 1500: + brightness = 60; + break; + case 16 ... 150: + brightness = 40; + break; + case 0 ... 15: + brightness = 1; + break; + default: + return -1; + } + } else + return -1; + + return brightness; +} + +static int OEM_sys_display_info(struct display_info *disp_info) +{ + struct dirent *dent; + DIR *dirp; + int i, index; + const char * bl_path = BACKLIGHT_PATH; + const char * lcd_path = LCD_PATH; + + /* Backlight */ + index = 0; + dirp = opendir(bl_path); + if (dirp) { + while(dent = readdir(dirp)) { + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + break; + } + + if (!strcmp(".", dent->d_name) || !strcmp("..", dent->d_name)) + continue; + else { + strcpy(disp_info[index].bl_name, dent->d_name); + index++; + } + } + closedir(dirp); + } + + for (i = 0; i < index; i++) + devmgr_log("bl_name[%s]", disp_info[i].bl_name); + + bl_index = index; + + /* LCD */ + index = 0; + dirp = opendir(lcd_path); + if (dirp) { + while(dent = readdir(dirp)) { + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + break; + } + + if (!strcmp(".", dent->d_name) || !strcmp("..", dent->d_name)) + continue; + else { + strcpy(disp_info[index].lcd_name, dent->d_name); + index++; + } + } + closedir(dirp); + } + + for (i = 0; i < index; i++) + devmgr_log("lcd_name[%s]", disp_info[i].lcd_name); + + lcd_index = index; +} + +int OEM_sys_get_display_count(int *value) +{ + int ret = -1; + + /* TODO: We should implement to find out current number of display */ + *value = (lcd_index == 0 ? bl_index : lcd_index) ; + ret = 0; + /* ********************* */ + + devmgr_log("value[%d]", *value); + + return ret; +} + +int OEM_sys_get_backlight_max_brightness(int index, int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_get_backlight_min_brightness(int index, int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, BACKLIGHT_MIN_BRIGHTNESS_PATH, disp_info[index].bl_name); + ret = sys_get_int(path, value); + + //FIXME: this is a workaround for TZSP-3141 before kernel exports min_brightness. + if(ret < 0){ + *value = 0; + ret = 0; + } + + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + + +int OEM_sys_get_backlight_brightness(int index, int *value, int power_saving) +{ + int ret = -1; + char path[MAX_NAME+1]; + int max_brightness; + int pwr_saving_offset; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]power_saving[%d]", path, *value, power_saving); + + if (power_saving){ + snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name); + ret = sys_get_int(path, &max_brightness); + if (ret) + { + devmgr_log("Can't read max_brightness node[%s]", path); + return ret; + } + pwr_saving_offset = (PWR_SAVING_CANDELA_CRITERION * max_brightness / MAX_CANDELA_CRITERION) + 0.5; + + if (*value > max_brightness - pwr_saving_offset) + *value = max_brightness; + else + *value = *value + pwr_saving_offset; + + devmgr_log("power_saving result[%d]", *value); + } + + return ret; +} + + +int OEM_sys_set_backlight_dimming(int index, int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + devmgr_log("index is %d, value is %d", index, value); + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, BACKLIGHT_DIMMING_PATH, disp_info[index].bl_name); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_set_backlight_brightness(int index, int value, int power_saving) +{ + int ret = -1; + char path[MAX_NAME+1]; + int max_brightness; + int pwr_saving_offset; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + devmgr_log("path[%s]value[%d]power_saving[%d]", path, value, power_saving); + + if (power_saving){ + snprintf(path, MAX_NAME, BACKLIGHT_MAX_BRIGHTNESS_PATH, disp_info[index].bl_name); + ret = sys_get_int(path, &max_brightness); + if (ret) + { + devmgr_log("Can't read max_brightness node[%s]", path); + return ret; + } + pwr_saving_offset = (PWR_SAVING_CANDELA_CRITERION * max_brightness / MAX_CANDELA_CRITERION) + 0.5; + + if (value < pwr_saving_offset) + value = 0; + else + value = value - pwr_saving_offset; + + devmgr_log("power_saving result[%d]", value); + } + + snprintf(path, MAX_NAME, BACKLIGHT_BRIGHTNESS_PATH, disp_info[index].bl_name); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_get_backlight_acl_control(int index, int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_backlight_acl_control(int index, int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, LCD_ACL_CONTROL_PATH, disp_info[index].lcd_name); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_get_lcd_power(int index, int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_lcd_power(int index, int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + if (index >= DISP_MAX) { + devmgr_log("supports %d display node", DISP_MAX); + return ret; + } + + snprintf(path, MAX_NAME, LCD_POWER_PATH, disp_info[index].lcd_name); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +/* image_enhance */ +/* mode - dynamic, standard, natural, movie */ +enum image_enhance_mode { + MODE_DYNAMIC = 0, + MODE_STANDARD, + MODE_NATURAL, + MODE_MOVIE, +}; + +/* scenario - ui, gallery, video, vtcall, camera, browser, negative, bypass */ +enum image_enhance_scenario { + SCENARIO_UI = 0, + SCENARIO_GALLERY, + SCENARIO_VIDEO, + SCENARIO_VTCALL, + SCENARIO_CAMERA, + SCENARIO_BROWSER, + SCENARIO_NEGATIVE, + SCENARIO_BYPASS, +}; + +/* tone - normal, warm, cold */ +enum image_enhance_tone { + TONE_NORMAL = 0, + TONE_WARM, + TONE_COLD, +}; + +/* tone browser - tone1, tone2, tone3 */ +enum image_enhance_tone_br { + TONE_1 = 0, + TONE_2, + TONE_3, +}; + +/* outdoor - off, on */ +enum image_enhance_outdoor { + OUTDOOR_OFF = 0, + OUTDOOR_ON, +}; + +/* index - mode, scenario, tone, outdoor, tune */ +enum image_enhance_index { + INDEX_MODE, + INDEX_SCENARIO, + INDEX_TONE, + INDEX_OUTDOOR, + INDEX_TUNE, + INDEX_MAX, +}; + +const char *image_enhance_str[INDEX_MAX] = { + "mode", + "scenario", + "tone", + "outdoor", + "tune", +}; + +struct image_enhance_info { + enum image_enhance_mode mode; + enum image_enhance_scenario scenario; + enum image_enhance_tone tone; + enum image_enhance_outdoor outdoor; +}; + +int OEM_sys_get_image_enhance_save(void *image_enhance) +{ + int ret = -1; + char path[MAX_NAME+1]; + struct image_enhance_info *image_enhance_save = (struct image_enhance_info *)image_enhance; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]); + ret = sys_get_int(path, &image_enhance_save->mode); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]); + ret = sys_get_int(path, &image_enhance_save->scenario); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]); + ret = sys_get_int(path, &image_enhance_save->tone); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]); + ret = sys_get_int(path, &image_enhance_save->outdoor); + devmgr_log("path[%s]mode[%d]scenario[%d]tone[%d]outdoor[%d]", path, image_enhance_save->mode, + image_enhance_save->scenario, image_enhance_save->tone, image_enhance_save->outdoor); + + return ret; +} + +int OEM_sys_set_image_enhance_restore(void *image_enhance) +{ + int ret = -1; + char path[MAX_NAME+1]; + struct image_enhance_info *image_enhance_restore = (struct image_enhance_info *)image_enhance; + + devmgr_log("path[%s]mode[%d]scenario[%d]tone[%d]outdoor[%d]", path, image_enhance_restore->mode, + image_enhance_restore->scenario, image_enhance_restore->tone, image_enhance_restore->outdoor); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]); + ret = sys_set_int(path, image_enhance_restore->mode); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]); + ret = sys_set_int(path, image_enhance_restore->scenario); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]); + ret = sys_set_int(path, image_enhance_restore->tone); + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]); + ret = sys_set_int(path, image_enhance_restore->outdoor); + + return ret; +} + +int OEM_sys_get_image_enhance_mode(int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_image_enhance_mode(int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_MODE]); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_get_image_enhance_scenario(int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_image_enhance_scenario(int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_SCENARIO]); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_get_image_enhance_tone(int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_image_enhance_tone(int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TONE]); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_get_image_enhance_outdoor(int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_image_enhance_outdoor(int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_OUTDOOR]); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_get_image_enhance_tune(int *value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TUNE]); + ret = sys_get_int(path, value); + devmgr_log("path[%s]value[%d]", path, *value); + + return ret; +} + +int OEM_sys_set_image_enhance_tune(int value) +{ + int ret = -1; + char path[MAX_NAME+1]; + + snprintf(path, MAX_NAME, IMAGE_ENHANCE_PATH, image_enhance_str[INDEX_TUNE]); + devmgr_log("path[%s]value[%d]", path, value); + ret = sys_set_int(path, value); + + return ret; +} + +int OEM_sys_image_enhance_info(int *value) +{ + DIR *dir_info; + struct dirent *dir_entry; + int ret = -1; + const char * image_enhance_path_info = IMAGE_ENHANCE_PATH_INFO; + + dir_info = opendir(image_enhance_path_info); + + if (NULL != dir_info) { + *value = 1; + ret = 0; + } else { + *value = 0; + ret = -ENOENT; + } + + closedir(dir_info); + return ret; +} + +int OEM_sys_set_display_frame_rate(int value) +{ + if(value){ + devmgr_log("Display frame rate limited to 40Hz"); + return sys_set_str(DISPLAY_FRAME_RATE_PATH, "40"); + }else{ + devmgr_log("Display frame rate change 40Hz and 60Hz"); + return sys_set_str(DISPLAY_FRAME_RATE_PATH, "60"); + } + + return -1; +} + +int OEM_sys_set_haptic_motor_oneshot(int value) +{ + int ret; + + // workaround: duration==50 doesn't vibrate in PR3 hardware + if( 50 == value) value = 100; + + //assemble all possible times (Vibra1 On Time * Vibra1 Cycle Count) + ret = find_suit_value_and_set(value); + if(ret < 0) { + devmgr_log("set oneshot faild"); + return ret; + } + + // workaround: toggle vibration on org.tizen.settings->sound doesn't work + // settings applicaton will do something like below, while HAPTIC_PROP_ENABLE is never been set to 1 then. + // haptic_stop_all_effects-> + // haptic_internal_stop_effect-> + // device_set_property(DEVTYPE_HAPTIC, HAPTIC_PROP_ENABLE, 0); + //OEM_sys_set_haptic_vibetones_enable(1); + +#if 0 + //use settimer + ret = settimer_and_vibrate(value); + if(ret < 0) { + devmgr_log("set oneshot faild"); + return ret; + } +#endif + + return 0; +} + +int OEM_sys_set_haptic_motor_level(int value) +{ + int input_value = 0; + + devmgr_log("input vibration level=%d", value); + switch(value) { + case 0 ... 20: + input_value = 20; + break; + case 21 ... 40: + input_value = 40; + break; + case 41 ... 60: + input_value = 60; + break; + case 61 ... 80: + input_value = 80; + break; + case 81 ... 100: + input_value = 100; + break; + default: + devmgr_log("input vibration level=%d err", value); + return -1; + + } + return vib_hw_ctrl(VIBRA_DUTY_CYCLE, 1, input_value, NULL, NULL); +} + +int OEM_sys_get_haptic_motor_level(int *value) +{ + return vib_hw_ctrl(VIBRA_DUTY_CYCLE, 0, 0, value, NULL); +} + +int OEM_sys_set_haptic_motor_enable(int value) +{ + int vib_num_ontime, vib_num_cycle_count; + + if(value == 1) { + if(vib_hw_ctrl(VIBRA_GET_NUM_ON_TIME, 0, 0, &vib_num_ontime, NULL)) { + devmgr_log("get VIBRA_GET_NUM_ON_TIME err"); + return -1; + } + + if(vib_hw_ctrl(VIBRA_ON_TIME, 1, vib_num_ontime - 1 , NULL, NULL)) { + devmgr_log("set VIBRA_ON_TIME err"); + return -1; + } + + if(vib_hw_ctrl(VIBRA_GET_NUM_CYCLECOUNT, 0, 0, &vib_num_cycle_count, NULL)) { + devmgr_log("get VIBRA_GET_NUM_CYCLECOUNT err"); + return -1; + } + + if(vib_hw_ctrl(VIBRA_CYCLE_COUNT, 1, vib_num_cycle_count - 1, NULL, NULL)) { + devmgr_log("set VIBRA_CYCLE_COUNT err"); + return -1; + } + } + + if(vib_hw_ctrl(VIBRA_START, 1, value, NULL, NULL)) { + devmgr_log("set VIBRA_START err"); + return -1; + } + + return 0; +} + +int OEM_sys_get_haptic_motor_level_max(int *value) +{ + return vib_hw_ctrl(VIBRA_GET_LEVEL_MAX, 0, 0, value, NULL); +} + +GENERATE_ACCESSORS_INT_R(battery_capacity, BATTERY_CAPACITY_PATH) +/* +GENERATE_ACCESSORS_INT_R(battery_charge_full, BATTERY_CHARGE_FULL_PATH) +GENERATE_ACCESSORS_INT_R(battery_charge_now, BATTERY_CHARGE_NOW_PATH) +*/ +GENERATE_ACCESSORS_INT_R(battery_present, BATTERY_PRESENT_PATH) + +enum battery_status_type +{ + BATTERY_STATUS_FULL = 0, + BATTERY_STATUS_CHARGING, + BATTERY_STATUS_DISCHARGING, + BATTERY_STATUS_MAX, +}; + +static char *status_text[] = { + "Full", "Charging", "Discharging" +}; + +int OEM_sys_get_battery_charge_full(int *value) +{ + char buf[BUFF_MAX] = {0}; + int ret = -1; + + ret = sys_get_str(BATTERY_CHARGE_STATUS_PATH, buf); + + if(0 == ret){ + if(0 == strncmp(buf, status_text[BATTERY_STATUS_FULL], strlen(status_text[BATTERY_STATUS_FULL]))){ + *value = 1; + }else{ + *value = 0; + } + + ret = 0; + } + + return ret; +} + +int OEM_sys_get_battery_charge_now(int *value) +{ + char buf[BUFF_MAX] = {0}; + int ret = -1; + + ret = sys_get_str(BATTERY_CHARGE_STATUS_PATH, buf); + + if(0 == ret){ + if(0 == strncmp(buf, status_text[BATTERY_STATUS_CHARGING], strlen(status_text[BATTERY_STATUS_CHARGING]))){ + *value = 1; + }else{ + *value = 0; + } + + ret = 0; + } + + return ret; +} + +int OEM_sys_get_battery_capacity_raw(int *value) +{ + int ret; + + ret = sys_get_int(BATTERY_CAPACITY_RAW_PATH, value); + if (ret == -1) { + return -ENODEV; + } + + return ret; +} + +static char *health_text[] = { + "Unknown", "Good", "Overheat", "Dead", "Over voltage", + "Unspecified failure", "Cold", +}; + +int OEM_sys_get_battery_health(int *value) +{ + char buf[BUFF_MAX] = {0}; + int ret = 0; + int i = 0; + + ret = sys_get_str(BATTERY_HEALTH_PATH, buf); + if (ret == -1) + return -1; + + for (i = 0; i < BATTERY_HEALTH_MAX; i++) { + if (strncmp(buf, health_text[i], strlen(health_text[i])) == 0) { + *value = i; + return 0; + } + } + + return -1; +} + +int OEM_sys_get_battery_polling_required(int *value) +{ + *value = 0; + + return 0; +} + +int OEM_sys_get_battery_support_insuspend_charging(int *value) +{ + *value = 1; + + return 0; +} + +static char uart_node_path[MAX_NAME]; +static char usb_node_path[MAX_NAME]; + +/* find uart/usb node path */ +static int OEM_sys_muic_node_path_info() +{ + int err = -1; + + err = sys_check_node(UART_PATH); + if (!err) + sys_get_node(UART_PATH, uart_node_path); + else { + err = sys_check_node(UART_PATH_TRATS); + if (err) { + devmgr_log("uart path node not found"); + return -1; + } + sys_get_node(UART_PATH_TRATS, uart_node_path); + } + + err = sys_check_node(USB_PATH); + if (!err) + sys_get_node(USB_PATH, usb_node_path); + else { + err = sys_check_node(USB_PATH_TRATS); + if (err) { + devmgr_log("usb path node not found"); + return -1; + } + sys_get_node(USB_PATH_TRATS, usb_node_path); + } + return 0; +} + +int OEM_sys_get_uart_path(int *value) +{ + char buf[BUFF_MAX] = {0}; + int ret = 0; + + ret = sys_get_str(uart_node_path, buf); + if (ret == -1) + return -1; + + if (strncmp(buf, "CP", 2) == 0) { + *value = PATH_CP; + return 0; + } else if (strncmp(buf, "AP", 2) == 0) { + *value = PATH_AP; + return 0; + } + + return -1; +} + +int OEM_sys_set_uart_path(int value) +{ + switch (value) { + case PATH_CP: + return sys_set_str(uart_node_path, "CP"); + case PATH_AP: + return sys_set_str(uart_node_path, "AP"); + } + + return -1; +} + + +int OEM_sys_get_usb_path(int *value) +{ + char buf[BUFF_MAX] = {0}; + int ret = 0; + + ret = sys_get_str(usb_node_path, buf); + if (ret == -1) + return -1; + + if (strncmp(buf, "PDA", 3) == 0) { + *value = PATH_AP; + return 0; + } else if (strncmp(buf, "MODEM", 5) == 0) { + *value = PATH_CP; + return 0; + } + + return -1; +} + +int OEM_sys_set_usb_path(int value) +{ + switch (value) { + case PATH_CP: + return sys_set_str(usb_node_path, "MODEM"); + case PATH_AP: + return sys_set_str(usb_node_path, "PDA"); + } + + return -1; +} + +GENERATE_ACCESSORS_INT_R(jack_charger_online, JACK_CHARGER_ONLINE_PATH) +GENERATE_ACCESSORS_INT_R(jack_earjack_online, JACK_EARJACK_ONLINE_PATH) +GENERATE_ACCESSORS_INT_R(jack_earkey_online, JACK_EARKEY_ONLINE_PATH) +GENERATE_ACCESSORS_INT_R(jack_hdmi_online, JACK_HDMI_ONLINE_PATH) +GENERATE_ACCESSORS_INT_R(jack_usb_online, JACK_USB_ONLINE_PATH) +GENERATE_ACCESSORS_INT_R(jack_cradle_online, JACK_CRADLE_ONLINE_PATH) +GENERATE_ACCESSORS_INT_R(jack_tvout_online, JACK_TVOUT_ONLINE_PATH) + +int OEM_sys_get_jack_keyboard_online(int *value) +{ + /* Currently, We don't provide SLP Based platform with keyboard I/F */ + int ret = -1; + /*return sys_get_int(JACK_KEYBOARD_ONLINE_PATH, value);*/ + return ret; +} + +int OEM_sys_get_hdmi_support(int *value) +{ + *value = 1; + + return 0; +} + +GENERATE_ACCESSORS_INT_R(leds_torch_max_brightness, LEDS_TORCH_MAX_BRIGHTNESS_PATH) +GENERATE_ACCESSORS_INT_RW(leds_torch_brightness, LEDS_TORCH_BRIGHTNESS_PATH) + +int OEM_sys_set_power_state(int value) +{ + switch (value) { + case POWER_STATE_SUSPEND: + return sys_set_str(POWER_STATE_PATH, "mem"); + case POWER_STATE_PRE_SUSPEND: + return sys_set_str(POWER_STATE_PATH, "pre_suspend"); + case POWER_STATE_POST_RESUME: + return sys_set_str(POWER_STATE_PATH, "post_resume"); + } + + return -1; +} + +GENERATE_ACCESSORS_INT_RW(power_wakeup_count, POWER_WAKEUP_COUNT_PATH) + +GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv1, MEMNOTIFY_THRESHOLD_LV1_PATH) +GENERATE_ACCESSORS_INT_W(memnotify_threshold_lv2, MEMNOTIFY_THRESHOLD_LV2_PATH) + +GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_max_freq, CPUFREQ_CPUINFO_MAX_FREQ_PATH) +GENERATE_ACCESSORS_INT_R(cpufreq_cpuinfo_min_freq, CPUFREQ_CPUINFO_MIN_FREQ_PATH) +GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_max_freq, CPUFREQ_SCALING_MAX_FREQ_PATH) +GENERATE_ACCESSORS_INT_RW(cpufreq_scaling_min_freq, CPUFREQ_SCALING_MIN_FREQ_PATH) + +#define GENERATE_ACCESSORS_INT_R_NO_CONVERT(_suffix, _item) \ +int OEM_sys_get_##_suffix(int *value) \ +{ \ + return sys_get_int_wo_convert(_item, value); \ +} + +#define GENERATE_ACCESSORS_INT_W_NO_CONVERT(_suffix, _item) \ +int OEM_sys_set_##_suffix(int value) \ +{ \ + return sys_set_int_wo_convert(_item, value); \ +} + +GENERATE_ACCESSORS_INT_R_NO_CONVERT(memnotify_victim_task, MEMNOTIFY_VICTIM_TASK_PATH) +GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_pnp, PROCESS_MONITOR_MP_PNP_PATH) +GENERATE_ACCESSORS_INT_W_NO_CONVERT(process_monitor_mp_vip, PROCESS_MONITOR_MP_VIP_PATH) + +#define GENERATE_ACCESSORS_GET_NODE_PATH(_suffix, _item) \ +int OEM_sys_get_##_suffix(char *node) \ +{ \ + return sys_get_node(_item, node); \ +} + +GENERATE_ACCESSORS_GET_NODE_PATH(touch_event, TOUCH_EVENT_NODE) +GENERATE_ACCESSORS_GET_NODE_PATH(memnotify_node, MEMNOTIFY_NODE) +GENERATE_ACCESSORS_GET_NODE_PATH(process_monitor_node, PROCESS_MONITOR_NODE) + +static OEM_sys_devman_plugin_interface devman_plugin_interface_mfld; + +EXPORT_API const OEM_sys_devman_plugin_interface *OEM_sys_get_devman_plugin_interface() +{ + /* Light interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_display_count = &OEM_sys_get_display_count; + devman_plugin_interface_mfld.OEM_sys_get_backlight_min_brightness = &OEM_sys_get_backlight_min_brightness; + devman_plugin_interface_mfld.OEM_sys_get_backlight_max_brightness = &OEM_sys_get_backlight_max_brightness; + devman_plugin_interface_mfld.OEM_sys_get_backlight_brightness = &OEM_sys_get_backlight_brightness; + devman_plugin_interface_mfld.OEM_sys_set_backlight_brightness = &OEM_sys_set_backlight_brightness; + devman_plugin_interface_mfld.OEM_sys_set_backlight_dimming = &OEM_sys_set_backlight_dimming; + devman_plugin_interface_mfld.OEM_sys_get_backlight_acl_control = &OEM_sys_get_backlight_acl_control; + devman_plugin_interface_mfld.OEM_sys_set_backlight_acl_control = &OEM_sys_set_backlight_acl_control; + + devman_plugin_interface_mfld.OEM_sys_get_lcd_power = &OEM_sys_get_lcd_power; + devman_plugin_interface_mfld.OEM_sys_set_lcd_power = &OEM_sys_set_lcd_power; + + /* Image Ehnhace interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_image_enhance_mode = &OEM_sys_get_image_enhance_mode; + devman_plugin_interface_mfld.OEM_sys_set_image_enhance_mode = &OEM_sys_set_image_enhance_mode; + devman_plugin_interface_mfld.OEM_sys_get_image_enhance_scenario = &OEM_sys_get_image_enhance_scenario; + devman_plugin_interface_mfld.OEM_sys_set_image_enhance_scenario = &OEM_sys_set_image_enhance_scenario; + devman_plugin_interface_mfld.OEM_sys_get_image_enhance_tone = &OEM_sys_get_image_enhance_tone; + devman_plugin_interface_mfld.OEM_sys_set_image_enhance_tone = &OEM_sys_set_image_enhance_tone; + devman_plugin_interface_mfld.OEM_sys_get_image_enhance_outdoor = &OEM_sys_get_image_enhance_outdoor; + devman_plugin_interface_mfld.OEM_sys_set_image_enhance_outdoor = &OEM_sys_set_image_enhance_outdoor; + + devman_plugin_interface_mfld.OEM_sys_get_image_enhance_tune = &OEM_sys_get_image_enhance_tune; + devman_plugin_interface_mfld.OEM_sys_set_image_enhance_tune = &OEM_sys_set_image_enhance_tune; + + devman_plugin_interface_mfld.OEM_sys_image_enhance_info = &OEM_sys_image_enhance_info; + + devman_plugin_interface_mfld.OEM_sys_set_display_frame_rate = &OEM_sys_set_display_frame_rate; + + /* UART path interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_uart_path = &OEM_sys_get_uart_path; + devman_plugin_interface_mfld.OEM_sys_set_uart_path = &OEM_sys_set_uart_path; + + /* USB path interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_usb_path = &OEM_sys_get_usb_path; + devman_plugin_interface_mfld.OEM_sys_set_usb_path = &OEM_sys_set_usb_path; + + /* Vibrator interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_haptic_vibetones_level_max = &OEM_sys_get_haptic_motor_level_max; + devman_plugin_interface_mfld.OEM_sys_get_haptic_vibetones_level = &OEM_sys_get_haptic_motor_level; + devman_plugin_interface_mfld.OEM_sys_set_haptic_vibetones_level = &OEM_sys_set_haptic_motor_level; + devman_plugin_interface_mfld.OEM_sys_set_haptic_vibetones_enable = &OEM_sys_set_haptic_motor_enable; + devman_plugin_interface_mfld.OEM_sys_set_haptic_vibetones_oneshot = &OEM_sys_set_haptic_motor_oneshot; + + /* Battery interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_battery_capacity = &OEM_sys_get_battery_capacity; + devman_plugin_interface_mfld.OEM_sys_get_battery_capacity_raw = &OEM_sys_get_battery_capacity_raw; + devman_plugin_interface_mfld.OEM_sys_get_battery_charge_full = &OEM_sys_get_battery_charge_full; + devman_plugin_interface_mfld.OEM_sys_get_battery_charge_now = &OEM_sys_get_battery_charge_now; + devman_plugin_interface_mfld.OEM_sys_get_battery_present = &OEM_sys_get_battery_present; + devman_plugin_interface_mfld.OEM_sys_get_battery_health = &OEM_sys_get_battery_health; + devman_plugin_interface_mfld.OEM_sys_get_battery_polling_required= &OEM_sys_get_battery_polling_required; + devman_plugin_interface_mfld.OEM_sys_get_battery_support_insuspend_charging = &OEM_sys_get_battery_support_insuspend_charging; + + /* Connection interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_jack_charger_online = &OEM_sys_get_jack_charger_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_earjack_online = &OEM_sys_get_jack_earjack_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_earkey_online = &OEM_sys_get_jack_earkey_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_hdmi_online = &OEM_sys_get_jack_hdmi_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_usb_online = &OEM_sys_get_jack_usb_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_cradle_online = &OEM_sys_get_jack_cradle_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_tvout_online = &OEM_sys_get_jack_tvout_online; + devman_plugin_interface_mfld.OEM_sys_get_jack_keyboard_online = &OEM_sys_get_jack_keyboard_online; + + devman_plugin_interface_mfld.OEM_sys_get_hdmi_support = &OEM_sys_get_hdmi_support; + + /* Torch interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_leds_torch_max_brightness = &OEM_sys_get_leds_torch_max_brightness; + devman_plugin_interface_mfld.OEM_sys_get_leds_torch_brightness = &OEM_sys_get_leds_torch_brightness; + devman_plugin_interface_mfld.OEM_sys_set_leds_torch_brightness = &OEM_sys_set_leds_torch_brightness; + + /* Power management interfaces */ + devman_plugin_interface_mfld.OEM_sys_set_power_state = &OEM_sys_set_power_state; + devman_plugin_interface_mfld.OEM_sys_get_power_wakeup_count = &OEM_sys_get_power_wakeup_count; + devman_plugin_interface_mfld.OEM_sys_set_power_wakeup_count = &OEM_sys_set_power_wakeup_count; + + /* OOM interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_memnotify_node = &OEM_sys_get_memnotify_node; + devman_plugin_interface_mfld.OEM_sys_get_memnotify_victim_task = &OEM_sys_get_memnotify_victim_task; + devman_plugin_interface_mfld.OEM_sys_set_memnotify_threshold_lv1 = &OEM_sys_set_memnotify_threshold_lv1; + devman_plugin_interface_mfld.OEM_sys_set_memnotify_threshold_lv2 = &OEM_sys_set_memnotify_threshold_lv2; + + /* Process monitor interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_process_monitor_node = &OEM_sys_get_process_monitor_node; + devman_plugin_interface_mfld.OEM_sys_set_process_monitor_mp_pnp = &OEM_sys_set_process_monitor_mp_pnp; + devman_plugin_interface_mfld.OEM_sys_set_process_monitor_mp_vip = &OEM_sys_set_process_monitor_mp_vip; + + /* UART path interfaces */ + devman_plugin_interface_mfld.OEM_sys_get_cpufreq_cpuinfo_max_freq = &OEM_sys_get_cpufreq_cpuinfo_max_freq; + devman_plugin_interface_mfld.OEM_sys_get_cpufreq_cpuinfo_min_freq = &OEM_sys_get_cpufreq_cpuinfo_min_freq; + devman_plugin_interface_mfld.OEM_sys_get_cpufreq_scaling_max_freq = &OEM_sys_get_cpufreq_scaling_max_freq; + devman_plugin_interface_mfld.OEM_sys_set_cpufreq_scaling_max_freq = &OEM_sys_set_cpufreq_scaling_max_freq; + devman_plugin_interface_mfld.OEM_sys_get_cpufreq_scaling_min_freq = &OEM_sys_get_cpufreq_scaling_min_freq; + devman_plugin_interface_mfld.OEM_sys_set_cpufreq_scaling_min_freq = &OEM_sys_set_cpufreq_scaling_min_freq; + + devman_plugin_interface_mfld.OEM_sys_get_backlight_brightness_by_lux = &OEM_sys_get_backlight_brightness_by_lux; + OEM_sys_display_info(disp_info); + OEM_sys_muic_node_path_info(); + + return &devman_plugin_interface_mfld; +} diff --git a/src/test/slp_plugin_test.c b/src/test/slp_plugin_test.c new file mode 100644 index 0000000..09360c3 --- /dev/null +++ b/src/test/slp_plugin_test.c @@ -0,0 +1,333 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#define TEST_GET(_func, _value) {\ + if((err = _func(&(_value))) < 0) { \ + printf("test "#_func" err:%d\n", err);\ + } else {\ + printf(#_func" get value: %d OK\n", _value); \ + }\ +}\ + +#define TEST_SET(_func, _value) {\ + if((err = _func(_value)) < 0) { \ + printf("test "#_func" err:%d\n", err);\ + } else {\ + printf("test "#_func" OK\n");\ + }\ +}\ + +#define TEST_INDEX_GET(_func, _index, _value) {\ + if((err = _func(_index, &(_value))) < 0) { \ + printf("test "#_func" ,index = %d err:%d\n", _index, err);\ + } else {\ + printf(#_func" ,index = %d get value: %d OK\n", _index, _value); \ + }\ +}\ + +#define TEST_INDEX_SET(_func, _index, _value) {\ + if((err = _func(_index, _value)) < 0) { \ + printf("test "#_func" ,index = %d err:%d\n", _index, err);\ + } else {\ + printf("test "#_func" ,index = %d OK\n", _index);\ + }\ +}\ + +int err = 0; + +void test_set_enable() +{ + int value; + + printf("set enable value (0:disable,1:enable,-1:quit):"); + if((err = scanf("%d", &value)) <= 0) { + return; + } + + if(value == -1) + return; + + TEST_SET(OEM_sys_set_haptic_motor_enable, value); +} + +void test_get_max_level() +{ + int max_level; + + TEST_GET(OEM_sys_get_haptic_motor_level_max, max_level); +} + +int test_set_level() +{ + int level; + + while(1) { + printf("set level (-1:quit):"); + if((err = scanf("%d", &level)) <= 0) { + return -1; + } + + switch(level) { + case 0 ... 100: + TEST_SET(OEM_sys_set_haptic_motor_level, level); + printf("set level: %d\n", level); + case -1: + return 0; + default: + break; + } + } + return 0; +} + +void test_get_level() +{ + int value; + TEST_GET(OEM_sys_get_haptic_motor_level, value); +} + +void test_one_shot() +{ + int value; + + printf("set oneshot times :"); + if((err = scanf("%d", &value)) <= 0) { + printf("scanf failed %d\n", err); + return; + } + + TEST_SET(OEM_sys_set_haptic_motor_oneshot, value); +} + +void svi_test() +{ + int r = 0; + int handle = 0; + + r = svi_init(&handle); + if (r != SVI_SUCCESS){ + printf("Cannot initialize svi.\n"); + } else { +#if 0 + r = svi_play (handle, SVI_VIB_TOUCH_TOUCH, SVI_SND_TOUCH_TOUCH1); + if (r != SVI_SUCCESS) { + printf("Cannot play sound or vibration.\n"); + } +#endif + +#if 0 + r = svi_play_sound (handle, SVI_SND_TOUCH_TOUCH1); + if (r != SVI_SUCCESS) { + printf("Cannot play sound.\n"); + } +#endif + + +#if 1 + r = svi_play_vib (handle, SVI_VIB_OPERATION_VIBRATION); + if (r != SVI_SUCCESS) { + printf("Cannot play vibration.\n"); + } +#endif + // don't close handle too fast, vibrator needs time to boost + sleep(1); + + r = svi_fini(handle); + if (r != SVI_SUCCESS) { + printf("Cannot close svi.\n"); + } + } +} + +void vib_test() +{ + char input,tmp; + + while(1) { + printf("=======================1. vib_test==========================\n"); + printf("1 : test OEM_sys_get_haptic_motor_level_max\n"); + printf("2 : test OEM_sys_get_haptic_motor_level\n"); + printf("3 : test OEM_sys_set_haptic_motor_level\n"); + printf("4 : test OEM_sys_set_haptic_motor_enable\n"); + printf("5 : test OEM_sys_set_haptic_motor_oneshot\n"); + printf("q : quit\n"); + printf("============================================================\n"); + + scanf("%c", &input); + while((tmp = getchar()) != '\n'); + + switch(input) { + case '1': + test_get_max_level(); + break; + case '2': + test_get_level(); + break; + case '3': + test_set_level(); + break; + case '4': + test_set_enable(); + break; + case '5': + test_one_shot(); + break; + case 'q': + return; + default: + break; + } + } +} + +void battery_test() +{ + int value; + + TEST_GET(OEM_sys_get_battery_capacity, value); + TEST_GET(OEM_sys_get_battery_capacity_raw, value); + TEST_GET(OEM_sys_get_battery_charge_full, value); + TEST_GET(OEM_sys_get_battery_charge_now, value); + TEST_GET(OEM_sys_get_battery_present, value); + TEST_GET(OEM_sys_get_battery_health, value); + TEST_GET(OEM_sys_get_battery_polling_required, value); + TEST_GET(OEM_sys_get_battery_support_insuspend_charging, value); +} + +void powner_test() +{ + int value; + + TEST_GET(OEM_sys_get_power_wakeup_count, value); + TEST_SET(OEM_sys_set_power_wakeup_count, value); + TEST_SET(OEM_sys_set_power_state, POWER_STATE_SUSPEND); + TEST_SET(OEM_sys_set_power_state, POWER_STATE_PRE_SUSPEND); + TEST_SET(OEM_sys_set_power_state, POWER_STATE_POST_RESUME); +} + +void cpufreq_test() +{ + int value; + + TEST_GET(OEM_sys_get_cpufreq_cpuinfo_max_freq, value); + TEST_GET(OEM_sys_get_cpufreq_cpuinfo_min_freq, value); + TEST_GET(OEM_sys_get_cpufreq_scaling_max_freq, value); + TEST_SET(OEM_sys_set_cpufreq_scaling_max_freq, value); + TEST_GET(OEM_sys_get_cpufreq_scaling_min_freq, value); + TEST_SET(OEM_sys_set_cpufreq_scaling_min_freq, value); +} + +void jack_test() +{ + int value; + + TEST_GET(OEM_sys_get_jack_charger_online, value); + TEST_GET(OEM_sys_get_jack_earjack_online, value); + TEST_GET(OEM_sys_get_jack_earkey_online, value); + TEST_GET(OEM_sys_get_jack_hdmi_online, value); + TEST_GET(OEM_sys_get_jack_usb_online, value); + TEST_GET(OEM_sys_get_jack_cradle_online, value); + TEST_GET(OEM_sys_get_jack_tvout_online, value); + TEST_GET(OEM_sys_get_jack_keyboard_online, value); +} + +void backlight_test() +{ + int value, power_saving, index, i; + + OEM_sys_get_display_count(&index); + + for(i = 0; i < index; i++) { + printf("================= test index = %d ==================\n", i); + TEST_INDEX_GET(OEM_sys_get_backlight_min_brightness, i, value); + TEST_INDEX_GET(OEM_sys_get_backlight_max_brightness, i, value); + + if((err = OEM_sys_get_backlight_brightness(i, &value, 0)) < 0) { + printf("test OEM_sys_get_backlight_brightness power_saving = 0 err:%d\n", err); + } else { + printf("OEM_sys_get_backlight_brightness power_saving = 0 get value: %d OK\n", value); + } + + if((err = OEM_sys_get_backlight_brightness(i, &value, 1)) < 0) { + printf("test OEM_sys_get_backlight_brightness power_saving = 1 err:%d\n", err); + } else { + printf("OEM_sys_get_backlight_brightness power_saving = 1 get value: %d OK\n", value); + } + + if((err = OEM_sys_set_backlight_brightness(i, &value, 0)) < 0) { + printf("test OEM_sys_set_backlight_brightness power_saving = 0 err:%d\n", err); + } else { + printf("OEM_sys_set_backlight_brightness power_saving = 0 get value: %d OK\n", value); + } + + if((err = OEM_sys_set_backlight_brightness(i, &value, 1)) < 0) { + printf("test OEM_sys_set_backlight_brightness power_saving = 1 err:%d\n", err); + } else { + printf("OEM_sys_set_backlight_brightness power_saving = 1 get value: %d OK\n", value); + } + + OEM_sys_get_backlight_brightness(i, &value, 1); + + TEST_INDEX_SET(OEM_sys_set_backlight_dimming, i, 1); + TEST_INDEX_GET(OEM_sys_get_backlight_acl_control, i, value); + TEST_INDEX_SET(OEM_sys_set_backlight_acl_control, i, value) + } +} + +int main() +{ + char input,tmp; + + OEM_sys_get_devman_plugin_interface(); + + while(1) { + printf("===================slp_device_manager_plugin test====================\n"); + printf("1 : vib_test\n"); + printf("2 : svi_test\n"); + printf("3 : battery_test\n"); + printf("4 : power_test\n"); + printf("5 : cpufreq_test\n"); + printf("6 : jack_test\n"); + printf("7 : backlight\n"); + printf("q : quit\n"); + printf("=====================================================================\n"); + + scanf("%c", &input); + while((tmp = getchar()) != '\n'); + + switch(input) { + case '1': + vib_test(); + break; + case '2': + svi_test(); + break; + case '3': + battery_test(); + break; + case '4': + powner_test(); + break; + case '5': + cpufreq_test(); + break; + case '6': + jack_test(); + break; + case '7': + backlight_test(); + break; + case 'q': + return 0; + default: + break; + } + } + return 0; +} diff --git a/src/vibrator.c b/src/vibrator.c new file mode 100644 index 0000000..2903ebe --- /dev/null +++ b/src/vibrator.c @@ -0,0 +1,770 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vibrator.h" + +#define LOG_TAG "slp_devman_plugin" +#define VIB_INFO_DEFAULT_PATH "/usr/etc/vibrator.ini" +#define MAX_VALUE_SIZE 64 +#define VIB_INFO_NUM 9 +#define SESSION "general" +#define MALLOC(type, num) (type*)malloc((num)*sizeof(type)) +#define CYCLE_COUNT_TYPE 1 +#define ON_TIME_TYPE 2 + + +char *vib_ini_name[VIB_INFO_NUM][2] = { + {"Vibra1 Boost Time", "8"}, + {"Vibra1 Duty Cycle", "50"}, + {"Vibra1 Brake", "On"}, + {"Vibra1 Direction", "Forward"}, + {"Vibra1 On Time", "Infinite"}, + {"Vibra1 Off Time", "0.00"}, + {"Vibra1 Cycle Count", "Infinite"}, + {"Vibra1 Enable Mux", "SPI"}, + {"Vibra1 Start", "Off"} +}; + +typedef struct { + snd_ctl_elem_info_t *info; + snd_ctl_elem_id_t *id; + snd_ctl_elem_value_t *control; +}vib_stack_t; + +static __thread int err; +static __thread char card[MAX_VALUE_SIZE] = "default"; +static __thread char card_num[MAX_VALUE_SIZE]; +static __thread char vib_info_value[VIB_INFO_NUM][MAX_VALUE_SIZE]; +static __thread int init_flag = 0; + +int read_ini_info() +{ + char *tmp; + int i; + char name[64]; + memset(vib_info_value, 0, sizeof(vib_info_value)); + dictionary* dic = iniparser_load(VIB_INFO_DEFAULT_PATH); + if(!dic) { + SLOGE("iniparser load err"); + return -1; + } + + tmp = iniparser_getstring(dic, "general:Card", NULL); + if(tmp) { + strncpy(card_num, tmp, strlen(tmp)); + card_num[strlen(tmp)] = '\0'; + } else { + SLOGE("iniparser get card err"); + iniparser_freedict(dic); + return -1; + } + + for(i = 0; i < VIB_INFO_NUM; i++) { + sprintf(name, "%s:%s", SESSION, vib_ini_name[i][0]); + name[strlen(name)] = '\0'; + tmp = iniparser_getstring(dic, name, vib_ini_name[i][1]); + strncpy(vib_info_value[i], tmp, strlen(tmp)); + vib_info_value[i][63] = '\0'; + SLOGD("name: [%s], vib_info_value[%d]: %s\n", name, i, vib_info_value[i]); + } + + if (dic) { + iniparser_freedict(dic); + dic = NULL; + } + + return 0; +} + +void print_vib_val() +{ + int i; + for(i = 0; i < VIB_INFO_NUM; i++) { + SLOGD("print_vid_val: %s", vib_info_value[i]); + } + SLOGD("card : %s", card_num); +} + +int open_vib_hw(snd_ctl_t **handle) +{ + int i; + //Get card number + i = snd_card_get_index(card_num); + if(i >= 0 && i < 32) + { + memset(card, 0, sizeof(card)); + sprintf(card, "hw:%d", i); + } else { + SLOGE("card number err:[%d]", i); + return -1; + } + + //Open handle + if((err = snd_ctl_open(handle, card, 0)) < 0) + { + SLOGE("control %s open err: %s", card, snd_strerror(err)); + return -1; + } + + return 0; +} + +int prepare_snd_ctl(snd_ctl_t *handle, vib_stack_t *stack, + snd_ctl_elem_type_t *type, unsigned int *count, char *name) +{ + memset(stack->id, 0, snd_ctl_elem_id_sizeof()); + memset(stack->info, 0, snd_ctl_elem_info_sizeof()); + memset(stack->control, 0, snd_ctl_elem_value_sizeof()); + + //Set interface + snd_ctl_elem_id_set_interface(stack->id, SND_CTL_ELEM_IFACE_MIXER); + + //Set name test for Vibra1 Start + snd_ctl_elem_id_set_name(stack->id, name); + + //init info id + snd_ctl_elem_info_set_id(stack->info, stack->id); + + //get info + if((err = snd_ctl_elem_info(handle, stack->info)) < 0) + { + SLOGE("get info err : %s", snd_strerror(err)); + return -1; + } + + //get type + *type = snd_ctl_elem_info_get_type(stack->info); + + //get count + *count = snd_ctl_elem_info_get_count(stack->info); + + //set value id + snd_ctl_elem_value_set_id(stack->control, stack->id); + + return 0; +} + +int vib_hw_io(int set_flag, snd_ctl_t *handle, vib_stack_t *stack, + snd_ctl_elem_type_t *type, unsigned int *count, int value, int *out_val) +{ + unsigned int idx; + long tmp; + + if(!set_flag) { + //read element + if((err = snd_ctl_elem_read(handle, stack->control)) < 0) { + SLOGE("read element err :%s", snd_strerror(err)); + return -1; + } + + for(idx = 0; idx < *count && idx < 128; idx++) { + switch (*type) { + case SND_CTL_ELEM_TYPE_BOOLEAN: + *out_val = snd_ctl_elem_value_get_boolean(stack->control, idx); + break; + case SND_CTL_ELEM_TYPE_INTEGER: + *out_val = snd_ctl_elem_value_get_integer(stack->control, idx); + break; + case SND_CTL_ELEM_TYPE_INTEGER64: + *out_val = snd_ctl_elem_value_get_integer64(stack->control, idx); + break; + case SND_CTL_ELEM_TYPE_ENUMERATED: + *out_val = snd_ctl_elem_value_get_enumerated(stack->control, idx); + break; + case SND_CTL_ELEM_TYPE_BYTES: + *out_val = snd_ctl_elem_value_get_byte(stack->control, idx); + break; + default: + SLOGE("Unknown control element type"); + return -1; + } + } + } else { + //set value + tmp = value; + for(idx = 0; idx < *count && idx < 128; idx++) + { + switch (*type) { + case SND_CTL_ELEM_TYPE_BOOLEAN: + snd_ctl_elem_value_set_boolean(stack->control, idx, tmp); + break; + case SND_CTL_ELEM_TYPE_INTEGER: + snd_ctl_elem_value_set_integer(stack->control, idx, tmp); + break; + case SND_CTL_ELEM_TYPE_INTEGER64: + snd_ctl_elem_value_set_integer64(stack->control, idx, tmp); + break; + case SND_CTL_ELEM_TYPE_ENUMERATED: + snd_ctl_elem_value_set_enumerated(stack->control, idx, tmp); + break; + case SND_CTL_ELEM_TYPE_BYTES: + snd_ctl_elem_value_set_byte(stack->control, idx, tmp); + break; + default: + SLOGE("Unknown control element type"); + return -1; + } + + SLOGD("writing alsa element, index %u with value %ld\n", idx, tmp); + // Write element + if ((err = snd_ctl_elem_write(handle, stack->control)) < 0) { + SLOGE("snd_ctl_elem_write err: %s", snd_strerror(err)); + // Close sound control + return -1; + } + } + } + return 0; +} + +int translate_str_to_int(snd_ctl_t *handle, vib_stack_t *stack, char *str_val) +{ + int items, i; + const char *name; + + items = snd_ctl_elem_info_get_items(stack->info); + if (items <= 0) + return -1; + + SLOGD("trans name=[%s], value=[%s]", snd_ctl_elem_id_get_name(stack->id), str_val); + for (i = 0; i < items; i++) { + snd_ctl_elem_info_set_item(stack->info, i); + if (snd_ctl_elem_info(handle, stack->info) < 0) + return -1; + name = snd_ctl_elem_info_get_item_name(stack->info); + SLOGE("item %d : %s", i, name); + if(strcmp(name, str_val) == 0) { + return i; + } + } + + SLOGD("%s can't find suit value", str_val); + return -1; +} + + +int translate_enum_to_value(snd_ctl_t *handle, vib_stack_t *stack, int *value) +{ + int items; + char *name; + + items = snd_ctl_elem_info_get_items(stack->info); + if (items <= 0) + return -1; + + snd_ctl_elem_info_set_item(stack->info, *value); + + if (snd_ctl_elem_info(handle, stack->info) < 0) + return -1; + + name = snd_ctl_elem_info_get_item_name(stack->info); + if(name != NULL) + *value = atoi(name); + else + return -1; + + return 0; +} + + +int get_literal_value(snd_ctl_t *handle, vib_stack_t *stack, char **str_val, int flag) +{ + int items, i, j; + char *name; + + items = snd_ctl_elem_info_get_items(stack->info); + if (items <= 0) + return -1; + + //cyclecount has "off" in the beginning and "infinite" at last + //on time has "infinite" at last + switch(flag) { + case CYCLE_COUNT_TYPE: + i = 1; + items = items - 1; + break; + case ON_TIME_TYPE: + i = 0; + items = items - 1; + break; + default: + i = 0; + } + + for (j = 0; i < items; i++, j++) { + name = NULL; + snd_ctl_elem_info_set_item(stack->info, i); + if (snd_ctl_elem_info(handle, stack->info) < 0) + return -1; + name = snd_ctl_elem_info_get_item_name(stack->info); + + SLOGE("item %d : %s", i, name); + strncpy(str_val[j], name, strlen(name)); + str_val[j][strlen(name)] = '\0'; + } + + return 0; +} + +int get_items_count(snd_ctl_t *handle, vib_stack_t *stack) +{ + int items; + + items = snd_ctl_elem_info_get_items(stack->info); + + if (items <= 0) + return -1; + else + return items; +} + +void print_array(int cycle_count_num, int ontime_num, double **array) +{ + int pos_cycle_count, pos_ontime; + for(pos_cycle_count = 0;pos_cycle_count < cycle_count_num; pos_cycle_count++) { + for(pos_ontime = 0;pos_ontime < ontime_num; pos_ontime++) { + SLOGD("[%.2lf]", array[pos_cycle_count][pos_ontime]); + } + } +} + +void free_planar_array(void **p, int row) +{ + int i; + if(p == NULL) + return; + for(i = 0; i < row; i++) { + free(p[i]); + } + free(p); +} + +double **new_double_planar_array(int row, int column) +{ + double **array; + int i,j; + //get on time literal value + array = MALLOC(double *, row); + if(array == NULL) { + SLOGE("malloc err"); + return NULL; + } + + for(i = 0; i < row; i++) { + array[i] = MALLOC(double, column); + if(array[i] == NULL) { + SLOGE("malloc err"); + goto free_all; + } + } + return array; + +free_all: + for(j = 0; j < i; j++) { + free(array[j]); + } + free(array); + return NULL; +} + +char **new_char_planar_array(int row, int column) +{ + char **array; + int i, j; + + array = MALLOC(char *, row); + if(array == NULL) { + SLOGE("malloc err"); + return NULL; + } + + for(i = 0; i < row; i++) { + array[i] = MALLOC(char, column); + if(array[i] == NULL) { + SLOGE("malloc err"); + goto free_all; + } + } + return array; + +free_all: + for(j = 0; j < i; j++) { + free(array[j]); + } + free(array); + return NULL; +} + +int init_value_array(int cycle_count_num, int ontime_num, double **array) +{ + int pos_cycle_count,pos_ontime, ret; + char **p_cycle = NULL, **p_ontime = NULL; + + //get literal value of cyclecount + if((p_cycle = new_char_planar_array(cycle_count_num, MAX_VALUE_SIZE)) == NULL) { + SLOGE("new char planar array - cyclecount err"); + return -1; + } + if((ret = vib_hw_ctrl(VIBRA_GET_LITERAL_VALUE_CYCLECOUNT, 0, 0, NULL, p_cycle)) < 0) { + SLOGE("get literal_value_cyclecount err"); + goto free_array; + } + + //get literal value of on time + if((p_ontime = new_char_planar_array(ontime_num, MAX_VALUE_SIZE)) == NULL) { + SLOGE("new char planar array - ontime err"); + goto free_array; + } + if((ret = vib_hw_ctrl(VIBRA_GET_LITERAL_VALUE_ON_TIME, 0, 0, NULL, p_ontime)) < 0) { + SLOGE("get literal_value_ontime err"); + goto free_array; + } + + //calculate all possible combinations + for(pos_cycle_count = 0;pos_cycle_count < cycle_count_num; pos_cycle_count++) { + for(pos_ontime = 0;pos_ontime < ontime_num; pos_ontime++) { + array[pos_cycle_count][pos_ontime] = atof(p_cycle[pos_cycle_count]) * atof(p_ontime[pos_ontime]); + SLOGD("[%.2lf]", array[pos_cycle_count][pos_ontime]); + } + } + + free_planar_array(p_cycle, cycle_count_num); + free_planar_array(p_ontime, ontime_num); + return 0; + +free_array: + free_planar_array(p_cycle, cycle_count_num); + free_planar_array(p_ontime, ontime_num); + return -1; +} + +void find_cycle_and_ontime(double **p, int cycle_count_num, int ontime_num, int *out_cycle_pos, int *out_ontime_pos, double value) +{ + double tmp = fabs(p[0][0] - value); + int pos_cycle_count, pos_ontime, i = 0, j = 0; + + for(pos_cycle_count = 0; pos_cycle_count < cycle_count_num; pos_cycle_count++) { + for(pos_ontime = 0; pos_ontime < ontime_num; pos_ontime++) { + if(tmp > fabs(value - p[pos_cycle_count][pos_ontime])) { + i = pos_cycle_count; + j = pos_ontime; + tmp = fabs(value - p[pos_cycle_count][pos_ontime]); + SLOGD("tmp=[%.2lf], p[%d][%d]=[%.2lf]\n", tmp, pos_cycle_count, pos_ontime, p[pos_cycle_count][pos_ontime]); + } + } + } + *out_cycle_pos = i; + *out_ontime_pos = j; +} + +int find_suit_value_and_set(int value) +{ + int ret, cycle_count_num, ontime_num, pos_cycle_count = 0, pos_ontime = 0; + double **array = NULL; + + if(value <= 0) { + SLOGE("input value %d is not valid", value); + return -1; + } + + if((ret = vib_hw_ctrl(VIBRA_GET_NUM_CYCLECOUNT, 0, 0, &cycle_count_num, NULL)) < 0) { + SLOGE("get num_cyclecount err"); + return -1; + } + + if((ret = vib_hw_ctrl(VIBRA_GET_NUM_ON_TIME, 0, 0, &ontime_num, NULL)) < 0) { + SLOGE("get num_ontime err"); + return -1; + } + + //drop off, infinite + cycle_count_num = cycle_count_num - 2; + + //drop infinite + ontime_num = ontime_num - 1; + + if((array = new_double_planar_array(cycle_count_num, ontime_num)) == NULL) { + return -1; + } + + ret = init_value_array(cycle_count_num, ontime_num, array); + if(ret < 0) { + SLOGE("init array failed"); + goto free_array; + } + + find_cycle_and_ontime(array, cycle_count_num, ontime_num, &pos_cycle_count, &pos_ontime, (value / 1000.0)); + SLOGD("find suit cyclecount [%d], onTime [%d]", pos_cycle_count, pos_ontime); + + //set cyclecount , ontime and begin start + if(vib_hw_ctrl(VIBRA_CYCLE_COUNT, 1, pos_cycle_count + 1, NULL, NULL)) { + SLOGE("SET Cycle Count %d err", pos_cycle_count + 1); + goto free_array; + } + if(vib_hw_ctrl(VIBRA_ON_TIME, 1, pos_ontime, NULL, NULL)) { + SLOGE("SET On Time %d err", pos_ontime); + goto free_array; + } + if(vib_hw_ctrl(VIBRA_START, 1, 1, NULL, NULL)) { + SLOGE("start vibrator err"); + goto free_array; + } + + free_planar_array(array, cycle_count_num); + return 0; + +free_array: + free_planar_array(array, cycle_count_num); + return -1; +} + +int init_vib_value(snd_ctl_t *handle, vib_stack_t *stack, snd_ctl_elem_type_t *type, unsigned int *count) +{ + int value, i; + for(i = 0; i < VIB_INFO_NUM; i++) { + err = prepare_snd_ctl(handle, stack, type, count, vib_ini_name[i][0]); + if(err < 0) { + SLOGE("prepare vib hw err"); + return -1; + } + + //in ini file,we define string value not enum value + value = translate_str_to_int(handle, stack, vib_info_value[i]); + if(value < 0) { + SLOGE("[%s] translate err", vib_ini_name[i][0]); + return -1; + } + + err = vib_hw_io(1, handle, stack, type, count, value, NULL); + if(err < 0) { + SLOGE("ctl vib hw err"); + return -1; + } + } + return 0; +} + +int get_hw_name(int type, char *name) +{ + memset(name, 0, sizeof(name)); + switch(type) { + case VIBRA_BOOST_TIME: + strncpy(name, vib_ini_name[VIBRA_BOOST_TIME][0], strlen(vib_ini_name[VIBRA_BOOST_TIME][0])); + name[strlen(vib_ini_name[VIBRA_BOOST_TIME][0])] = '\0'; + break; + case VIBRA_DUTY_CYCLE: + case VIBRA_GET_LEVEL_MAX: + strncpy(name, vib_ini_name[VIBRA_DUTY_CYCLE][0], strlen(vib_ini_name[VIBRA_DUTY_CYCLE][0])); + name[strlen(vib_ini_name[VIBRA_DUTY_CYCLE][0])] = '\0'; + break; + case VIBRA_BRAKE: + strncpy(name, vib_ini_name[VIBRA_BRAKE][0], strlen(vib_ini_name[VIBRA_BRAKE][0])); + name[strlen(vib_ini_name[VIBRA_BRAKE][0])] = '\0'; + break; + case VIBRA_DIRECTION: + strncpy(name, vib_ini_name[VIBRA_DIRECTION][0], strlen(vib_ini_name[VIBRA_DIRECTION][0])); + name[strlen(vib_ini_name[VIBRA_DIRECTION][0])] = '\0'; + break; + case VIBRA_ON_TIME: + case VIBRA_GET_NUM_ON_TIME: + case VIBRA_GET_LITERAL_VALUE_ON_TIME: + strncpy(name, vib_ini_name[VIBRA_ON_TIME][0], strlen(vib_ini_name[VIBRA_ON_TIME][0])); + name[strlen(vib_ini_name[VIBRA_ON_TIME][0])] = '\0'; + break; + case VIBRA_OFF_TIME: + strncpy(name, vib_ini_name[VIBRA_OFF_TIME][0], strlen(vib_ini_name[VIBRA_OFF_TIME][0])); + name[strlen(vib_ini_name[VIBRA_OFF_TIME][0])] = '\0'; + break; + case VIBRA_CYCLE_COUNT: + case VIBRA_GET_NUM_CYCLECOUNT: + case VIBRA_GET_LITERAL_VALUE_CYCLECOUNT: + strncpy(name, vib_ini_name[VIBRA_CYCLE_COUNT][0], strlen(vib_ini_name[VIBRA_CYCLE_COUNT][0])); + name[strlen(vib_ini_name[VIBRA_CYCLE_COUNT][0])] = '\0'; + break; + case VIBRA_ENABLE_MUX: + strncpy(name, vib_ini_name[VIBRA_ENABLE_MUX][0], strlen(vib_ini_name[VIBRA_ENABLE_MUX][0])); + name[strlen(vib_ini_name[VIBRA_ENABLE_MUX][0])] = '\0'; + break; + case VIBRA_START: + strncpy(name, vib_ini_name[VIBRA_START][0], strlen(vib_ini_name[VIBRA_START][0])); + name[strlen(vib_ini_name[VIBRA_START][0])] = '\0'; + break; + default: + SLOGE("can't find suit name, type: %d", type); + return -1; + } + return 0; +} + +void get_alarm_and_stop(int num) +{ + if(vib_hw_ctrl(VIBRA_START, 1, 0, NULL, NULL)) { + SLOGE("start vibrator err"); + return; + } +} + +int settimer_and_vibrate(int value) +{ + int sec = 0, usec = 0, ret; + struct itimerval tick; + + if(value <= 0) { + SLOGE("input value %d is not valid", value); + return -1; + } + + signal(SIGALRM, get_alarm_and_stop); + + sec = value / 1000; + usec = (value % 1000) * 1000; + + tick.it_value.tv_sec = sec; + tick.it_value.tv_usec = usec; + tick.it_interval.tv_sec = 0; + tick.it_interval.tv_usec = 0; + + ret = setitimer(ITIMER_REAL, &tick, NULL); + if (ret != 0) + { + SLOGE("Settimer error.%s", strerror(errno)); + return -1 ; + } + + if(vib_hw_ctrl(VIBRA_START, 1, 1, NULL, NULL)) { + SLOGE("start vibrator err"); + return -1; + } + return 0; +} + +int vib_hw_ctrl(int hw_ctl_type, int set_flag, int value, int *out_val, char **literal_value) +{ + snd_ctl_t *handle = NULL; + vib_stack_t stack; + snd_ctl_elem_type_t type; + unsigned int count; + char hw_name[MAX_VALUE_SIZE]; + + //init default vib_info + if(!init_flag) { + if((err = read_ini_info()) < 0) { + SLOGE("init vib info err:%d", err); + return -1; + } + print_vib_val(); + } + + //Allocate in stack + snd_ctl_elem_id_alloca(&(stack.id)); + snd_ctl_elem_info_alloca(&(stack.info)); + snd_ctl_elem_value_alloca(&(stack.control)); + + if((err = open_vib_hw(&handle)) < 0) { + SLOGE("open vib hw err"); + return -1; + } + + //init all values first + if(!init_flag) { + err = init_vib_value(handle, &stack, &type, &count); + if(err < 0) { + SLOGE("prepare vib hw err"); + goto error; + } + init_flag = 1; + } + + err = get_hw_name(hw_ctl_type, hw_name); + if(err < 0) { + SLOGE("prepare vib hw err"); + goto error; + } + + SLOGD("hw_name : [%s]", hw_name); + err = prepare_snd_ctl(handle, &stack, &type, &count, hw_name); + if(err < 0) { + SLOGE("prepare vib hw err"); + goto error; + } + + //set value + if(set_flag) { + if(hw_ctl_type == VIBRA_DUTY_CYCLE) { + char tmp[32]; + memset(tmp, 0, sizeof(tmp)); + sprintf(tmp, "%d", value); + + value = translate_str_to_int(handle, &stack, tmp); + if(value < 0) { + SLOGE("[%s] translate err", tmp); + goto error; + } + } + + err = vib_hw_io(1, handle, &stack, &type, &count, value, NULL); + if(err < 0) { + SLOGE("ctl vib hw err"); + goto error; + } + //or get value + } else { + switch(hw_ctl_type) { + case VIBRA_GET_LEVEL_MAX: + if((*out_val = get_items_count(handle, &stack)) < 0) { + SLOGE("get level max err"); + goto error; + } + + (*out_val)--; + break; + case VIBRA_GET_NUM_CYCLECOUNT: + case VIBRA_GET_NUM_ON_TIME: + if((*out_val = get_items_count(handle, &stack)) < 0) { + SLOGE("get count num err"); + goto error; + } + break; + case VIBRA_GET_LITERAL_VALUE_CYCLECOUNT: + if((err = get_literal_value(handle, &stack, literal_value, CYCLE_COUNT_TYPE)) < 0) { + SLOGE("get cycle count literal value err"); + goto error; + } + break; + case VIBRA_GET_LITERAL_VALUE_ON_TIME: + if((err = get_literal_value(handle, &stack, literal_value, ON_TIME_TYPE)) < 0) { + SLOGE("get on time literal value err"); + goto error; + } + break; + default: + err = vib_hw_io(0, handle, &stack, &type, &count, 0, out_val); + if(err < 0) { + SLOGE("ctl vib hw err"); + goto error; + } + break; + } + + if(hw_ctl_type == VIBRA_DUTY_CYCLE + || hw_ctl_type == VIBRA_GET_LEVEL_MAX) { + err = translate_enum_to_value(handle, &stack, out_val); + if(err < 0) { + SLOGE("ctl vib hw err"); + goto error; + } + } + } + snd_ctl_close(handle); + return 0; + +error: + snd_ctl_close(handle); + return -1; +} diff --git a/vibrator.ini b/vibrator.ini new file mode 100644 index 0000000..3061732 --- /dev/null +++ b/vibrator.ini @@ -0,0 +1,49 @@ +; To see available options, check "amixer -c3" output in device: +; ; Simple mixer control 'Vibra1 Boost Time',0 +; ; Capabilities: enum +; ; Items: '0' '1' '2' '4' '8' '16' '32' '64' +; ; Item0: '8' +; ; Simple mixer control 'Vibra1 Brake',0 +; ; Capabilities: enum +; ; Items: 'Off' 'On' +; ; Item0: 'On' +; ; Simple mixer control 'Vibra1 Cycle Count',0 +; ; Capabilities: enum +; ; Items: 'Off' '1' '2' '4' '8' '16' '32' 'Infinite' +; ; Item0: '32' +; ; Simple mixer control 'Vibra1 Direction',0 +; ; Capabilities: enum +; ; Items: 'Forward' 'Forward & Reverse' +; ; Item0: 'Forward & Reverse' +; ; Simple mixer control 'Vibra1 Duty Cycle',0 +; ; Capabilities: enum +; ; Items: '20' '22' '24' '26' '28' '30' '32' '34' '36' '38' '40' '42' '44' '46' '48' '50' '52' '54' '56' '58' '60' '62' '64' '66' '68' '70' '75' '80' '85' '90' '95' '100' +; ; Item0: '30' +; ; Simple mixer control 'Vibra1 Enable Mux',0 +; ; Capabilities: enum +; ; Items: 'PWM' 'SPI' +; ; Item0: 'SPI' +; ; Simple mixer control 'Vibra1 Off Time',0 +; ; Capabilities: enum +; ; Items: '0.00' '0.05' '0.10' '0.15' '0.20' '0.25' '0.30' '0.35' '0.40' '0.45' '0.50' '0.75' '1.00' '1.25' '1.50' '2.00' +; ; Item0: '1.00' +; ; Simple mixer control 'Vibra1 On Time',0 +; ; Capabilities: enum +; ; Items: '0.05' '0.10' '0.15' '0.20' '0.25' '0.30' '0.35' '0.40' '0.45' '0.50' '0.75' '1.00' '1.25' '1.5' '2.00' 'Infinite' +; ; Item0: '1.00' +; ; Simple mixer control 'Vibra1 Start',0 +; ; Capabilities: enum +; ; Items: 'Off' 'On' +; ; Item0: 'Off' +; + +[general] +Card=3 +Vibra1 Boost Time = 8 ; millisecond +Vibra1 Duty Cycle = 50 ; intensity level +Vibra1 Brake = On +Vibra1 Direction = Forward +Vibra1 On Time = Infinite ; second +Vibra1 Off Time = 0.00 ; second +Vibra1 Cycle Count = Infinite ; +Vibra1 Enable Mux = SPI ; -- 2.7.4