mirrors/clevo-keyboard
mirrors/clevo-keyboard
1
0
Fork 0
mirror of https://github.com/wessel-novacustom/clevo-keyboard.git synced 2024-11-15 03:34:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rework to switch from old platform sysfs interface to standardised leds sysfs interface

Browse source
This commit is contained in:
Werner Sembach 2022-08-24 10:57:20 +02:00
parent ca72360c7d
commit dbd467bcd4
7 changed files with 431 additions and 715 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Makefile
View file

@ -16,12 +16,14 @@
# You should have received a copy of the GNU General Public License
# along with this software. If not, see <https://www.gnu.org/licenses/>.
#
obj-m := ./src/tuxedo_keyboard.o \
obj-m := tuxedo_keyboard.o \
./src/clevo_wmi.o \
./src/clevo_acpi.o \
./src/tuxedo_io/tuxedo_io.o \
./src/uniwill_wmi.o
tuxedo_keyboard-y := ./src/tuxedo_keyboard.o ./src/clevo_leds.o
PWD := $(shell pwd)
KDIR := /lib/modules/$(shell uname -r)/build

14
src/clevo_interfaces.h
View file

@ -38,6 +38,10 @@
#define CLEVO_CMD_GET_FLIGHTMODE_SW 0x07
#define CLEVO_CMD_GET_TOUCHPAD_SW 0x09
#define CLEVO_CMD_GET_EVENT 0x01
#define CLEVO_CMD_GET_SPECS 0x0D // Returns buffer -> only works with clevo_evaluate_method2
// The clevo set commands expect a parameter
#define CLEVO_CMD_SET_FANSPEED_VALUE 0x68
#define CLEVO_CMD_SET_FANSPEED_AUTO 0x69
@ -46,6 +50,16 @@
#define CLEVO_CMD_SET_FLIGHTMODE_SW 0x20
#define CLEVO_CMD_SET_TOUCHPAD_SW 0x2a
#define CLEVO_CMD_SET_KB_LEDS 0x67 // used to set color, brightness, blinking pattern, etc.
#define CLEVO_CMD_SET_EVENTS_ENABLED 0x46
#define CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_0 0xF0000000 // 1-zone RGB and 3-zone RGB left
#define CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_1 0xF1000000 // 3-zone RGB center
#define CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_2 0xF2000000 // 3-Zone RGB right
#define CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_3 0xF3000000 // Unused on all known Clevo devices
#define CLEVO_CMD_SET_KB_LEDS_SUB_BRIGHTNESS 0xF4000000
#define CLEVO_CMD_OPT 0x79
#define CLEVO_OPT_SUBCMD_SET_PERF_PROF 0x19

800
src/clevo_keyboard.h
View file

@ -21,45 +21,23 @@
#include "tuxedo_keyboard_common.h"
#include "clevo_interfaces.h"
#include <linux/leds.h>
#include <linux/led-class-multicolor.h>
#define BRIGHTNESS_MIN 0
#define BRIGHTNESS_MAX 255
#define BRIGHTNESS_DEFAULT BRIGHTNESS_MAX
#define REGION_LEFT 0xF0000000
#define REGION_CENTER 0xF1000000
#define REGION_RIGHT 0xF2000000
#define REGION_EXTRA 0xF3000000
#define KEYBOARD_BRIGHTNESS 0xF4000000
#define KB_COLOR_DEFAULT 0xFFFFFF // White
#define DEFAULT_BLINKING_PATTERN 0
// Submethod IDs for the CLEVO_GET interface method
#define CLEVO_METHOD_ID_GET_EVENT 0x01
#define CLEVO_METHOD_ID_GET_AP 0x46
#define CLEVO_METHOD_ID_SET_KB_LEDS 0x67 /* used to set color, brightness,
blinking pattern, etc. */
#define CLEVO_METHOD_ID_GET_SPECS 0x0D // only works with clevo_evaluate_method2
#include "clevo_leds.h"
// Clevo event codes
#define CLEVO_EVENT_DECREASE_BACKLIGHT 0x81
#define CLEVO_EVENT_INCREASE_BACKLIGHT 0x82
#define CLEVO_EVENT_NEXT_BLINKING_PATTERN 0x83
#define CLEVO_EVENT_TOGGLE_STATE 0x9F
#define CLEVO_EVENT_KB_LEDS_DECREASE 0x81
#define CLEVO_EVENT_KB_LEDS_INCREASE 0x82
#define CLEVO_EVENT_KB_LEDS_CYCLE_MODE 0x83
#define CLEVO_EVENT_KB_LEDS_CYCLE_BRIGHTNESS 0x8A
#define CLEVO_EVENT_KB_LEDS_TOGGLE 0x9F
#define CLEVO_EVENT_CYCLE_BRIGHTNESS 0x8A
#define CLEVO_EVENT_TOUCHPAD_TOGGLE 0x5D
#define CLEVO_EVENT_TOUCHPAD_OFF 0xFC
#define CLEVO_EVENT_TOUCHPAD_ON 0xFD
#define CLEVO_EVENT_TOUCHPAD_TOGGLE 0x5D
#define CLEVO_EVENT_TOUCHPAD_OFF 0xFC
#define CLEVO_EVENT_TOUCHPAD_ON 0xFD
#define CLEVO_EVENT_RFKILL1 0x85
#define CLEVO_EVENT_RFKILL2 0x86
#define CLEVO_EVENT_RFKILL1 0x85
#define CLEVO_EVENT_RFKILL2 0x86
#define CLEVO_KB_MODE_DEFAULT 0 // "CUSTOM"/Static Color
struct tuxedo_keyboard_driver clevo_keyboard_driver;
@ -68,18 +46,9 @@ static struct clevo_interfaces_t {
struct clevo_interface_t *acpi;
} clevo_interfaces;
enum clevo_kb_backlight_type {
CLEVO_KB_BACKLIGHT_TYPE_NONE = 0x00,
CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR = 0x01,
CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB = 0x02,
CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB = 0x06,
CLEVO_KB_BACKLIGHT_TYPE_PER_KEY_RGB = 0xf3
};
struct clevo_interface_t *active_clevo_interface;
void clevo_keyboard_write_state(void);
void clevo_keyboard_event_callb(u32 event);
void clevo_keyboard_event_callb(u32 event); // TODO Reorder to not require forward declaration?
static DEFINE_MUTEX(clevo_keyboard_interface_modification_lock);
@ -94,7 +63,7 @@ u32 clevo_keyboard_add_interface(struct clevo_interface_t *new_interface)
// Only use wmi if there is no other current interface
if (ZERO_OR_NULL_PTR(active_clevo_interface)) {
pr_debug("enable wmi events\n");
clevo_interfaces.wmi->method_call(0x46, 0, NULL);
clevo_interfaces.wmi->method_call(CLEVO_CMD_SET_EVENTS_ENABLED, 0, NULL);
active_clevo_interface = clevo_interfaces.wmi;
}
@ -104,7 +73,7 @@ u32 clevo_keyboard_add_interface(struct clevo_interface_t *new_interface)
clevo_interfaces.acpi->event_callb = clevo_keyboard_event_callb;
pr_debug("enable acpi events (takes priority)\n");
clevo_interfaces.acpi->method_call(0x46, 0, NULL);
clevo_interfaces.acpi->method_call(CLEVO_CMD_SET_EVENTS_ENABLED, 0, NULL);
active_clevo_interface = clevo_interfaces.acpi;
} else {
// Not recognized interface
@ -149,12 +118,12 @@ EXPORT_SYMBOL(clevo_keyboard_remove_interface);
static struct key_entry clevo_keymap[] = {
// Keyboard backlight (RGB versions)
{ KE_KEY, CLEVO_EVENT_DECREASE_BACKLIGHT, { KEY_KBDILLUMDOWN } },
{ KE_KEY, CLEVO_EVENT_INCREASE_BACKLIGHT, { KEY_KBDILLUMUP } },
{ KE_KEY, CLEVO_EVENT_TOGGLE_STATE, { KEY_KBDILLUMTOGGLE } },
{ KE_KEY, CLEVO_EVENT_NEXT_BLINKING_PATTERN, { KEY_LIGHTS_TOGGLE } },
{ KE_KEY, CLEVO_EVENT_KB_LEDS_DECREASE, { KEY_KBDILLUMDOWN } },
{ KE_KEY, CLEVO_EVENT_KB_LEDS_INCREASE, { KEY_KBDILLUMUP } },
{ KE_KEY, CLEVO_EVENT_KB_LEDS_TOGGLE, { KEY_KBDILLUMTOGGLE } },
{ KE_KEY, CLEVO_EVENT_KB_LEDS_CYCLE_MODE, { KEY_LIGHTS_TOGGLE } },
// Single cycle key (white only versions)
{ KE_KEY, CLEVO_EVENT_CYCLE_BRIGHTNESS, { KEY_KBDILLUMUP } },
{ KE_KEY, CLEVO_EVENT_KB_LEDS_CYCLE_BRIGHTNESS, { KEY_KBDILLUMTOGGLE } }, //FIXME Cycle in driver or toggle in desktop environment?
// Touchpad
// The weirdly named touchpad toggle key that is implemented as KEY_F21 "everywhere"
@ -183,23 +152,8 @@ static struct key_entry clevo_keymap[] = {
// Keyboard struct
struct kbd_led_state_t {
u8 has_left;
u8 has_center;
u8 has_right;
u8 has_extra;
u8 has_mode;
u8 has_brightness;
u8 enabled;
struct {
u32 left;
u32 center;
u32 right;
u32 extra;
} color;
u8 brightness;
u8 blinking_pattern;
u8 mode;
u8 whole_kbd_color;
};
@ -209,122 +163,28 @@ struct blinking_pattern_t {
const char *const name;
};
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 = {
.set = blinking_pattern_id_validator,
.get = param_get_int,
static struct blinking_pattern_t kbd_backlight_modes[] = {
{ .key = 0, .value = 0x00000000, .name = "CUSTOM"},
{ .key = 1, .value = 0x1002a000, .name = "BREATHE"},
{ .key = 2, .value = 0x33010000, .name = "CYCLE"},
{ .key = 3, .value = 0x80000000, .name = "DANCE"},
{ .key = 4, .value = 0xA0000000, .name = "FLASH"},
{ .key = 5, .value = 0x70000000, .name = "RANDOM_COLOR"},
{ .key = 6, .value = 0x90000000, .name = "TEMPO"},
{ .key = 7, .value = 0xB0000000, .name = "WAVE"}
};
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");
static uint param_color_center = KB_COLOR_DEFAULT;
module_param_named(color_center, param_color_center, uint, S_IRUSR);
MODULE_PARM_DESC(color_center, "Color for the Center Region");
static uint param_color_right = KB_COLOR_DEFAULT;
module_param_named(color_right, param_color_right, uint, S_IRUSR);
MODULE_PARM_DESC(color_right, "Color for the Right Region");
static uint param_color_extra = KB_COLOR_DEFAULT;
module_param_named(color_extra, param_color_extra, uint, S_IRUSR);
MODULE_PARM_DESC(color_extra, "Color for the Extra Region");
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 bool param_state = true;
module_param_named(state, param_state, bool, S_IRUSR);
MODULE_PARM_DESC(state,
"Set the State of the Keyboard TRUE = ON | FALSE = OFF");
static struct kbd_led_state_t kbd_led_state = {
.has_left = 0,
.has_center = 0,
.has_right = 0,
.has_extra = 0,
.has_mode = 0,
.has_brightness = 0,
.enabled = 1,
.color = {
.left = KB_COLOR_DEFAULT, .center = KB_COLOR_DEFAULT,
.right = KB_COLOR_DEFAULT, .extra = KB_COLOR_DEFAULT
},
.brightness = BRIGHTNESS_DEFAULT,
.blinking_pattern = DEFAULT_BLINKING_PATTERN,
.whole_kbd_color = 7
.has_mode = 1,
.mode = CLEVO_KB_MODE_DEFAULT,
.whole_kbd_color = 7,
};
static struct blinking_pattern_t blinking_patterns[] = {
{ .key = 0,.value = 0,.name = "CUSTOM"},
{ .key = 1,.value = 0x1002a000,.name = "BREATHE"},
{ .key = 2,.value = 0x33010000,.name = "CYCLE"},
{ .key = 3,.value = 0x80000000,.name = "DANCE"},
{ .key = 4,.value = 0xA0000000,.name = "FLASH"},
{ .key = 5,.value = 0x70000000,.name = "RANDOM_COLOR"},
{ .key = 6,.value = 0x90000000,.name = "TEMPO"},
{ .key = 7,.value = 0xB0000000,.name = "WAVE"}
};
// Sysfs Interface Methods
// Sysfs Interface for the keyboard state (ON / OFF)
static ssize_t show_state_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%d\n", kbd_led_state.enabled);
}
// Sysfs Interface for the color of the left side (Color as hexvalue)
static ssize_t show_color_left_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%06x\n", kbd_led_state.color.left);
}
// Sysfs Interface for the color of the center (Color as hexvalue)
static ssize_t show_color_center_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%06x\n", kbd_led_state.color.center);
}
// Sysfs Interface for the color of the right side (Color as hexvalue)
static ssize_t show_color_right_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%06x\n", kbd_led_state.color.right);
}
// Sysfs Interface for the color of the extra region (Color as hexvalue)
static ssize_t show_color_extra_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%06x\n", kbd_led_state.color.extra);
}
// Sysfs Interface for the keyboard brightness (unsigned int)
static ssize_t show_brightness_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%d\n", kbd_led_state.brightness);
}
// Sysfs Interface for the backlight blinking pattern
static ssize_t show_blinking_patterns_fs(struct device *child, struct device_attribute *attr,
static ssize_t show_kbd_backlight_modes_fs(struct device *child, struct device_attribute *attr,
char *buffer)
{
return sprintf(buffer, "%d\n", kbd_led_state.blinking_pattern);
}
// Sysfs Interface for if the keyboard has extra region
static ssize_t show_hasextra_fs(struct device *child,
struct device_attribute *attr, char *buffer)
{
return sprintf(buffer, "%d\n", kbd_led_state.has_extra);
return sprintf(buffer, "%d\n", kbd_led_state.mode);
}
u32 clevo_evaluate_method2(u8 cmd, u32 arg, union acpi_object **result)
@ -373,33 +233,6 @@ u32 clevo_get_active_interface_id(char **id_str)
}
EXPORT_SYMBOL(clevo_get_active_interface_id);
static void set_brightness(u8 brightness)
{
TUXEDO_INFO("Set brightness on %d", brightness);
if (!clevo_evaluate_method
(CLEVO_METHOD_ID_SET_KB_LEDS, 0xF4000000 | brightness, NULL)) {
kbd_led_state.brightness = brightness;
}
}
static ssize_t set_brightness_fs(struct device *child,
struct device_attribute *attr,
const char *buffer, size_t size)
{
unsigned int val;
// hier unsigned?
int err = kstrtouint(buffer, 0, &val);
if (err) {
return err;
}
val = clamp_t(u8, val, BRIGHTNESS_MIN, BRIGHTNESS_MAX);
set_brightness(val);
return size;
}
static int set_enabled_cmd(u8 state)
{
u32 cmd = 0xE0000000;
@ -411,126 +244,7 @@ static int set_enabled_cmd(u8 state)
cmd |= 0x07F001;
}
return clevo_evaluate_method(CLEVO_METHOD_ID_SET_KB_LEDS, cmd, NULL);
}
static void set_enabled(u8 state)
{
if (!set_enabled_cmd(state)) {
kbd_led_state.enabled = state;
}
}
static ssize_t set_state_fs(struct device *child, struct device_attribute *attr,
const char *buffer, size_t size)
{
unsigned int state;
int err = kstrtouint(buffer, 0, &state);
if (err) {
return err;
}
state = clamp_t(u8, state, 0, 1);
set_enabled(state);
return size;
}
static int set_color(u32 region, u32 color)
{
u32 cset =
((color & 0x0000FF) << 16) | ((color & 0xFF0000) >> 8) |
((color & 0x00FF00) >> 8);
u32 clevo_submethod_arg = region | cset;
TUXEDO_DEBUG("Set Color '%08x' for region '%08x'", color, region);
return clevo_evaluate_method(CLEVO_METHOD_ID_SET_KB_LEDS, clevo_submethod_arg, NULL);
}
static int set_color_code_region(u32 region, u32 colorcode)
{
int err;
if (0 == (err = set_color(region, colorcode))) {
// after succesfully setting color, update our state struct
// depending on which region was changed
switch (region) {
case REGION_LEFT:
kbd_led_state.color.left = colorcode;
break;
case REGION_CENTER:
kbd_led_state.color.center = colorcode;
break;
case REGION_RIGHT:
kbd_led_state.color.right = colorcode;
break;
case REGION_EXTRA:
kbd_led_state.color.extra = colorcode;
break;
}
}
return err;
}
static int set_color_string_region(const char *color_string, size_t size, u32 region)
{
u32 colorcode;
int err = kstrtouint(color_string, 0, &colorcode);
if (err) {
return err;
}
if (!set_color(region, colorcode)) {
// after succesfully setting color, update our state struct
// depending on which region was changed
switch (region) {
case REGION_LEFT:
kbd_led_state.color.left = colorcode;
break;
case REGION_CENTER:
kbd_led_state.color.center = colorcode;
break;
case REGION_RIGHT:
kbd_led_state.color.right = colorcode;
break;
case REGION_EXTRA:
kbd_led_state.color.extra = colorcode;
break;
}
}
return size;
}
static ssize_t set_color_left_fs(struct device *child,
struct device_attribute *attr,
const char *color_string, size_t size)
{
return set_color_string_region(color_string, size, REGION_LEFT);
}
static ssize_t set_color_center_fs(struct device *child,
struct device_attribute *attr,
const char *color_string, size_t size)
{
return set_color_string_region(color_string, size, REGION_CENTER);
}
static ssize_t set_color_right_fs(struct device *child,
struct device_attribute *attr,
const char *color_string, size_t size)
{
return set_color_string_region(color_string, size, REGION_RIGHT);
}
static ssize_t set_color_extra_fs(struct device *child,
struct device_attribute *attr,
const char *color_string, size_t size)
{
return set_color_string_region(color_string, size, REGION_EXTRA);
return clevo_evaluate_method(CLEVO_CMD_SET_KB_LEDS, cmd, NULL);
}
static int set_next_color_whole_kb(void)
@ -549,77 +263,71 @@ static int set_next_color_whole_kb(void)
new_color_id, new_color_code);
/* Set color on all four regions*/
set_color_code_region(REGION_LEFT, new_color_code);
set_color_code_region(REGION_CENTER, new_color_code);
set_color_code_region(REGION_RIGHT, new_color_code);
set_color_code_region(REGION_EXTRA, new_color_code);
clevo_leds_set_color_extern(new_color_code);
kbd_led_state.whole_kbd_color = new_color_id;
return 0;
}
static void set_blinking_pattern(u8 blinkling_pattern)
static void set_kbd_backlight_mode(u8 kbd_backlight_mode)
{
TUXEDO_INFO("set_mode on %s", blinking_patterns[blinkling_pattern].name);
TUXEDO_INFO("Set keyboard backlight mode on %s", kbd_backlight_modes[kbd_backlight_mode].name);
if (!clevo_evaluate_method(CLEVO_METHOD_ID_SET_KB_LEDS, blinking_patterns[blinkling_pattern].value, NULL)) {
if (!clevo_evaluate_method(CLEVO_CMD_SET_KB_LEDS, kbd_backlight_modes[kbd_backlight_mode].value, NULL)) {
// method was succesfull so update ur internal state struct
kbd_led_state.blinking_pattern = blinkling_pattern;
}
if (blinkling_pattern == 0) { // 0 is the "custom" blinking pattern
// so just set all regions to the stored colors
set_color(REGION_LEFT, kbd_led_state.color.left);
set_color(REGION_CENTER, kbd_led_state.color.center);
set_color(REGION_RIGHT, kbd_led_state.color.right);
if (kbd_led_state.has_extra == 1) {
set_color(REGION_EXTRA, kbd_led_state.color.extra);
}
kbd_led_state.mode = kbd_backlight_mode;
}
}
static ssize_t set_blinking_pattern_fs(struct device *child,
static ssize_t set_kbd_backlight_mode_fs(struct device *child,
struct device_attribute *attr,
const char *buffer, size_t size)
{
unsigned int blinking_pattern;
unsigned int kbd_backlight_mode;
int err = kstrtouint(buffer, 0, &blinking_pattern);
int err = kstrtouint(buffer, 0, &kbd_backlight_mode);
if (err) {
return err;
}
blinking_pattern = clamp_t(u8, blinking_pattern, 0, ARRAY_SIZE(blinking_patterns) - 1);
set_blinking_pattern(blinking_pattern);
kbd_backlight_mode = clamp_t(u8, kbd_backlight_mode, 0, ARRAY_SIZE(kbd_backlight_modes) - 1);
set_kbd_backlight_mode(kbd_backlight_mode);
return size;
}
static int blinking_pattern_id_validator(const char *value,
const struct kernel_param *blinking_pattern_param)
static int kbd_backlight_mode_id_validator(const char *value,
const struct kernel_param *kbd_backlight_mode_param)
{
int blinking_pattern = 0;
int kbd_backlight_mode = 0;
if (kstrtoint(value, 10, &blinking_pattern) != 0
|| blinking_pattern < 0
|| blinking_pattern > (ARRAY_SIZE(blinking_patterns) - 1)) {
if (kstrtoint(value, 10, &kbd_backlight_mode) != 0
|| kbd_backlight_mode < 0
|| kbd_backlight_mode > (ARRAY_SIZE(kbd_backlight_modes) - 1)) {
return -EINVAL;
}
return param_set_int(value, blinking_pattern_param);
return param_set_int(value, kbd_backlight_mode_param);
}
static const struct kernel_param_ops param_ops_mode_ops = {
.set = kbd_backlight_mode_id_validator,
.get = param_get_int,
};
static u8 param_kbd_backlight_mode = CLEVO_KB_MODE_DEFAULT;
module_param_cb(kbd_backlight_mode, &param_ops_mode_ops, &param_kbd_backlight_mode, S_IRUSR);
MODULE_PARM_DESC(kbd_backlight_mode, "Set the keyboard backlight blinking pattern");
// TODO remove
static int brightness_validator(const char *value,
const struct kernel_param *brightness_param)
{
int brightness = 0;
if (kstrtoint(value, 10, &brightness) != 0
|| brightness < BRIGHTNESS_MIN
|| brightness > BRIGHTNESS_MAX) {
|| brightness < 0
|| brightness > 255) {
return -EINVAL;
}
@ -630,338 +338,37 @@ void clevo_keyboard_event_callb(u32 event)
{
u32 key_event = event;
// TUXEDO_DEBUG("clevo event: %0#6x\n", event);
TUXEDO_DEBUG("Clevo event: %0#6x\n", event);
switch (key_event) {
case CLEVO_EVENT_DECREASE_BACKLIGHT:
if (kbd_led_state.brightness == BRIGHTNESS_MIN
|| (kbd_led_state.brightness - BRIGHTNESS_STEP) < BRIGHTNESS_MIN) {
set_brightness(BRIGHTNESS_MIN);
} else {
set_brightness(kbd_led_state.brightness - BRIGHTNESS_STEP);
}
break;
case CLEVO_EVENT_INCREASE_BACKLIGHT:
if (kbd_led_state.brightness == BRIGHTNESS_MAX
|| (kbd_led_state.brightness + BRIGHTNESS_STEP) > BRIGHTNESS_MAX) {
set_brightness(BRIGHTNESS_MAX);
} else {
set_brightness(kbd_led_state.brightness + BRIGHTNESS_STEP);
}
break;
// case CLEVO_EVENT_NEXT_BLINKING_PATTERN:
// set_blinking_pattern((kbd_led_state.blinking_pattern + 1) >
// (ARRAY_SIZE(blinking_patterns) - 1) ? 0 : (kbd_led_state.blinking_pattern + 1));
// break;
case CLEVO_EVENT_NEXT_BLINKING_PATTERN:
set_next_color_whole_kb();
break;
case CLEVO_EVENT_TOGGLE_STATE:
set_enabled(kbd_led_state.enabled == 0 ? 1 : 0);
break;
default:
break;
case CLEVO_EVENT_KB_LEDS_CYCLE_MODE:
set_next_color_whole_kb();
break;
default:
break;
}
if (current_driver != NULL && current_driver->input_device != NULL) {
if (!sparse_keymap_report_known_event(
current_driver->input_device, key_event, 1, true)) {
TUXEDO_DEBUG("Unknown key - %d (%0#6x)\n", key_event,
key_event);
if (!sparse_keymap_report_known_event(current_driver->input_device, key_event, 1, true)) {
TUXEDO_DEBUG("Unknown key - %d (%0#6x)\n", key_event, key_event);
}
}
}
// Sysfs attribute file permissions and method linking
static DEVICE_ATTR(state, 0644, show_state_fs, set_state_fs);
static DEVICE_ATTR(color_left, 0644, show_color_left_fs, set_color_left_fs);
static DEVICE_ATTR(color_center, 0644, show_color_center_fs,
set_color_center_fs);
static DEVICE_ATTR(color_right, 0644, show_color_right_fs, set_color_right_fs);
static DEVICE_ATTR(color_extra, 0644, show_color_extra_fs, set_color_extra_fs);
static DEVICE_ATTR(brightness, 0644, show_brightness_fs, set_brightness_fs);
static DEVICE_ATTR(mode, 0644, show_blinking_patterns_fs, set_blinking_pattern_fs);
static DEVICE_ATTR(extra, 0444, show_hasextra_fs, NULL);
static int ledcdev_set_blocking(struct led_classdev *led_cdev, enum led_brightness brightness) {
set_brightness(brightness);
return 0;
}
static int ledcdev_set_blocking_mc(struct led_classdev *led_cdev, enum led_brightness brightness) {
u32 region, colorcode;
struct led_classdev_mc *led_cdev_mc = lcdev_to_mccdev(led_cdev);
pr_debug("ledcdev_set_blocking_mc() brightness 0x%02x\n", brightness);
pr_debug("ledcdev_set_blocking_mc() led_cdev_mc->subled_info[0].intensity 0x%02x\n", led_cdev_mc->subled_info[0].intensity);
pr_debug("ledcdev_set_blocking_mc() led_cdev_mc->subled_info[1].intensity 0x%02x\n", led_cdev_mc->subled_info[1].intensity);
pr_debug("ledcdev_set_blocking_mc() led_cdev_mc->subled_info[2].intensity 0x%02x\n", led_cdev_mc->subled_info[2].intensity);
pr_debug("ledcdev_set_blocking_mc() led_cdev_mc->subled_info[0].channel 0x%02x\n", led_cdev_mc->subled_info[0].channel);
pr_debug("ledcdev_set_blocking_mc() led_cdev_mc->subled_info[1].channel 0x%02x\n", led_cdev_mc->subled_info[1].channel);
pr_debug("ledcdev_set_blocking_mc() led_cdev_mc->subled_info[2].channel 0x%02x\n", led_cdev_mc->subled_info[2].channel);
if (led_cdev_mc->subled_info[0].channel == 0) {
region = REGION_LEFT;
}
else if (led_cdev_mc->subled_info[0].channel == 1) {
region = REGION_CENTER;
}
else if (led_cdev_mc->subled_info[0].channel == 2) {
region = REGION_RIGHT;
}
else {
region = REGION_EXTRA;
}
colorcode = (led_cdev_mc->subled_info[0].intensity << 16) +
(led_cdev_mc->subled_info[1].intensity << 8) +
led_cdev_mc->subled_info[2].intensity;
if (!set_color(region, colorcode)) {
// after succesfully setting color, update our state struct
// depending on which region was changed
switch (region) {
case REGION_LEFT:
kbd_led_state.color.left = colorcode;
break;
case REGION_CENTER:
kbd_led_state.color.center = colorcode;
break;
case REGION_RIGHT:
kbd_led_state.color.right = colorcode;
break;
case REGION_EXTRA:
kbd_led_state.color.extra = colorcode;
break;
}
}
set_brightness(brightness);
return 0;
}
static enum led_brightness ledcdev_get(struct led_classdev *led_cdev) {
return kbd_led_state.brightness;
}
static struct led_classdev cdev_kb = {
.name = KBUILD_MODNAME "::kbd_backlight",
.max_brightness = BRIGHTNESS_MAX,
.brightness_set_blocking = &ledcdev_set_blocking,
.brightness_get = &ledcdev_get,
.brightness = BRIGHTNESS_DEFAULT,
};
static struct led_classdev_mc cdev_kb_mc[3];
static struct mc_subled cdev_kb_mc_subled[3][3];
static DEVICE_ATTR(kbd_backlight_mode, 0644, show_kbd_backlight_modes_fs, set_kbd_backlight_mode_fs);
static void clevo_keyboard_init_device_interface(struct platform_device *dev)
{
u32 status;
union acpi_object *result;
// The very first Clevos with keyboard backlight did have fixed color, but not yet the CLEVO_METHOD_ID_GET_SPECS. To
// not break these, we set this as default for the time being, better having an extra sysfs entry without function than
// a missing one. This is a temporary fix until we find a way to identify these early keyboard backlight devices.
enum clevo_kb_backlight_type kb_backlight_type = CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR;
status = clevo_evaluate_method2(CLEVO_METHOD_ID_GET_SPECS, 0, &result);
if (!status) {
if (result->type == ACPI_TYPE_BUFFER) {
pr_debug("CLEVO_METHOD_ID_GET_SPECS successful\n");
kb_backlight_type = result->buffer.pointer[0x0f];
}
else {
pr_debug("CLEVO_METHOD_ID_GET_SPECS return value has wrong type\n");
}
ACPI_FREE(result);
}
else {
pr_debug("CLEVO_METHOD_ID_GET_SPECS failed\n");
}
pr_debug("Keyboard Backlight Type: 0x%02x\n", kb_backlight_type);
// Setup sysfs
if (device_create_file(&dev->dev, &dev_attr_state) != 0) {
TUXEDO_ERROR("Sysfs attribute file creation failed for state\n");
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB ||
kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
if (device_create_file
(&dev->dev, &dev_attr_color_left) != 0) {
TUXEDO_ERROR
("Sysfs attribute file creation failed for color left\n");
}
else {
kbd_led_state.has_left = 1;
}
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
if (device_create_file
(&dev->dev, &dev_attr_color_center) != 0) {
TUXEDO_ERROR
("Sysfs attribute file creation failed for color center\n");
}
else {
kbd_led_state.has_center = 1;
}
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
if (device_create_file
(&dev->dev, &dev_attr_color_right) != 0) {
TUXEDO_ERROR
("Sysfs attribute file creation failed for color right\n");
}
else {
kbd_led_state.has_right = 1;
}
}
/*if (set_color(REGION_EXTRA, KB_COLOR_DEFAULT) != 0) {
TUXEDO_DEBUG("Keyboard does not support EXTRA Color");
kbd_led_state.has_extra = 0;
} else {
kbd_led_state.has_extra = 1;
if (device_create_file
(&dev->dev,
&dev_attr_color_extra) != 0) {
TUXEDO_ERROR
("Sysfs attribute file creation failed for color extra\n");
}
set_color(REGION_EXTRA, param_color_extra);
}*/
kbd_led_state.has_extra = 0; // No known Clevo device using this region, set color check doesn't work.
if (device_create_file(&dev->dev, &dev_attr_extra) !=
0) {
TUXEDO_ERROR
("Sysfs attribute file creation failed for extra information flag\n");
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
if (device_create_file(&dev->dev, &dev_attr_mode) !=
0) {
if (clevo_leds_get_backlight_type() == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
if (device_create_file(&dev->dev, &dev_attr_kbd_backlight_mode) != 0) {
TUXEDO_ERROR("Sysfs attribute file creation failed for blinking pattern\n");
}
else {
kbd_led_state.has_mode = 1;
}
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR ||
kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB ||
kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
if (device_create_file
(&dev->dev, &dev_attr_brightness) != 0) {
TUXEDO_ERROR
("Sysfs attribute file creation failed for brightness\n");
}
else {
kbd_led_state.has_brightness = 1;
}
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR) {
led_classdev_register(&dev->dev, &cdev_kb);
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB) {
cdev_kb_mc[0].led_cdev.name = KBUILD_MODNAME "::kbd_backlight";
cdev_kb_mc[0].led_cdev.max_brightness = BRIGHTNESS_MAX;
cdev_kb_mc[0].led_cdev.brightness_set_blocking = &ledcdev_set_blocking_mc;
cdev_kb_mc[0].led_cdev.brightness_get = &ledcdev_get;
cdev_kb_mc[0].led_cdev.brightness = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].num_colors = 3;
cdev_kb_mc[0].subled_info = cdev_kb_mc_subled[0];
cdev_kb_mc[0].subled_info[0].color_index = LED_COLOR_ID_RED;
cdev_kb_mc[0].subled_info[0].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].subled_info[0].channel = 0;
cdev_kb_mc[0].subled_info[1].color_index = LED_COLOR_ID_GREEN;
cdev_kb_mc[0].subled_info[1].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].subled_info[1].channel = 0;
cdev_kb_mc[0].subled_info[2].color_index = LED_COLOR_ID_BLUE;
cdev_kb_mc[0].subled_info[2].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].subled_info[2].channel = 0;
devm_led_classdev_multicolor_register(&dev->dev, &cdev_kb_mc[0]);
}
if (kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
cdev_kb_mc[0].led_cdev.name = KBUILD_MODNAME "::kbd_backlight";
cdev_kb_mc[0].led_cdev.max_brightness = BRIGHTNESS_MAX;
cdev_kb_mc[0].led_cdev.brightness_set_blocking = &ledcdev_set_blocking_mc;
cdev_kb_mc[0].led_cdev.brightness_get = &ledcdev_get;
cdev_kb_mc[0].led_cdev.brightness = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].num_colors = 3;
cdev_kb_mc[0].subled_info = cdev_kb_mc_subled[0];
cdev_kb_mc[0].subled_info[0].color_index = LED_COLOR_ID_RED;
cdev_kb_mc[0].subled_info[0].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].subled_info[0].channel = 0;
cdev_kb_mc[0].subled_info[1].color_index = LED_COLOR_ID_GREEN;
cdev_kb_mc[0].subled_info[1].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].subled_info[1].channel = 0;
cdev_kb_mc[0].subled_info[2].color_index = LED_COLOR_ID_BLUE;
cdev_kb_mc[0].subled_info[2].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[0].subled_info[2].channel = 0;
devm_led_classdev_multicolor_register(&dev->dev, &cdev_kb_mc[0]);
cdev_kb_mc[1].led_cdev.name = KBUILD_MODNAME "::kbd_backlight";
cdev_kb_mc[1].led_cdev.max_brightness = BRIGHTNESS_MAX;
cdev_kb_mc[1].led_cdev.brightness_set_blocking = &ledcdev_set_blocking_mc;
cdev_kb_mc[1].led_cdev.brightness_get = &ledcdev_get;
cdev_kb_mc[1].led_cdev.brightness = BRIGHTNESS_DEFAULT;
cdev_kb_mc[1].num_colors = 3;
cdev_kb_mc[1].subled_info = cdev_kb_mc_subled[1];
cdev_kb_mc[1].subled_info[0].color_index = LED_COLOR_ID_RED;
cdev_kb_mc[1].subled_info[0].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[1].subled_info[0].channel = 1;
cdev_kb_mc[1].subled_info[1].color_index = LED_COLOR_ID_GREEN;
cdev_kb_mc[1].subled_info[1].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[1].subled_info[1].channel = 1;
cdev_kb_mc[1].subled_info[2].color_index = LED_COLOR_ID_BLUE;
cdev_kb_mc[1].subled_info[2].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[1].subled_info[2].channel = 1;
devm_led_classdev_multicolor_register(&dev->dev, &cdev_kb_mc[1]);
cdev_kb_mc[2].led_cdev.name = KBUILD_MODNAME "::kbd_backlight";
cdev_kb_mc[2].led_cdev.max_brightness = BRIGHTNESS_MAX;
cdev_kb_mc[2].led_cdev.brightness_set_blocking = &ledcdev_set_blocking_mc;
cdev_kb_mc[2].led_cdev.brightness_get = &ledcdev_get;
cdev_kb_mc[2].led_cdev.brightness = BRIGHTNESS_DEFAULT;
cdev_kb_mc[2].num_colors = 3;
cdev_kb_mc[2].subled_info = cdev_kb_mc_subled[2];
cdev_kb_mc[2].subled_info[0].color_index = LED_COLOR_ID_RED;
cdev_kb_mc[2].subled_info[0].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[2].subled_info[0].channel = 2;
cdev_kb_mc[2].subled_info[1].color_index = LED_COLOR_ID_GREEN;
cdev_kb_mc[2].subled_info[1].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[2].subled_info[1].channel = 2;
cdev_kb_mc[2].subled_info[2].color_index = LED_COLOR_ID_BLUE;
cdev_kb_mc[2].subled_info[2].intensity = BRIGHTNESS_DEFAULT;
cdev_kb_mc[2].subled_info[2].channel = 2;
devm_led_classdev_multicolor_register(&dev->dev, &cdev_kb_mc[2]);
}
}
void clevo_keyboard_write_state(void)
{
// Note:
// - set_blinking_pattern also writes colors
// - set_brightness, set_enabled, set_blinking_pattern
// still also update state
set_blinking_pattern(kbd_led_state.blinking_pattern);
set_brightness(kbd_led_state.brightness);
set_enabled(kbd_led_state.enabled);
}
/**
@ -981,20 +388,11 @@ int clevo_keyboard_init(void)
{
bool performance_profile_set_workaround;
// Init state from params
kbd_led_state.color.left = param_color_left;
kbd_led_state.color.center = param_color_center;
kbd_led_state.color.right = param_color_right;
kbd_led_state.color.extra = param_color_extra;
kbd_led_state.mode = param_kbd_backlight_mode;
set_kbd_backlight_mode(kbd_led_state.mode);
kbd_led_state.blinking_pattern = param_blinking_pattern;
if (param_brightness > BRIGHTNESS_MAX) param_brightness = BRIGHTNESS_DEFAULT;
kbd_led_state.brightness = param_brightness;
kbd_led_state.enabled = param_state;
clevo_keyboard_write_state();
clevo_evaluate_method(CLEVO_CMD_SET_EVENTS_ENABLED, 0, NULL);
set_enabled_cmd(1);
// Workaround for firmware issue not setting selected performance profile.
// Explicitly set "performance" perf. profile on init regardless of what is chosen
@ -1013,7 +411,7 @@ int clevo_keyboard_init(void)
;
if (performance_profile_set_workaround) {
TUXEDO_INFO("Performance profile 'performance' set workaround applied\n");
clevo_evaluate_method(0x79, 0x19000002, NULL);
clevo_evaluate_method(CLEVO_CMD_OPT, 0x19000002, NULL);
}
return 0;
@ -1022,6 +420,7 @@ int clevo_keyboard_init(void)
static int clevo_keyboard_probe(struct platform_device *dev)
{
clevo_keyboard_init_device_interface(dev);
clevo_leds_init(dev);
clevo_keyboard_init();
return 0;
@ -1029,38 +428,15 @@ static int clevo_keyboard_probe(struct platform_device *dev)
static void clevo_keyboard_remove_device_interface(struct platform_device *dev)
{
device_remove_file(&dev->dev, &dev_attr_state);
if (kbd_led_state.has_left == 1) {
device_remove_file(&dev->dev, &dev_attr_color_left);
}
if (kbd_led_state.has_center == 1) {
device_remove_file(&dev->dev, &dev_attr_color_center);
}
if (kbd_led_state.has_right == 1) {
device_remove_file(&dev->dev, &dev_attr_color_right);
}
device_remove_file(&dev->dev, &dev_attr_extra);
if (kbd_led_state.has_mode == 1) {
device_remove_file(&dev->dev, &dev_attr_mode);
}
if (kbd_led_state.has_brightness == 1) {
device_remove_file(&dev->dev, &dev_attr_brightness);
}
if (kbd_led_state.has_extra == 1) {
device_remove_file(&dev->dev, &dev_attr_color_extra);
device_remove_file(&dev->dev, &dev_attr_kbd_backlight_mode);
}
}
static int clevo_keyboard_remove(struct platform_device *dev)
{
clevo_keyboard_remove_device_interface(dev);
clevo_leds_remove(dev);
return 0;
}
@ -1073,10 +449,8 @@ static int clevo_keyboard_suspend(struct platform_device *dev, pm_message_t stat
static int clevo_keyboard_resume(struct platform_device *dev)
{
clevo_evaluate_method(CLEVO_METHOD_ID_GET_AP, 0, NULL);
clevo_keyboard_write_state();
clevo_evaluate_method(CLEVO_CMD_SET_EVENTS_ENABLED, 0, NULL);
set_enabled_cmd(1);
return 0;
}

285
src/clevo_leds.c Normal file
View file

@ -0,0 +1,285 @@
/*!
* Copyright (c) 2018-2020 TUXEDO Computers GmbH <tux@tuxedocomputers.com>
*
* This file is part of tuxedo-keyboard.
*
* tuxedo-keyboard is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software. If not, see <https://www.gnu.org/licenses/>.
*/
#include "clevo_leds.h"
#include "clevo_interfaces.h"
#include <linux/leds.h>
#include <linux/led-class-multicolor.h>
#define CLEVO_KBD_BRIGHTNESS_MIN 0
#define CLEVO_KBD_BRIGHTNESS_MAX 255
#define CLEVO_KBD_BRIGHTNESS_DEFAULT (CLEVO_KBD_BRIGHTNESS_MAX * 0.5)
#define CLEVO_KB_COLOR_DEFAULT_RED 0xFF
#define CLEVO_KB_COLOR_DEFAULT_GREEN 0xFF
#define CLEVO_KB_COLOR_DEFAULT_BLUE 0xFF
#define CLEVO_KB_COLOR_DEFAULT ((CLEVO_KB_COLOR_DEFAULT_RED << 16) + (CLEVO_KB_COLOR_DEFAULT_GREEN << 8) + CLEVO_KB_COLOR_DEFAULT_BLUE)
// The very first Clevos with keyboard backlight did have fixed color, but not yet the CLEVO_METHOD_ID_GET_SPECS. To
// not break these, we set this as default for the time being, better having an extra sysfs entry without function than
// a missing one. This is a temporary fix until we find a way to identify these early keyboard backlight devices.
static enum clevo_kb_backlight_types clevo_kb_backlight_type = CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR;
static int clevo_evaluate_set_brightness(u8 brightness)
{
pr_debug("Set brightness on %d", brightness);
return clevo_evaluate_method (CLEVO_CMD_SET_KB_LEDS, 0xF4000000 | brightness, NULL);
}
static int clevo_evaluate_set_color(u32 zone, u32 color)
{
u32 cset = ((color & 0x0000FF) << 16) | ((color & 0xFF0000) >> 8) | ((color & 0x00FF00) >> 8);
u32 clevo_submethod_arg = zone | cset;
pr_debug("Set Color '%08x' for region '%08x'", color, zone);
return clevo_evaluate_method(CLEVO_CMD_SET_KB_LEDS, clevo_submethod_arg, NULL);
}
static void clevo_leds_set_brightness(struct led_classdev *led_cdev __always_unused, enum led_brightness brightness) {
int ret = clevo_evaluate_set_brightness(brightness);
if (ret) {
pr_debug("clevo_leds_set_brightness(): clevo_evaluate_set_brightness() failed");
return;
}
led_cdev->brightness = brightness;
}
static void clevo_leds_set_brightness_mc(struct led_classdev *led_cdev, enum led_brightness brightness) {
int ret;
u32 zone, color;
struct led_classdev_mc *mcled_cdev = lcdev_to_mccdev(led_cdev);
ret = clevo_evaluate_set_brightness(CLEVO_KBD_BRIGHTNESS_MAX);
if (ret) {
pr_debug("clevo_leds_set_brightness_mc(): clevo_evaluate_set_brightness() failed");
return;
}
zone = mcled_cdev->subled_info[0].channel;
led_mc_calc_color_components(mcled_cdev, brightness);
color = (mcled_cdev->subled_info[0].brightness << 16) +
(mcled_cdev->subled_info[1].brightness << 8) +
mcled_cdev->subled_info[2].brightness;
ret = clevo_evaluate_set_color(zone, color);
if (ret) {
pr_debug("clevo_leds_set_brightness_mc(): clevo_evaluate_set_color() failed");
return;
}
led_cdev->brightness = brightness;
}
static struct led_classdev clevo_led_cdev = {
.name = "rgb:kbd_backlight",
.max_brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.brightness_set = &clevo_leds_set_brightness,
.brightness = CLEVO_KBD_BRIGHTNESS_DEFAULT
};
static struct mc_subled clevo_mcled_cdevs_subleds[3][3] = {
{
{
.color_index = LED_COLOR_ID_RED,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_RED,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_0
},
{
.color_index = LED_COLOR_ID_GREEN,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_GREEN,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_0
},
{
.color_index = LED_COLOR_ID_BLUE,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_BLUE,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_0
}
},
{
{
.color_index = LED_COLOR_ID_RED,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_RED,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_1
},
{
.color_index = LED_COLOR_ID_GREEN,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_GREEN,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_1
},
{
.color_index = LED_COLOR_ID_BLUE,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_BLUE,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_1
}
},
{
{
.color_index = LED_COLOR_ID_RED,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_RED,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_2
},
{
.color_index = LED_COLOR_ID_GREEN,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_GREEN,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_2
},
{
.color_index = LED_COLOR_ID_BLUE,
.brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.intensity = CLEVO_KB_COLOR_DEFAULT_BLUE,
.channel = CLEVO_CMD_SET_KB_LEDS_SUB_RGB_ZONE_2
}
}
};
static struct led_classdev_mc clevo_mcled_cdevs[3] = {
{
.led_cdev.name = "rgb:kbd_backlight",
.led_cdev.max_brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.led_cdev.brightness_set = &clevo_leds_set_brightness_mc,
.led_cdev.brightness = CLEVO_KBD_BRIGHTNESS_DEFAULT,
.subled_info = clevo_mcled_cdevs_subleds[0]
},
{
.led_cdev.name = "rgb:kbd_backlight",
.led_cdev.max_brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.led_cdev.brightness_set = &clevo_leds_set_brightness_mc,
.led_cdev.brightness = CLEVO_KBD_BRIGHTNESS_DEFAULT,
.subled_info = clevo_mcled_cdevs_subleds[1]
},
{
.led_cdev.name = "rgb:kbd_backlight",
.led_cdev.max_brightness = CLEVO_KBD_BRIGHTNESS_MAX,
.led_cdev.brightness_set = &clevo_leds_set_brightness_mc,
.led_cdev.brightness = CLEVO_KBD_BRIGHTNESS_DEFAULT,
.subled_info = clevo_mcled_cdevs_subleds[2]
}
};
int clevo_leds_init(struct platform_device *dev)
{
u32 status;
union acpi_object *result;
status = clevo_evaluate_method2(CLEVO_CMD_GET_SPECS, 0, &result);
if (!status) {
if (result->type == ACPI_TYPE_BUFFER) {
pr_debug("CLEVO_CMD_GET_SPECS successful\n");
clevo_kb_backlight_type = result->buffer.pointer[0x0f];
}
else {
pr_debug("CLEVO_CMD_GET_SPECS return value has wrong type\n");
}
ACPI_FREE(result);
}
else {
pr_debug("CLEVO_CMD_GET_SPECS failed\n");
}
pr_debug("Keyboard backlight type: 0x%02x\n", clevo_kb_backlight_type);
if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR) {
led_classdev_register(&dev->dev, &clevo_led_cdev);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB) {
devm_led_classdev_multicolor_register(&dev->dev, &clevo_mcled_cdevs[0]);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
devm_led_classdev_multicolor_register(&dev->dev, &clevo_mcled_cdevs[0]);
devm_led_classdev_multicolor_register(&dev->dev, &clevo_mcled_cdevs[1]);
devm_led_classdev_multicolor_register(&dev->dev, &clevo_mcled_cdevs[2]);
}
return 0;
}
EXPORT_SYMBOL(clevo_leds_init);
int clevo_leds_remove(struct platform_device *dev) {
if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR) {
led_classdev_unregister(&clevo_led_cdev);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB) {
devm_led_classdev_multicolor_unregister(&dev->dev, &clevo_mcled_cdevs[0]);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
devm_led_classdev_multicolor_unregister(&dev->dev, &clevo_mcled_cdevs[0]);
devm_led_classdev_multicolor_unregister(&dev->dev, &clevo_mcled_cdevs[1]);
devm_led_classdev_multicolor_unregister(&dev->dev, &clevo_mcled_cdevs[2]);
}
return 0;
}
EXPORT_SYMBOL(clevo_leds_remove);
enum clevo_kb_backlight_types clevo_leds_get_backlight_type() {
return clevo_kb_backlight_type;
}
EXPORT_SYMBOL(clevo_leds_get_backlight_type);
void clevo_leds_set_brightness_extern(u32 brightness) {
if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR) {
clevo_led_cdev.brightness_set(&clevo_led_cdev, brightness);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB) {
clevo_mcled_cdevs[0].led_cdev.brightness_set(&clevo_mcled_cdevs[0].led_cdev, brightness);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
clevo_mcled_cdevs[0].led_cdev.brightness_set(&clevo_mcled_cdevs[0].led_cdev, brightness);
clevo_mcled_cdevs[1].led_cdev.brightness_set(&clevo_mcled_cdevs[1].led_cdev, brightness);
clevo_mcled_cdevs[2].led_cdev.brightness_set(&clevo_mcled_cdevs[2].led_cdev, brightness);
}
}
EXPORT_SYMBOL(clevo_leds_set_brightness_extern);
void clevo_leds_set_color_extern(u32 color) {
if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB) {
clevo_mcled_cdevs[0].subled_info[0].intensity = (color >> 16) & 0xff;
clevo_mcled_cdevs[0].subled_info[1].intensity = (color >> 8) & 0xff;
clevo_mcled_cdevs[0].subled_info[2].intensity = color & 0xff;
clevo_mcled_cdevs[0].led_cdev.brightness_set(&clevo_mcled_cdevs[0].led_cdev, clevo_mcled_cdevs[0].led_cdev.brightness);
}
else if (clevo_kb_backlight_type == CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB) {
clevo_mcled_cdevs[0].subled_info[0].intensity = (color >> 16) & 0xff;
clevo_mcled_cdevs[0].subled_info[1].intensity = (color >> 8) & 0xff;
clevo_mcled_cdevs[0].subled_info[2].intensity = color & 0xff;
clevo_mcled_cdevs[0].led_cdev.brightness_set(&clevo_mcled_cdevs[0].led_cdev, clevo_mcled_cdevs[0].led_cdev.brightness);
clevo_mcled_cdevs[1].subled_info[0].intensity = (color >> 16) & 0xff;
clevo_mcled_cdevs[1].subled_info[1].intensity = (color >> 8) & 0xff;
clevo_mcled_cdevs[1].subled_info[2].intensity = color & 0xff;
clevo_mcled_cdevs[1].led_cdev.brightness_set(&clevo_mcled_cdevs[1].led_cdev, clevo_mcled_cdevs[0].led_cdev.brightness);
clevo_mcled_cdevs[2].subled_info[0].intensity = (color >> 16) & 0xff;
clevo_mcled_cdevs[2].subled_info[1].intensity = (color >> 8) & 0xff;
clevo_mcled_cdevs[2].subled_info[2].intensity = color & 0xff;
clevo_mcled_cdevs[2].led_cdev.brightness_set(&clevo_mcled_cdevs[2].led_cdev, clevo_mcled_cdevs[0].led_cdev.brightness);
}
}
EXPORT_SYMBOL(clevo_leds_set_color_extern);
MODULE_LICENSE("GPL");

39
src/clevo_leds.h Normal file
View file

@ -0,0 +1,39 @@
/*!
* Copyright (c) 2018-2020 TUXEDO Computers GmbH <tux@tuxedocomputers.com>
*
* This file is part of tuxedo-keyboard.
*
* tuxedo-keyboard is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef CLEVO_LEDS_H
#define CLEVO_LEDS_H
#include <linux/platform_device.h>
enum clevo_kb_backlight_types {
CLEVO_KB_BACKLIGHT_TYPE_NONE = 0x00,
CLEVO_KB_BACKLIGHT_TYPE_FIXED_COLOR = 0x01,
CLEVO_KB_BACKLIGHT_TYPE_3_ZONE_RGB = 0x02,
CLEVO_KB_BACKLIGHT_TYPE_1_ZONE_RGB = 0x06,
CLEVO_KB_BACKLIGHT_TYPE_PER_KEY_RGB = 0xf3
};
int clevo_leds_init(struct platform_device *dev);
int clevo_leds_remove(struct platform_device *dev);
enum clevo_kb_backlight_types clevo_leds_get_backlight_type(void);
void clevo_leds_set_brightness_extern(u32 brightness);
void clevo_leds_set_color_extern(u32 color);
#endif // CLEVO_LEDS_H

3
src/tuxedo_keyboard_common.h
View file

@ -129,6 +129,7 @@ static const struct kernel_param_ops param_ops_brightness_ops = {
.get = param_get_int,
};
// TODO remove
static ushort param_brightness = 0xffff; // Default unset value (higher than max)
module_param_cb(brightness, &param_ops_brightness_ops, &param_brightness,
S_IRUSR);
@ -139,4 +140,4 @@ 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
#endif

1
src/uniwill_keyboard.h
View file

@ -27,6 +27,7 @@
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/leds.h>
#include <linux/led-class-multicolor.h>
#include <linux/string.h>
#include <linux/version.h>
#include "uniwill_interfaces.h"