forked from 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.
309 lines
6.2 KiB
309 lines
6.2 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* MSI GT683R led driver |
|
* |
|
* Copyright (c) 2014 Janne Kanniainen <[email protected]> |
|
*/ |
|
|
|
#include <linux/device.h> |
|
#include <linux/hid.h> |
|
#include <linux/kernel.h> |
|
#include <linux/leds.h> |
|
#include <linux/module.h> |
|
|
|
#include "hid-ids.h" |
|
|
|
#define GT683R_BUFFER_SIZE 8 |
|
|
|
/* |
|
* GT683R_LED_OFF: all LEDs are off |
|
* GT683R_LED_AUDIO: LEDs brightness depends on sound level |
|
* GT683R_LED_BREATHING: LEDs brightness varies at human breathing rate |
|
* GT683R_LED_NORMAL: LEDs are fully on when enabled |
|
*/ |
|
enum gt683r_led_mode { |
|
GT683R_LED_OFF = 0, |
|
GT683R_LED_AUDIO = 2, |
|
GT683R_LED_BREATHING = 3, |
|
GT683R_LED_NORMAL = 5 |
|
}; |
|
|
|
enum gt683r_panels { |
|
GT683R_LED_BACK = 0, |
|
GT683R_LED_SIDE = 1, |
|
GT683R_LED_FRONT = 2, |
|
GT683R_LED_COUNT, |
|
}; |
|
|
|
static const char * const gt683r_panel_names[] = { |
|
"back", |
|
"side", |
|
"front", |
|
}; |
|
|
|
struct gt683r_led { |
|
struct hid_device *hdev; |
|
struct led_classdev led_devs[GT683R_LED_COUNT]; |
|
struct mutex lock; |
|
struct work_struct work; |
|
enum led_brightness brightnesses[GT683R_LED_COUNT]; |
|
enum gt683r_led_mode mode; |
|
}; |
|
|
|
static const struct hid_device_id gt683r_led_id[] = { |
|
{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) }, |
|
{ } |
|
}; |
|
|
|
static void gt683r_brightness_set(struct led_classdev *led_cdev, |
|
enum led_brightness brightness) |
|
{ |
|
int i; |
|
struct device *dev = led_cdev->dev->parent; |
|
struct hid_device *hdev = to_hid_device(dev); |
|
struct gt683r_led *led = hid_get_drvdata(hdev); |
|
|
|
for (i = 0; i < GT683R_LED_COUNT; i++) { |
|
if (led_cdev == &led->led_devs[i]) |
|
break; |
|
} |
|
|
|
if (i < GT683R_LED_COUNT) { |
|
led->brightnesses[i] = brightness; |
|
schedule_work(&led->work); |
|
} |
|
} |
|
|
|
static ssize_t mode_show(struct device *dev, |
|
struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
u8 sysfs_mode; |
|
struct hid_device *hdev = to_hid_device(dev->parent); |
|
struct gt683r_led *led = hid_get_drvdata(hdev); |
|
|
|
if (led->mode == GT683R_LED_NORMAL) |
|
sysfs_mode = 0; |
|
else if (led->mode == GT683R_LED_AUDIO) |
|
sysfs_mode = 1; |
|
else |
|
sysfs_mode = 2; |
|
|
|
return scnprintf(buf, PAGE_SIZE, "%u\n", sysfs_mode); |
|
} |
|
|
|
static ssize_t mode_store(struct device *dev, |
|
struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
u8 sysfs_mode; |
|
struct hid_device *hdev = to_hid_device(dev->parent); |
|
struct gt683r_led *led = hid_get_drvdata(hdev); |
|
|
|
|
|
if (kstrtou8(buf, 10, &sysfs_mode) || sysfs_mode > 2) |
|
return -EINVAL; |
|
|
|
mutex_lock(&led->lock); |
|
|
|
if (sysfs_mode == 0) |
|
led->mode = GT683R_LED_NORMAL; |
|
else if (sysfs_mode == 1) |
|
led->mode = GT683R_LED_AUDIO; |
|
else |
|
led->mode = GT683R_LED_BREATHING; |
|
|
|
mutex_unlock(&led->lock); |
|
schedule_work(&led->work); |
|
|
|
return count; |
|
} |
|
|
|
static int gt683r_led_snd_msg(struct gt683r_led *led, u8 *msg) |
|
{ |
|
int ret; |
|
|
|
ret = hid_hw_raw_request(led->hdev, msg[0], msg, GT683R_BUFFER_SIZE, |
|
HID_FEATURE_REPORT, HID_REQ_SET_REPORT); |
|
if (ret != GT683R_BUFFER_SIZE) { |
|
hid_err(led->hdev, |
|
"failed to send set report request: %i\n", ret); |
|
if (ret < 0) |
|
return ret; |
|
return -EIO; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int gt683r_leds_set(struct gt683r_led *led, u8 leds) |
|
{ |
|
int ret; |
|
u8 *buffer; |
|
|
|
buffer = kzalloc(GT683R_BUFFER_SIZE, GFP_KERNEL); |
|
if (!buffer) |
|
return -ENOMEM; |
|
|
|
buffer[0] = 0x01; |
|
buffer[1] = 0x02; |
|
buffer[2] = 0x30; |
|
buffer[3] = leds; |
|
ret = gt683r_led_snd_msg(led, buffer); |
|
|
|
kfree(buffer); |
|
return ret; |
|
} |
|
|
|
static int gt683r_mode_set(struct gt683r_led *led, u8 mode) |
|
{ |
|
int ret; |
|
u8 *buffer; |
|
|
|
buffer = kzalloc(GT683R_BUFFER_SIZE, GFP_KERNEL); |
|
if (!buffer) |
|
return -ENOMEM; |
|
|
|
buffer[0] = 0x01; |
|
buffer[1] = 0x02; |
|
buffer[2] = 0x20; |
|
buffer[3] = mode; |
|
buffer[4] = 0x01; |
|
ret = gt683r_led_snd_msg(led, buffer); |
|
|
|
kfree(buffer); |
|
return ret; |
|
} |
|
|
|
static void gt683r_led_work(struct work_struct *work) |
|
{ |
|
int i; |
|
u8 leds = 0; |
|
u8 mode; |
|
struct gt683r_led *led = container_of(work, struct gt683r_led, work); |
|
|
|
mutex_lock(&led->lock); |
|
|
|
for (i = 0; i < GT683R_LED_COUNT; i++) { |
|
if (led->brightnesses[i]) |
|
leds |= BIT(i); |
|
} |
|
|
|
if (gt683r_leds_set(led, leds)) |
|
goto fail; |
|
|
|
if (leds) |
|
mode = led->mode; |
|
else |
|
mode = GT683R_LED_OFF; |
|
|
|
gt683r_mode_set(led, mode); |
|
fail: |
|
mutex_unlock(&led->lock); |
|
} |
|
|
|
static DEVICE_ATTR_RW(mode); |
|
|
|
static struct attribute *gt683r_led_attrs[] = { |
|
&dev_attr_mode.attr, |
|
NULL |
|
}; |
|
|
|
static const struct attribute_group gt683r_led_group = { |
|
.name = "gt683r", |
|
.attrs = gt683r_led_attrs, |
|
}; |
|
|
|
static const struct attribute_group *gt683r_led_groups[] = { |
|
>683r_led_group, |
|
NULL |
|
}; |
|
|
|
static int gt683r_led_probe(struct hid_device *hdev, |
|
const struct hid_device_id *id) |
|
{ |
|
int i; |
|
int ret; |
|
int name_sz; |
|
char *name; |
|
struct gt683r_led *led; |
|
|
|
led = devm_kzalloc(&hdev->dev, sizeof(*led), GFP_KERNEL); |
|
if (!led) |
|
return -ENOMEM; |
|
|
|
mutex_init(&led->lock); |
|
INIT_WORK(&led->work, gt683r_led_work); |
|
|
|
led->mode = GT683R_LED_NORMAL; |
|
led->hdev = hdev; |
|
hid_set_drvdata(hdev, led); |
|
|
|
ret = hid_parse(hdev); |
|
if (ret) { |
|
hid_err(hdev, "hid parsing failed\n"); |
|
return ret; |
|
} |
|
|
|
ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); |
|
if (ret) { |
|
hid_err(hdev, "hw start failed\n"); |
|
return ret; |
|
} |
|
|
|
for (i = 0; i < GT683R_LED_COUNT; i++) { |
|
name_sz = strlen(dev_name(&hdev->dev)) + |
|
strlen(gt683r_panel_names[i]) + 3; |
|
|
|
name = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); |
|
if (!name) { |
|
ret = -ENOMEM; |
|
goto fail; |
|
} |
|
|
|
snprintf(name, name_sz, "%s::%s", |
|
dev_name(&hdev->dev), gt683r_panel_names[i]); |
|
led->led_devs[i].name = name; |
|
led->led_devs[i].max_brightness = 1; |
|
led->led_devs[i].brightness_set = gt683r_brightness_set; |
|
led->led_devs[i].groups = gt683r_led_groups; |
|
|
|
ret = led_classdev_register(&hdev->dev, &led->led_devs[i]); |
|
if (ret) { |
|
hid_err(hdev, "could not register led device\n"); |
|
goto fail; |
|
} |
|
} |
|
|
|
return 0; |
|
|
|
fail: |
|
for (i = i - 1; i >= 0; i--) |
|
led_classdev_unregister(&led->led_devs[i]); |
|
hid_hw_stop(hdev); |
|
return ret; |
|
} |
|
|
|
static void gt683r_led_remove(struct hid_device *hdev) |
|
{ |
|
int i; |
|
struct gt683r_led *led = hid_get_drvdata(hdev); |
|
|
|
for (i = 0; i < GT683R_LED_COUNT; i++) |
|
led_classdev_unregister(&led->led_devs[i]); |
|
flush_work(&led->work); |
|
hid_hw_stop(hdev); |
|
} |
|
|
|
static struct hid_driver gt683r_led_driver = { |
|
.probe = gt683r_led_probe, |
|
.remove = gt683r_led_remove, |
|
.name = "gt683r_led", |
|
.id_table = gt683r_led_id, |
|
}; |
|
|
|
module_hid_driver(gt683r_led_driver); |
|
|
|
MODULE_AUTHOR("Janne Kanniainen"); |
|
MODULE_DESCRIPTION("MSI GT683R led driver"); |
|
MODULE_LICENSE("GPL");
|
|
|