diff --git a/src/clevo_keyboard.h b/src/clevo_keyboard.h index 7793ba2..91d938a 100644 --- a/src/clevo_keyboard.h +++ b/src/clevo_keyboard.h @@ -34,19 +34,7 @@ #define KEYBOARD_BRIGHTNESS 0xF4000000 -/* All these COLOR_* macros are never used in the code, don't know why they are - here, maybe for documentation purposes. So won't delete for now */ -#define COLOR_BLACK 0x000000 -#define COLOR_RED 0xFF0000 -#define COLOR_GREEN 0x00FF00 -#define COLOR_BLUE 0x0000FF -#define COLOR_YELLOW 0xFFFF00 -#define COLOR_MAGENTA 0xFF00FF -#define COLOR_CYAN 0x00FFFF -#define COLOR_WHITE 0xFFFFFF - - -#define KB_COLOR_DEFAULT COLOR_WHITE // Default Color: White +#define KB_COLOR_DEFAULT 0xFFFFFF // White #define DEFAULT_BLINKING_PATTERN 0 // Submethod IDs for the CLEVO_GET WMI method @@ -105,16 +93,6 @@ static struct key_entry clevo_wmi_keymap[] = { #define BRIGHTNESS_STEP 25 -struct color_t { - u32 code; - char* name; -}; - -struct color_list_t { - uint size; - struct color_t colors[]; -}; - // Keyboard struct struct kbd_led_state_t { u8 has_extra; @@ -138,7 +116,7 @@ struct blinking_pattern_t { const char *const name; }; -// Param Validators + static int blinking_pattern_id_validator(const char *value, const struct kernel_param *blinking_pattern_param); static const struct kernel_param_ops param_ops_mode_ops = { @@ -146,14 +124,6 @@ static const struct kernel_param_ops param_ops_mode_ops = { .get = param_get_int, }; -static int brightness_validator(const char *val, - const struct kernel_param *brightness_param); -static const struct kernel_param_ops param_ops_brightness_ops = { - .set = brightness_validator, - .get = param_get_int, -}; - -// Module Parameters static uint param_color_left = KB_COLOR_DEFAULT; module_param_named(color_left, param_color_left, uint, S_IRUSR); MODULE_PARM_DESC(color_left, "Color for the Left Region"); @@ -174,11 +144,6 @@ static ushort param_blinking_pattern = DEFAULT_BLINKING_PATTERN; module_param_cb(mode, ¶m_ops_mode_ops, ¶m_blinking_pattern, S_IRUSR); MODULE_PARM_DESC(mode, "Set the keyboard backlight blinking pattern"); -static ushort param_brightness = BRIGHTNESS_DEFAULT; -module_param_cb(brightness, ¶m_ops_brightness_ops, ¶m_brightness, - S_IRUSR); -MODULE_PARM_DESC(brightness, "Set the Keyboard Brightness"); - static bool param_state = true; module_param_named(state, param_state, bool, S_IRUSR); MODULE_PARM_DESC(state, @@ -196,20 +161,6 @@ static struct kbd_led_state_t kbd_led_state = { .whole_kbd_color = 7 }; -static struct color_list_t color_list = { - .size = 8, - .colors = { - { .name = "BLACK", .code = 0x000000 }, // 0 - { .name = "RED", .code = 0xFF0000 }, // 1 - { .name = "GREEN", .code = 0x00FF00 }, // 2 - { .name = "BLUE", .code = 0x0000FF }, // 3 - { .name = "YELLOW", .code = 0xFFFF00 }, // 4 - { .name = "MAGENTA", .code = 0xFF00FF }, // 5 - { .name = "CYAN", .code = 0x00FFFF }, // 6 - { .name = "WHITE", .code = 0xFFFFFF }, // 7 - } -}; - static struct blinking_pattern_t blinking_patterns[] = { { .key = 0,.value = 0,.name = "CUSTOM"}, { .key = 1,.value = 0x1002a000,.name = "BREATHE"}, @@ -738,6 +689,7 @@ static int clevo_keyboard_probe(struct platform_device *dev) set_color(REGION_RIGHT, param_color_right); set_blinking_pattern(param_blinking_pattern); + if (param_brightness > BRIGHTNESS_MAX) param_brightness = BRIGHTNESS_DEFAULT; set_brightness(param_brightness); set_enabled(param_state); diff --git a/src/tuxedo_keyboard.c b/src/tuxedo_keyboard.c index 1513cf6..0ea1433 100644 --- a/src/tuxedo_keyboard.c +++ b/src/tuxedo_keyboard.c @@ -20,13 +20,6 @@ #define pr_fmt(fmt) "tuxedo_keyboard" ": " fmt -#include -#include -#include -#include -#include -#include -#include #include "tuxedo_keyboard_common.h" #include "clevo_keyboard.h" #include "uniwill_keyboard.h" @@ -43,6 +36,8 @@ MODULE_ALIAS("wmi:" UNIWILL_WMI_EVENT_GUID_0); MODULE_ALIAS("wmi:" UNIWILL_WMI_EVENT_GUID_1); MODULE_ALIAS("wmi:" UNIWILL_WMI_EVENT_GUID_2); +MODULE_SOFTDEP("pre: tuxedo-cc-wmi"); + static struct tuxedo_keyboard_driver *driver_list[] = { &clevo_keyboard_driver, &uniwill_keyboard_driver diff --git a/src/tuxedo_keyboard_common.h b/src/tuxedo_keyboard_common.h index 950db5f..3a52b2a 100644 --- a/src/tuxedo_keyboard_common.h +++ b/src/tuxedo_keyboard_common.h @@ -21,6 +21,11 @@ #define TUXEDO_KEYBOARD_COMMON_H #include +#include +#include +#include +#include +#include #include /* :::: Module specific Constants and simple Macros :::: */ @@ -68,4 +73,68 @@ bool sparse_keymap_report_known_event(struct input_dev *dev, unsigned int code, return false; } +struct color_t { + u32 code; + char* name; +}; + +struct color_list_t { + uint size; + struct color_t colors[]; +}; + +/** + * Commonly used standard colors + */ +static struct color_list_t color_list = { + .size = 8, + .colors = { + { .name = "BLACK", .code = 0x000000 }, // 0 + { .name = "RED", .code = 0xFF0000 }, // 1 + { .name = "GREEN", .code = 0x00FF00 }, // 2 + { .name = "BLUE", .code = 0x0000FF }, // 3 + { .name = "YELLOW", .code = 0xFFFF00 }, // 4 + { .name = "MAGENTA", .code = 0xFF00FF }, // 5 + { .name = "CYAN", .code = 0x00FFFF }, // 6 + { .name = "WHITE", .code = 0xFFFFFF }, // 7 + } +}; + +/** + * Looks up a color in the color_list + * + * Returns found color value, or 0xffffffff if string did not match + */ +static u32 color_lookup(const struct color_list_t *color_list, const char *color_name) +{ + u32 found_color = 0xffffffff; + int i; + for (i = 0; i < color_list->size; ++i) { + if (strcmp(color_list->colors[i].name, color_name) == 0) { + found_color = color_list->colors[i].code; + } + } + + return found_color; +} + +// Common parameters + +static int brightness_validator(const char *val, + const struct kernel_param *brightness_param); +static const struct kernel_param_ops param_ops_brightness_ops = { + .set = brightness_validator, + .get = param_get_int, +}; + +static ushort param_brightness = 0xffff; // Default unset value (higher than max) +module_param_cb(brightness, ¶m_ops_brightness_ops, ¶m_brightness, + S_IRUSR); +MODULE_PARM_DESC(brightness, "Set the Keyboard Brightness"); + +#define COLOR_STRING_LEN 20 +static char param_color[COLOR_STRING_LEN]; +module_param_string(color, param_color, COLOR_STRING_LEN, S_IRUSR); +MODULE_PARM_DESC(color, "Preset color for the keyboard backlight as string"); + #endif \ No newline at end of file diff --git a/src/uniwill_keyboard.h b/src/uniwill_keyboard.h index d3b8be6..24d3238 100644 --- a/src/uniwill_keyboard.h +++ b/src/uniwill_keyboard.h @@ -22,6 +22,7 @@ #include #include #include +#include #define UNIWILL_WMI_MGMT_GUID_BA "ABBC0F6D-8EA1-11D1-00A0-C90629100000" #define UNIWILL_WMI_MGMT_GUID_BB "ABBC0F6E-8EA1-11D1-00A0-C90629100000" @@ -34,10 +35,50 @@ #define UNIWILL_OSD_RADIOON 0x01A #define UNIWILL_OSD_RADIOOFF 0x01B -#define UNIWILL_OSD_TOUCHPADWORKAROUND 0xFFF +#define UNIWILL_OSD_TOUCHPADWORKAROUND 0xFFF + +#define UNIWILL_BRIGHTNESS_MIN 0x00 +#define UNIWILL_BRIGHTNESS_MAX 0xc8 +#define UNIWILL_BRIGHTNESS_DEFAULT UNIWILL_BRIGHTNESS_MAX * 0.30 +#define UNIWILL_COLOR_DEFAULT 0xffffff + +union uw_ec_read_return { + u32 dword; + struct { + u8 data_low; + u8 data_high; + } bytes; +}; + +union uw_ec_write_return { + u32 dword; + struct { + u8 addr_low; + u8 addr_high; + u8 data_low; + u8 data_high; + } bytes; +}; + +typedef u32 (uw_ec_read_func)(u8, u8, union uw_ec_read_return *); +typedef u32 (uw_ec_write_func)(u8, u8, u8, u8, union uw_ec_write_return *); + +extern uw_ec_read_func uw_ec_read_addr; +extern uw_ec_write_func uw_ec_write_addr; struct tuxedo_keyboard_driver uniwill_keyboard_driver; +struct kbd_led_state_uw_t { + u32 brightness; + u32 color; +} kbd_led_state_uw = { + .brightness = UNIWILL_BRIGHTNESS_DEFAULT, + .color = UNIWILL_COLOR_DEFAULT, +}; + +static u8 uniwill_kbd_bl_enable_state_on_start; +static bool uniwill_kbd_bl_type_rgb_single_color = true; + static struct key_entry uniwill_wmi_keymap[] = { // { KE_KEY, UNIWILL_OSD_RADIOON, { KEY_RFKILL } }, // { KE_KEY, UNIWILL_OSD_RADIOOFF, { KEY_RFKILL } }, @@ -95,6 +136,152 @@ static struct notifier_block keyboard_notifier_block = { .notifier_call = keyboard_notifier_callb }; +static u8 uniwill_read_kbd_bl_enabled(void) +{ + union uw_ec_read_return reg_read_return; + + uw_ec_read_func *__uw_ec_read_addr; + + u8 enabled = 0xff; + + __uw_ec_read_addr = symbol_get(uw_ec_read_addr); + + if (__uw_ec_read_addr) { + __uw_ec_read_addr(0x8c, 0x07, ®_read_return); + enabled = (reg_read_return.bytes.data_low >> 1) & 0x01; + enabled = !enabled; + } else { + TUXEDO_DEBUG("tuxedo-cc-wmi symbols not found\n"); + } + + if (__uw_ec_read_addr) symbol_put(uw_ec_read_addr); + + return enabled; +} + +static void uniwill_write_kbd_bl_enable(u8 enable) +{ + union uw_ec_read_return reg_read_return; + union uw_ec_write_return reg_write_return; + + uw_ec_read_func *__uw_ec_read_addr; + uw_ec_write_func *__uw_ec_write_addr; + + u8 write_value = 0; + enable = enable & 0x01; + + __uw_ec_read_addr = symbol_get(uw_ec_read_addr); + __uw_ec_write_addr = symbol_get(uw_ec_write_addr); + + if (__uw_ec_read_addr && __uw_ec_write_addr) { + __uw_ec_read_addr(0x8c, 0x07, ®_read_return); + write_value = reg_read_return.bytes.data_low & ~(1 << 1); + write_value |= (!enable << 1); + __uw_ec_write_addr(0x8c, 0x07, write_value, 0x00, ®_write_return); + } else { + TUXEDO_DEBUG("tuxedo-cc-wmi symbols not found\n"); + } + + if (__uw_ec_read_addr) symbol_put(uw_ec_read_addr); + if (__uw_ec_write_addr) symbol_put(uw_ec_write_addr); +} + +/*static u32 uniwill_read_kbd_bl_br_state(u8 *brightness_state) +{ + union uw_ec_read_return reg_read_return; + u32 result; + + uw_ec_read_func *__uw_ec_read_addr; + + __uw_ec_read_addr = symbol_get(uw_ec_read_addr); + + if (__uw_ec_read_addr) { + __uw_ec_read_addr(0x8c, 0x07, ®_read_return); + *brightness_state = (reg_read_return.bytes.data_low & 0xf0) >> 4; + result = 0; + } else { + TUXEDO_DEBUG("tuxedo-cc-wmi symbols not found\n"); + result = -EIO; + } + + return result; +}*/ + +static u32 uniwill_read_kbd_bl_rgb(u8 *red, u8 *green, u8 *blue) +{ + union uw_ec_read_return reg_read_return; + u32 result; + + uw_ec_read_func *__uw_ec_read_addr; + + __uw_ec_read_addr = symbol_get(uw_ec_read_addr); + + if (__uw_ec_read_addr) { + __uw_ec_read_addr(0x03, 0x18, ®_read_return); + *red = reg_read_return.bytes.data_low; + __uw_ec_read_addr(0x05, 0x18, ®_read_return); + *green = reg_read_return.bytes.data_low; + __uw_ec_read_addr(0x08, 0x18, ®_read_return); + *blue = reg_read_return.bytes.data_low; + result = 0; + } else { + TUXEDO_DEBUG("tuxedo-cc-wmi symbols not found\n"); + result = -EIO; + } + + if (__uw_ec_read_addr) symbol_put(uw_ec_read_addr); + + return result; +} + +static void uniwill_write_kbd_bl_rgb(u8 red, u8 green, u8 blue) +{ + union uw_ec_write_return reg_write_return; + + uw_ec_read_func *__uw_ec_read_addr; + uw_ec_write_func *__uw_ec_write_addr; + + __uw_ec_read_addr = symbol_get(uw_ec_read_addr); + __uw_ec_write_addr = symbol_get(uw_ec_write_addr); + + if (__uw_ec_read_addr && __uw_ec_write_addr) { + // Write the colors + if (red > 0xc8) red = 0xc8; + if (green > 0xc8) green = 0xc8; + if (blue > 0xc8) blue = 0xc8; + __uw_ec_write_addr(0x03, 0x18, red, 0x00, ®_write_return); + __uw_ec_write_addr(0x05, 0x18, green, 0x00, ®_write_return); + __uw_ec_write_addr(0x08, 0x18, blue, 0x00, ®_write_return); + TUXEDO_DEBUG("Wrote color [%0#4x, %0#4x, %0#4x]\n", red, green, blue); + } else { + TUXEDO_DEBUG("tuxedo-cc-wmi symbols not found\n"); + } + + if (__uw_ec_read_addr) symbol_put(uw_ec_read_addr); + if (__uw_ec_write_addr) symbol_put(uw_ec_write_addr); +} + +static void uniwill_write_kbd_bl_state(void) { + // Get single colors from state + u32 color_red = ((kbd_led_state_uw.color >> 0x10) & 0xff); + u32 color_green = (kbd_led_state_uw.color >> 0x08) & 0xff; + u32 color_blue = (kbd_led_state_uw.color >> 0x00) & 0xff; + + u32 brightness_percentage = (kbd_led_state_uw.brightness * 100) / UNIWILL_BRIGHTNESS_MAX; + + // Scale color values to valid range + color_red = (color_red * 0xc8) / 0xff; + color_green = (color_green * 0xc8) / 0xff; + color_blue = (color_blue * 0xc8) / 0xff; + + // Scale the respective color values with brightness + color_red = (color_red * brightness_percentage) / 100; + color_green = (color_green * brightness_percentage) / 100; + color_blue = (color_blue * brightness_percentage) / 100; + + uniwill_write_kbd_bl_rgb(color_red, color_green, color_blue); +} + static void uniwill_wmi_handle_event(u32 value, void *context, u32 guid_nr) { struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; @@ -110,22 +297,52 @@ static void uniwill_wmi_handle_event(u32 value, void *context, u32 guid_nr) } obj = (union acpi_object *) response.pointer; - if (obj && obj->type == ACPI_TYPE_INTEGER) { - code = obj->integer.value; - if (!sparse_keymap_report_known_event(current_driver->input_device, code, 1, true)) { - TUXEDO_DEBUG("[Ev %d] Unknown key - %d (%0#6x)\n", guid_nr, code, code); - } + if (obj) { + if (obj->type == ACPI_TYPE_INTEGER) { + code = obj->integer.value; + if (!sparse_keymap_report_known_event(current_driver->input_device, code, 1, true)) { + TUXEDO_DEBUG("[Ev %d] Unknown key - %d (%0#6x)\n", guid_nr, code, code); + } - // Special key combination when mode change key is pressed - if (code == 0xb0) { - input_report_key(current_driver->input_device, KEY_LEFTMETA, 1); - input_report_key(current_driver->input_device, KEY_LEFTALT, 1); - input_report_key(current_driver->input_device, KEY_F6, 1); - input_sync(current_driver->input_device); - input_report_key(current_driver->input_device, KEY_F6, 0); - input_report_key(current_driver->input_device, KEY_LEFTALT, 0); - input_report_key(current_driver->input_device, KEY_LEFTMETA, 0); - input_sync(current_driver->input_device); + // Special key combination when mode change key is pressed + if (code == 0xb0) { + input_report_key(current_driver->input_device, KEY_LEFTMETA, 1); + input_report_key(current_driver->input_device, KEY_LEFTALT, 1); + input_report_key(current_driver->input_device, KEY_F6, 1); + input_sync(current_driver->input_device); + input_report_key(current_driver->input_device, KEY_F6, 0); + input_report_key(current_driver->input_device, KEY_LEFTALT, 0); + input_report_key(current_driver->input_device, KEY_LEFTMETA, 0); + input_sync(current_driver->input_device); + } + + // Keyboard backlight brightness toggle + if (uniwill_kbd_bl_type_rgb_single_color) { + switch (code) { + case 0x3b: + kbd_led_state_uw.brightness = 0x00; + uniwill_write_kbd_bl_state(); + break; + case 0x3c: + kbd_led_state_uw.brightness = 0x20; + uniwill_write_kbd_bl_state(); + break; + case 0x3d: + kbd_led_state_uw.brightness = 0x50; + uniwill_write_kbd_bl_state(); + break; + case 0x3e: + kbd_led_state_uw.brightness = 0x80; + uniwill_write_kbd_bl_state(); + break; + case 0x3f: + kbd_led_state_uw.brightness = 0xc8; + uniwill_write_kbd_bl_state(); + break; + } + } + } else { + TUXEDO_DEBUG("[Ev %d] Unknown event type - %d (%0#6x)\n", guid_nr, obj->type, obj->type); } } @@ -147,6 +364,169 @@ static void uniwill_wmi_notify2(u32 value, void *context) uniwill_wmi_handle_event(value, context, 2); } +static ssize_t uw_brightness_show(struct device *child, + struct device_attribute *attr, char *buffer) +{ + return sprintf(buffer, "%d\n", kbd_led_state_uw.brightness); +} + +static ssize_t uw_brightness_store(struct device *child, + struct device_attribute *attr, + const char *buffer, size_t size) +{ + u32 brightness_input; + int err = kstrtouint(buffer, 0, &brightness_input); + if (err) return err; + if (brightness_input > UNIWILL_BRIGHTNESS_MAX) return -EINVAL; + kbd_led_state_uw.brightness = (u8)brightness_input; + uniwill_write_kbd_bl_state(); + return size; +} + +static ssize_t uw_color_string_show(struct device *child, + struct device_attribute *attr, char *buffer) +{ + int i; + sprintf(buffer, "Color values:"); + for (i = 0; i < color_list.size; ++i) { + sprintf(buffer + strlen(buffer), " %s", + color_list.colors[i].name); + } + sprintf(buffer + strlen(buffer), "\n"); + return strlen(buffer); +} + +static ssize_t uw_color_string_store(struct device *child, + struct device_attribute *attr, + const char *buffer, size_t size) +{ + u32 color_value; + char *buffer_copy; + + buffer_copy = kmalloc(size + 1, GFP_KERNEL); + strcpy(buffer_copy, buffer); + color_value = color_lookup(&color_list, strstrip(buffer_copy)); + kfree(buffer_copy); + + if (color_value > 0xffffff) return -EINVAL; + kbd_led_state_uw.color = color_value; + uniwill_write_kbd_bl_state(); + return size; +} + +// Device attributes used by uw kbd +struct uw_kbd_dev_attrs_t { + struct device_attribute brightness; + struct device_attribute color_string; +} uw_kbd_dev_attrs = { + .brightness = __ATTR(brightness, 0644, uw_brightness_show, uw_brightness_store), + .color_string = __ATTR(color_string, 0644, uw_color_string_show, uw_color_string_store) +}; + +// Device attributes used for uw_kbd_bl_color +static struct attribute *uw_kbd_bl_color_attrs[] = { + &uw_kbd_dev_attrs.brightness.attr, + &uw_kbd_dev_attrs.color_string.attr, + NULL +}; + +static struct attribute_group uw_kbd_bl_color_attr_group = { + .name = "uw_kbd_bl_color", + .attrs = uw_kbd_bl_color_attrs +}; + +static void uw_kbd_bl_init_set(void) +{ + if (uniwill_kbd_bl_type_rgb_single_color) { + // Disable backlight while initializing + // uniwill_write_kbd_bl_enable(0); + + // Update keyboard backlight according to the current state + uniwill_write_kbd_bl_state(); + } + + // Enable keyboard backlight + uniwill_write_kbd_bl_enable(1); +} + +// Keep track of previous colors on start, init array with different non-colors +static u32 uw_prev_colors[] = {0x01000000, 0x02000000, 0x03000000}; +static u32 uw_prev_colors_size = 3; +static u32 uw_prev_colors_index = 0; + +// Timer for checking animation colors +static struct timer_list uw_kbd_bl_init_timer; +static volatile int uw_kbd_bl_check_count = 40; +static int uw_kbd_bl_init_check_interval_ms = 500; + +static void uw_kbd_bl_init_ready_check_work_func(struct work_struct *work) +{ + u8 uw_cur_red, uw_cur_green, uw_cur_blue; + int i; + bool prev_colors_same; + uniwill_read_kbd_bl_rgb(&uw_cur_red, &uw_cur_green, &uw_cur_blue); + uw_prev_colors[uw_prev_colors_index] = (uw_cur_red << 0x10) | (uw_cur_green << 0x08) | uw_cur_blue; + uw_prev_colors_index = (uw_prev_colors_index + 1) % uw_prev_colors_size; + + prev_colors_same = true; + for (i = 1; i < uw_prev_colors_size; ++i) { + if (uw_prev_colors[i-1] != uw_prev_colors[i]) prev_colors_same = false; + } + + if (prev_colors_same) { + uw_kbd_bl_init_set(); + del_timer(&uw_kbd_bl_init_timer); + } else { + if (uw_kbd_bl_check_count != 0) { + mod_timer(&uw_kbd_bl_init_timer, jiffies + msecs_to_jiffies(uw_kbd_bl_init_check_interval_ms)); + } else { + TUXEDO_INFO("uw kbd init timeout, failed to detect end of boot animation\n"); + del_timer(&uw_kbd_bl_init_timer); + } + } + + uw_kbd_bl_check_count -= 1; +} + +static DECLARE_WORK(uw_kbd_bl_init_ready_check_work, uw_kbd_bl_init_ready_check_work_func); + +static void uw_kbd_bl_init_ready_check(struct timer_list *t) +{ + schedule_work(&uw_kbd_bl_init_ready_check_work); +} + +static int uw_kbd_bl_init(struct platform_device *dev) +{ + int status = 0; + + uniwill_kbd_bl_type_rgb_single_color = dmi_match(DMI_BOARD_NAME, "Polaris15I01"); + + // Save previous enable state + uniwill_kbd_bl_enable_state_on_start = uniwill_read_kbd_bl_enabled(); + + if (uniwill_kbd_bl_type_rgb_single_color) { + // Initialize keyboard backlight driver state according to parameters + if (param_brightness > UNIWILL_BRIGHTNESS_MAX) param_brightness = UNIWILL_BRIGHTNESS_DEFAULT; + kbd_led_state_uw.brightness = param_brightness; + if (color_lookup(&color_list, param_color) <= (u32) 0xffffff) kbd_led_state_uw.color = color_lookup(&color_list, param_color); + else kbd_led_state_uw.color = UNIWILL_COLOR_DEFAULT; + + // Init sysfs bl attributes group + status = sysfs_create_group(&dev->dev.kobj, &uw_kbd_bl_color_attr_group); + if (status) TUXEDO_ERROR("Failed to create sysfs group\n"); + + // Start periodic checking of animation, set and enable bl when done + timer_setup(&uw_kbd_bl_init_timer, uw_kbd_bl_init_ready_check, 0); + mod_timer(&uw_kbd_bl_init_timer, jiffies + msecs_to_jiffies(uw_kbd_bl_init_check_interval_ms)); + } else { + // For non-RGB versions + // Enable keyboard backlight immediately (should it be disabled) + uniwill_write_kbd_bl_enable(1); + } + + return status; +} + static int uniwill_keyboard_probe(struct platform_device *dev) { int status; @@ -186,6 +566,8 @@ static int uniwill_keyboard_probe(struct platform_device *dev) status = register_keyboard_notifier(&keyboard_notifier_block); + uw_kbd_bl_init(dev); + return 0; err_remove_notifiers: @@ -198,21 +580,34 @@ err_remove_notifiers: static int uniwill_keyboard_remove(struct platform_device *dev) { + // Restore previous backlight enable state + if (uniwill_kbd_bl_enable_state_on_start != 0xff) { + sysfs_remove_group(&dev->dev.kobj, &uw_kbd_bl_color_attr_group); + uniwill_write_kbd_bl_enable(uniwill_kbd_bl_enable_state_on_start); + } + unregister_keyboard_notifier(&keyboard_notifier_block); wmi_remove_notify_handler(UNIWILL_WMI_EVENT_GUID_0); wmi_remove_notify_handler(UNIWILL_WMI_EVENT_GUID_1); wmi_remove_notify_handler(UNIWILL_WMI_EVENT_GUID_2); + del_timer(&uw_kbd_bl_init_timer); + return 0; } static int uniwill_keyboard_suspend(struct platform_device *dev, pm_message_t state) { + uniwill_write_kbd_bl_enable(0); return 0; } static int uniwill_keyboard_resume(struct platform_device *dev) { + if (uniwill_kbd_bl_type_rgb_single_color) { + uniwill_write_kbd_bl_state(); + } + uniwill_write_kbd_bl_enable(1); return 0; }