Merge branch 'uniwill-rgb-backlight' into polaris-device-support

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
+#define KB_COLOR_DEFAULT		0xFFFFFF // White
-   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 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, &param_ops_mode_ops, &param_blinking_pattern, S_IRUSR);
 MODULE_PARM_DESC(mode, "Set the keyboard backlight blinking pattern");
 
-static ushort param_brightness = BRIGHTNESS_DEFAULT;
-module_param_cb(brightness, &param_ops_brightness_ops, &param_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);
 

src/tuxedo_keyboard.c

@@ -20,13 +20,6 @@
 
 #define pr_fmt(fmt) "tuxedo_keyboard" ": " fmt
 
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/acpi.h>
-#include <linux/dmi.h>
-#include <linux/platform_device.h>
-#include <linux/input.h>
-#include <linux/input/sparse-keymap.h>
 #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

src/tuxedo_keyboard_common.h

@@ -21,6 +21,11 @@
 #define TUXEDO_KEYBOARD_COMMON_H
 
 #include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/acpi.h>
+#include <linux/dmi.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
 
 /* ::::  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, &param_ops_brightness_ops, &param_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

src/uniwill_keyboard.h

@@ -22,6 +22,7 @@
 #include <linux/wmi.h>
 #include <linux/workqueue.h>
 #include <linux/keyboard.h>
+#include <linux/timer.h>
 
 #define UNIWILL_WMI_MGMT_GUID_BA "ABBC0F6D-8EA1-11D1-00A0-C90629100000"
 #define UNIWILL_WMI_MGMT_GUID_BB "ABBC0F6E-8EA1-11D1-00A0-C90629100000"
@@ -36,8 +37,48 @@
 
 #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, &reg_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, &reg_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, &reg_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, &reg_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, &reg_read_return);
+		*red = reg_read_return.bytes.data_low;
+		__uw_ec_read_addr(0x05, 0x18, &reg_read_return);
+		*green = reg_read_return.bytes.data_low;
+		__uw_ec_read_addr(0x08, 0x18, &reg_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, &reg_write_return);
+		__uw_ec_write_addr(0x05, 0x18, green, 0x00, &reg_write_return);
+		__uw_ec_write_addr(0x08, 0x18, blue, 0x00, &reg_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,7 +297,8 @@ 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) {
+	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);
@@ -127,6 +315,35 @@ static void uniwill_wmi_handle_event(u32 value, void *context, u32 guid_nr)
 				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);
+		}
 	}
 
 	kfree(obj);
@@ -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;
 }