mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
384 lines
8.7 KiB
384 lines
8.7 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* System76 ACPI Driver |
|
* |
|
* Copyright (C) 2019 System76 |
|
* |
|
* This program is free software; you can redistribute it and/or modify |
|
* it under the terms of the GNU General Public License version 2 as |
|
* published by the Free Software Foundation. |
|
*/ |
|
|
|
#include <linux/acpi.h> |
|
#include <linux/init.h> |
|
#include <linux/kernel.h> |
|
#include <linux/leds.h> |
|
#include <linux/module.h> |
|
#include <linux/pci_ids.h> |
|
#include <linux/types.h> |
|
|
|
struct system76_data { |
|
struct acpi_device *acpi_dev; |
|
struct led_classdev ap_led; |
|
struct led_classdev kb_led; |
|
enum led_brightness kb_brightness; |
|
enum led_brightness kb_toggle_brightness; |
|
int kb_color; |
|
}; |
|
|
|
static const struct acpi_device_id device_ids[] = { |
|
{"17761776", 0}, |
|
{"", 0}, |
|
}; |
|
MODULE_DEVICE_TABLE(acpi, device_ids); |
|
|
|
// Array of keyboard LED brightness levels |
|
static const enum led_brightness kb_levels[] = { |
|
48, |
|
72, |
|
96, |
|
144, |
|
192, |
|
255 |
|
}; |
|
|
|
// Array of keyboard LED colors in 24-bit RGB format |
|
static const int kb_colors[] = { |
|
0xFFFFFF, |
|
0x0000FF, |
|
0xFF0000, |
|
0xFF00FF, |
|
0x00FF00, |
|
0x00FFFF, |
|
0xFFFF00 |
|
}; |
|
|
|
// Get a System76 ACPI device value by name |
|
static int system76_get(struct system76_data *data, char *method) |
|
{ |
|
acpi_handle handle; |
|
acpi_status status; |
|
unsigned long long ret = 0; |
|
|
|
handle = acpi_device_handle(data->acpi_dev); |
|
status = acpi_evaluate_integer(handle, method, NULL, &ret); |
|
if (ACPI_SUCCESS(status)) |
|
return (int)ret; |
|
else |
|
return -1; |
|
} |
|
|
|
// Set a System76 ACPI device value by name |
|
static int system76_set(struct system76_data *data, char *method, int value) |
|
{ |
|
union acpi_object obj; |
|
struct acpi_object_list obj_list; |
|
acpi_handle handle; |
|
acpi_status status; |
|
|
|
obj.type = ACPI_TYPE_INTEGER; |
|
obj.integer.value = value; |
|
obj_list.count = 1; |
|
obj_list.pointer = &obj; |
|
handle = acpi_device_handle(data->acpi_dev); |
|
status = acpi_evaluate_object(handle, method, &obj_list, NULL); |
|
if (ACPI_SUCCESS(status)) |
|
return 0; |
|
else |
|
return -1; |
|
} |
|
|
|
// Get the airplane mode LED brightness |
|
static enum led_brightness ap_led_get(struct led_classdev *led) |
|
{ |
|
struct system76_data *data; |
|
int value; |
|
|
|
data = container_of(led, struct system76_data, ap_led); |
|
value = system76_get(data, "GAPL"); |
|
if (value > 0) |
|
return (enum led_brightness)value; |
|
else |
|
return LED_OFF; |
|
} |
|
|
|
// Set the airplane mode LED brightness |
|
static int ap_led_set(struct led_classdev *led, enum led_brightness value) |
|
{ |
|
struct system76_data *data; |
|
|
|
data = container_of(led, struct system76_data, ap_led); |
|
return system76_set(data, "SAPL", value == LED_OFF ? 0 : 1); |
|
} |
|
|
|
// Get the last set keyboard LED brightness |
|
static enum led_brightness kb_led_get(struct led_classdev *led) |
|
{ |
|
struct system76_data *data; |
|
|
|
data = container_of(led, struct system76_data, kb_led); |
|
return data->kb_brightness; |
|
} |
|
|
|
// Set the keyboard LED brightness |
|
static int kb_led_set(struct led_classdev *led, enum led_brightness value) |
|
{ |
|
struct system76_data *data; |
|
|
|
data = container_of(led, struct system76_data, kb_led); |
|
data->kb_brightness = value; |
|
return system76_set(data, "SKBL", (int)data->kb_brightness); |
|
} |
|
|
|
// Get the last set keyboard LED color |
|
static ssize_t kb_led_color_show( |
|
struct device *dev, |
|
struct device_attribute *dev_attr, |
|
char *buf) |
|
{ |
|
struct led_classdev *led; |
|
struct system76_data *data; |
|
|
|
led = (struct led_classdev *)dev->driver_data; |
|
data = container_of(led, struct system76_data, kb_led); |
|
return sprintf(buf, "%06X\n", data->kb_color); |
|
} |
|
|
|
// Set the keyboard LED color |
|
static ssize_t kb_led_color_store( |
|
struct device *dev, |
|
struct device_attribute *dev_attr, |
|
const char *buf, |
|
size_t size) |
|
{ |
|
struct led_classdev *led; |
|
struct system76_data *data; |
|
unsigned int val; |
|
int ret; |
|
|
|
led = (struct led_classdev *)dev->driver_data; |
|
data = container_of(led, struct system76_data, kb_led); |
|
ret = kstrtouint(buf, 16, &val); |
|
if (ret) |
|
return ret; |
|
if (val > 0xFFFFFF) |
|
return -EINVAL; |
|
data->kb_color = (int)val; |
|
system76_set(data, "SKBC", data->kb_color); |
|
|
|
return size; |
|
} |
|
|
|
static const struct device_attribute kb_led_color_dev_attr = { |
|
.attr = { |
|
.name = "color", |
|
.mode = 0644, |
|
}, |
|
.show = kb_led_color_show, |
|
.store = kb_led_color_store, |
|
}; |
|
|
|
// Notify that the keyboard LED was changed by hardware |
|
static void kb_led_notify(struct system76_data *data) |
|
{ |
|
led_classdev_notify_brightness_hw_changed( |
|
&data->kb_led, |
|
data->kb_brightness |
|
); |
|
} |
|
|
|
// Read keyboard LED brightness as set by hardware |
|
static void kb_led_hotkey_hardware(struct system76_data *data) |
|
{ |
|
int value; |
|
|
|
value = system76_get(data, "GKBL"); |
|
if (value < 0) |
|
return; |
|
data->kb_brightness = value; |
|
kb_led_notify(data); |
|
} |
|
|
|
// Toggle the keyboard LED |
|
static void kb_led_hotkey_toggle(struct system76_data *data) |
|
{ |
|
if (data->kb_brightness > 0) { |
|
data->kb_toggle_brightness = data->kb_brightness; |
|
kb_led_set(&data->kb_led, 0); |
|
} else { |
|
kb_led_set(&data->kb_led, data->kb_toggle_brightness); |
|
} |
|
kb_led_notify(data); |
|
} |
|
|
|
// Decrease the keyboard LED brightness |
|
static void kb_led_hotkey_down(struct system76_data *data) |
|
{ |
|
int i; |
|
|
|
if (data->kb_brightness > 0) { |
|
for (i = ARRAY_SIZE(kb_levels); i > 0; i--) { |
|
if (kb_levels[i - 1] < data->kb_brightness) { |
|
kb_led_set(&data->kb_led, kb_levels[i - 1]); |
|
break; |
|
} |
|
} |
|
} else { |
|
kb_led_set(&data->kb_led, data->kb_toggle_brightness); |
|
} |
|
kb_led_notify(data); |
|
} |
|
|
|
// Increase the keyboard LED brightness |
|
static void kb_led_hotkey_up(struct system76_data *data) |
|
{ |
|
int i; |
|
|
|
if (data->kb_brightness > 0) { |
|
for (i = 0; i < ARRAY_SIZE(kb_levels); i++) { |
|
if (kb_levels[i] > data->kb_brightness) { |
|
kb_led_set(&data->kb_led, kb_levels[i]); |
|
break; |
|
} |
|
} |
|
} else { |
|
kb_led_set(&data->kb_led, data->kb_toggle_brightness); |
|
} |
|
kb_led_notify(data); |
|
} |
|
|
|
// Cycle the keyboard LED color |
|
static void kb_led_hotkey_color(struct system76_data *data) |
|
{ |
|
int i; |
|
|
|
if (data->kb_color < 0) |
|
return; |
|
if (data->kb_brightness > 0) { |
|
for (i = 0; i < ARRAY_SIZE(kb_colors); i++) { |
|
if (kb_colors[i] == data->kb_color) |
|
break; |
|
} |
|
i += 1; |
|
if (i >= ARRAY_SIZE(kb_colors)) |
|
i = 0; |
|
data->kb_color = kb_colors[i]; |
|
system76_set(data, "SKBC", data->kb_color); |
|
} else { |
|
kb_led_set(&data->kb_led, data->kb_toggle_brightness); |
|
} |
|
kb_led_notify(data); |
|
} |
|
|
|
// Handle ACPI notification |
|
static void system76_notify(struct acpi_device *acpi_dev, u32 event) |
|
{ |
|
struct system76_data *data; |
|
|
|
data = acpi_driver_data(acpi_dev); |
|
switch (event) { |
|
case 0x80: |
|
kb_led_hotkey_hardware(data); |
|
break; |
|
case 0x81: |
|
kb_led_hotkey_toggle(data); |
|
break; |
|
case 0x82: |
|
kb_led_hotkey_down(data); |
|
break; |
|
case 0x83: |
|
kb_led_hotkey_up(data); |
|
break; |
|
case 0x84: |
|
kb_led_hotkey_color(data); |
|
break; |
|
} |
|
} |
|
|
|
// Add a System76 ACPI device |
|
static int system76_add(struct acpi_device *acpi_dev) |
|
{ |
|
struct system76_data *data; |
|
int err; |
|
|
|
data = devm_kzalloc(&acpi_dev->dev, sizeof(*data), GFP_KERNEL); |
|
if (!data) |
|
return -ENOMEM; |
|
acpi_dev->driver_data = data; |
|
data->acpi_dev = acpi_dev; |
|
|
|
err = system76_get(data, "INIT"); |
|
if (err) |
|
return err; |
|
data->ap_led.name = "system76_acpi::airplane"; |
|
data->ap_led.flags = LED_CORE_SUSPENDRESUME; |
|
data->ap_led.brightness_get = ap_led_get; |
|
data->ap_led.brightness_set_blocking = ap_led_set; |
|
data->ap_led.max_brightness = 1; |
|
data->ap_led.default_trigger = "rfkill-none"; |
|
err = devm_led_classdev_register(&acpi_dev->dev, &data->ap_led); |
|
if (err) |
|
return err; |
|
|
|
data->kb_led.name = "system76_acpi::kbd_backlight"; |
|
data->kb_led.flags = LED_BRIGHT_HW_CHANGED | LED_CORE_SUSPENDRESUME; |
|
data->kb_led.brightness_get = kb_led_get; |
|
data->kb_led.brightness_set_blocking = kb_led_set; |
|
if (acpi_has_method(acpi_device_handle(data->acpi_dev), "SKBC")) { |
|
data->kb_led.max_brightness = 255; |
|
data->kb_toggle_brightness = 72; |
|
data->kb_color = 0xffffff; |
|
system76_set(data, "SKBC", data->kb_color); |
|
} else { |
|
data->kb_led.max_brightness = 5; |
|
data->kb_color = -1; |
|
} |
|
err = devm_led_classdev_register(&acpi_dev->dev, &data->kb_led); |
|
if (err) |
|
return err; |
|
|
|
if (data->kb_color >= 0) { |
|
err = device_create_file( |
|
data->kb_led.dev, |
|
&kb_led_color_dev_attr |
|
); |
|
if (err) |
|
return err; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
// Remove a System76 ACPI device |
|
static int system76_remove(struct acpi_device *acpi_dev) |
|
{ |
|
struct system76_data *data; |
|
|
|
data = acpi_driver_data(acpi_dev); |
|
if (data->kb_color >= 0) |
|
device_remove_file(data->kb_led.dev, &kb_led_color_dev_attr); |
|
|
|
devm_led_classdev_unregister(&acpi_dev->dev, &data->ap_led); |
|
|
|
devm_led_classdev_unregister(&acpi_dev->dev, &data->kb_led); |
|
|
|
system76_get(data, "FINI"); |
|
|
|
return 0; |
|
} |
|
|
|
static struct acpi_driver system76_driver = { |
|
.name = "System76 ACPI Driver", |
|
.class = "hotkey", |
|
.ids = device_ids, |
|
.ops = { |
|
.add = system76_add, |
|
.remove = system76_remove, |
|
.notify = system76_notify, |
|
}, |
|
}; |
|
module_acpi_driver(system76_driver); |
|
|
|
MODULE_DESCRIPTION("System76 ACPI Driver"); |
|
MODULE_AUTHOR("Jeremy Soller <[email protected]>"); |
|
MODULE_LICENSE("GPL");
|
|
|