1/*
  2 * MSI GT683R led driver
  3 *
  4 * Copyright (c) 2014 Janne Kanniainen <janne.kanniainen@gmail.com>
  5 *
  6 * This program is free software; you can redistribute it and/or
  7 * modify it under the terms of the GNU General Public License as
  8 * published by the Free Software Foundation; either version 2 of
  9 * the License, or (at your option) any later version.
 10 *
 11 * This program is distributed in the hope that it will be useful,
 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14 * GNU General Public License for more details.
 15 *
 16 */
 17
 18#include <linux/device.h>
 19#include <linux/hid.h>
 20#include <linux/kernel.h>
 21#include <linux/leds.h>
 22#include <linux/module.h>
 23
 24#include "hid-ids.h"
 25
 26#define GT683R_BUFFER_SIZE			8
 27
 28/*
 29 * GT683R_LED_OFF: all LEDs are off
 30 * GT683R_LED_AUDIO: LEDs brightness depends on sound level
 31 * GT683R_LED_BREATHING: LEDs brightness varies at human breathing rate
 32 * GT683R_LED_NORMAL: LEDs are fully on when enabled
 33 */
 34enum gt683r_led_mode {
 35	GT683R_LED_OFF = 0,
 36	GT683R_LED_AUDIO = 2,
 37	GT683R_LED_BREATHING = 3,
 38	GT683R_LED_NORMAL = 5
 39};
 40
 41enum gt683r_panels {
 42	GT683R_LED_BACK = 0,
 43	GT683R_LED_SIDE = 1,
 44	GT683R_LED_FRONT = 2,
 45	GT683R_LED_COUNT,
 46};
 47
 48static const char * const gt683r_panel_names[] = {
 49	"back",
 50	"side",
 51	"front",
 52};
 53
 54struct gt683r_led {
 55	struct hid_device *hdev;
 56	struct led_classdev led_devs[GT683R_LED_COUNT];
 57	struct mutex lock;
 58	struct work_struct work;
 59	enum led_brightness brightnesses[GT683R_LED_COUNT];
 60	enum gt683r_led_mode mode;
 61};
 62
 63static const struct hid_device_id gt683r_led_id[] = {
 64	{ HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
 65	{ }
 66};
 67
 68static void gt683r_brightness_set(struct led_classdev *led_cdev,
 69				enum led_brightness brightness)
 70{
 71	int i;
 72	struct device *dev = led_cdev->dev->parent;
 73	struct hid_device *hdev = to_hid_device(dev);
 74	struct gt683r_led *led = hid_get_drvdata(hdev);
 75
 76	for (i = 0; i < GT683R_LED_COUNT; i++) {
 77		if (led_cdev == &led->led_devs[i])
 78			break;
 79	}
 80
 81	if (i < GT683R_LED_COUNT) {
 82		led->brightnesses[i] = brightness;
 83		schedule_work(&led->work);
 84	}
 85}
 86
 87static ssize_t mode_show(struct device *dev,
 88				struct device_attribute *attr,
 89				char *buf)
 90{
 91	u8 sysfs_mode;
 92	struct hid_device *hdev = to_hid_device(dev->parent);
 93	struct gt683r_led *led = hid_get_drvdata(hdev);
 94
 95	if (led->mode == GT683R_LED_NORMAL)
 96		sysfs_mode = 0;
 97	else if (led->mode == GT683R_LED_AUDIO)
 98		sysfs_mode = 1;
 99	else
100		sysfs_mode = 2;
101
102	return scnprintf(buf, PAGE_SIZE, "%u\n", sysfs_mode);
103}
104
105static ssize_t mode_store(struct device *dev,
106				struct device_attribute *attr,
107				const char *buf, size_t count)
108{
109	u8 sysfs_mode;
110	struct hid_device *hdev = to_hid_device(dev->parent);
111	struct gt683r_led *led = hid_get_drvdata(hdev);
112
113
114	if (kstrtou8(buf, 10, &sysfs_mode) || sysfs_mode > 2)
115		return -EINVAL;
116
117	mutex_lock(&led->lock);
118
119	if (sysfs_mode == 0)
120		led->mode = GT683R_LED_NORMAL;
121	else if (sysfs_mode == 1)
122		led->mode = GT683R_LED_AUDIO;
123	else
124		led->mode = GT683R_LED_BREATHING;
125
126	mutex_unlock(&led->lock);
127	schedule_work(&led->work);
128
129	return count;
130}
131
132static int gt683r_led_snd_msg(struct gt683r_led *led, u8 *msg)
133{
134	int ret;
135
136	ret = hid_hw_raw_request(led->hdev, msg[0], msg, GT683R_BUFFER_SIZE,
137				HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
138	if (ret != GT683R_BUFFER_SIZE) {
139		hid_err(led->hdev,
140			"failed to send set report request: %i\n", ret);
141		if (ret < 0)
142			return ret;
143		return -EIO;
144	}
145
146	return 0;
147}
148
149static int gt683r_leds_set(struct gt683r_led *led, u8 leds)
150{
151	int ret;
152	u8 *buffer;
153
154	buffer = kzalloc(GT683R_BUFFER_SIZE, GFP_KERNEL);
155	if (!buffer)
156		return -ENOMEM;
157
158	buffer[0] = 0x01;
159	buffer[1] = 0x02;
160	buffer[2] = 0x30;
161	buffer[3] = leds;
162	ret = gt683r_led_snd_msg(led, buffer);
163
164	kfree(buffer);
165	return ret;
166}
167
168static int gt683r_mode_set(struct gt683r_led *led, u8 mode)
169{
170	int ret;
171	u8 *buffer;
172
173	buffer = kzalloc(GT683R_BUFFER_SIZE, GFP_KERNEL);
174	if (!buffer)
175		return -ENOMEM;
176
177	buffer[0] = 0x01;
178	buffer[1] = 0x02;
179	buffer[2] = 0x20;
180	buffer[3] = mode;
181	buffer[4] = 0x01;
182	ret = gt683r_led_snd_msg(led, buffer);
183
184	kfree(buffer);
185	return ret;
186}
187
188static void gt683r_led_work(struct work_struct *work)
189{
190	int i;
191	u8 leds = 0;
192	u8 mode;
193	struct gt683r_led *led = container_of(work, struct gt683r_led, work);
194
195	mutex_lock(&led->lock);
196
197	for (i = 0; i < GT683R_LED_COUNT; i++) {
198		if (led->brightnesses[i])
199			leds |= BIT(i);
200	}
201
202	if (gt683r_leds_set(led, leds))
203		goto fail;
204
205	if (leds)
206		mode = led->mode;
207	else
208		mode = GT683R_LED_OFF;
209
210	gt683r_mode_set(led, mode);
211fail:
212	mutex_unlock(&led->lock);
213}
214
215static DEVICE_ATTR_RW(mode);
216
217static struct attribute *gt683r_led_attrs[] = {
218	&dev_attr_mode.attr,
219	NULL
220};
221
222static const struct attribute_group gt683r_led_group = {
223	.name = "gt683r",
224	.attrs = gt683r_led_attrs,
225};
226
227static const struct attribute_group *gt683r_led_groups[] = {
228	&gt683r_led_group,
229	NULL
230};
231
232static int gt683r_led_probe(struct hid_device *hdev,
233			const struct hid_device_id *id)
234{
235	int i;
236	int ret;
237	int name_sz;
238	char *name;
239	struct gt683r_led *led;
240
241	led = devm_kzalloc(&hdev->dev, sizeof(*led), GFP_KERNEL);
242	if (!led)
243		return -ENOMEM;
244
245	mutex_init(&led->lock);
246	INIT_WORK(&led->work, gt683r_led_work);
247
248	led->mode = GT683R_LED_NORMAL;
249	led->hdev = hdev;
250	hid_set_drvdata(hdev, led);
251
252	ret = hid_parse(hdev);
253	if (ret) {
254		hid_err(hdev, "hid parsing failed\n");
255		return ret;
256	}
257
258	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
259	if (ret) {
260		hid_err(hdev, "hw start failed\n");
261		return ret;
262	}
263
264	for (i = 0; i < GT683R_LED_COUNT; i++) {
265		name_sz = strlen(dev_name(&hdev->dev)) +
266				strlen(gt683r_panel_names[i]) + 3;
267
268		name = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
269		if (!name) {
270			ret = -ENOMEM;
271			goto fail;
272		}
273
274		snprintf(name, name_sz, "%s::%s",
275				dev_name(&hdev->dev), gt683r_panel_names[i]);
276		led->led_devs[i].name = name;
277		led->led_devs[i].max_brightness = 1;
278		led->led_devs[i].brightness_set = gt683r_brightness_set;
279		led->led_devs[i].groups = gt683r_led_groups;
280
281		ret = led_classdev_register(&hdev->dev, &led->led_devs[i]);
282		if (ret) {
283			hid_err(hdev, "could not register led device\n");
284			goto fail;
285		}
286	}
287
288	return 0;
289
290fail:
291	for (i = i - 1; i >= 0; i--)
292		led_classdev_unregister(&led->led_devs[i]);
293	hid_hw_stop(hdev);
294	return ret;
295}
296
297static void gt683r_led_remove(struct hid_device *hdev)
298{
299	int i;
300	struct gt683r_led *led = hid_get_drvdata(hdev);
301
302	for (i = 0; i < GT683R_LED_COUNT; i++)
303		led_classdev_unregister(&led->led_devs[i]);
304	flush_work(&led->work);
305	hid_hw_stop(hdev);
306}
307
308static struct hid_driver gt683r_led_driver = {
309	.probe = gt683r_led_probe,
310	.remove = gt683r_led_remove,
311	.name = "gt683r_led",
312	.id_table = gt683r_led_id,
313};
314
315module_hid_driver(gt683r_led_driver);
316
317MODULE_AUTHOR("Janne Kanniainen");
318MODULE_DESCRIPTION("MSI GT683R led driver");
319MODULE_LICENSE("GPL");