mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-13 05:54:23 +08:00
c942fddf87
Based on 3 normalized pattern(s): this program 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 2 of the license or at your option any later version this program 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 this program 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 2 of the license or at your option any later version [author] [kishon] [vijay] [abraham] [i] [kishon]@[ti] [com] this program 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 this program 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 2 of the license or at your option any later version [author] [graeme] [gregory] [gg]@[slimlogic] [co] [uk] [author] [kishon] [vijay] [abraham] [i] [kishon]@[ti] [com] [based] [on] [twl6030]_[usb] [c] [author] [hema] [hk] [hemahk]@[ti] [com] this program 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 1105 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070033.202006027@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
310 lines
6.2 KiB
C
310 lines
6.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* MSI GT683R led driver
|
|
*
|
|
* Copyright (c) 2014 Janne Kanniainen <janne.kanniainen@gmail.com>
|
|
*/
|
|
|
|
#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");
|