1/*
  2 * ThingM blink(1) USB RGB LED driver
  3 *
  4 * Copyright 2013-2014 Savoir-faire Linux Inc.
  5 *	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
  6 *
  7 * This program is free software; you can redistribute it and/or
  8 * modify it under the terms of the GNU General Public License as
  9 * published by the Free Software Foundation, version 2.
 10 */
 11
 12#include <linux/hid.h>
 13#include <linux/hidraw.h>
 14#include <linux/leds.h>
 15#include <linux/module.h>
 16#include <linux/mutex.h>
 17
 18#include "hid-ids.h"
 19
 20#define REPORT_ID	1
 21#define REPORT_SIZE	9
 22
 23/* Firmware major number of supported devices */
 24#define THINGM_MAJOR_MK1	'1'
 25#define THINGM_MAJOR_MK2	'2'
 26
 27struct thingm_fwinfo {
 28	char major;
 29	unsigned numrgb;
 30	unsigned first;
 31};
 32
 33static const struct thingm_fwinfo thingm_fwinfo[] = {
 34	{
 35		.major = THINGM_MAJOR_MK1,
 36		.numrgb = 1,
 37		.first = 0,
 38	}, {
 39		.major = THINGM_MAJOR_MK2,
 40		.numrgb = 2,
 41		.first = 1,
 42	}
 43};
 44
 45/* A red, green or blue channel, part of an RGB chip */
 46struct thingm_led {
 47	struct thingm_rgb *rgb;
 48	struct led_classdev ldev;
 49	char name[32];
 50};
 51
 52/* Basically a WS2812 5050 RGB LED chip */
 53struct thingm_rgb {
 54	struct thingm_device *tdev;
 55	struct thingm_led red;
 56	struct thingm_led green;
 57	struct thingm_led blue;
 58	u8 num;
 59};
 60
 61struct thingm_device {
 62	struct hid_device *hdev;
 63	struct {
 64		char major;
 65		char minor;
 66	} version;
 67	const struct thingm_fwinfo *fwinfo;
 68	struct mutex lock;
 69	struct thingm_rgb *rgb;
 70};
 71
 72static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
 73{
 74	int ret;
 75
 76	hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
 77			buf[0], buf[1], buf[2], buf[3], buf[4],
 78			buf[5], buf[6], buf[7], buf[8]);
 79
 80	mutex_lock(&tdev->lock);
 81
 82	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
 83			HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 84
 85	mutex_unlock(&tdev->lock);
 86
 87	return ret < 0 ? ret : 0;
 88}
 89
 90static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
 91{
 92	int ret;
 93
 94	/*
 95	 * A read consists of two operations: sending the read command
 96	 * and the actual read from the device. Use the mutex to protect
 97	 * the full sequence of both operations.
 98	 */
 99	mutex_lock(&tdev->lock);
100
101	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
102			HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
103	if (ret < 0)
104		goto err;
105
106	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
107			HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
108	if (ret < 0)
109		goto err;
110
111	ret = 0;
112
113	hid_dbg(tdev->hdev, "<- %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
114			buf[0], buf[1], buf[2], buf[3], buf[4],
115			buf[5], buf[6], buf[7], buf[8]);
116err:
117	mutex_unlock(&tdev->lock);
118	return ret;
119}
120
121static int thingm_version(struct thingm_device *tdev)
122{
123	u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
124	int err;
125
126	err = thingm_recv(tdev, buf);
127	if (err)
128		return err;
129
130	tdev->version.major = buf[3];
131	tdev->version.minor = buf[4];
132
133	return 0;
134}
135
136static int thingm_write_color(struct thingm_rgb *rgb)
137{
138	u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };
139
140	buf[2] = rgb->red.ldev.brightness;
141	buf[3] = rgb->green.ldev.brightness;
142	buf[4] = rgb->blue.ldev.brightness;
143
144	return thingm_send(rgb->tdev, buf);
145}
146
147static int thingm_led_set(struct led_classdev *ldev,
148			  enum led_brightness brightness)
149{
150	struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
151	int ret;
152
153	ret = thingm_write_color(led->rgb);
154	if (ret)
155		hid_err(led->rgb->tdev->hdev, "failed to write color\n");
156
157	return ret;
158}
159
160static int thingm_init_rgb(struct thingm_rgb *rgb)
161{
162	const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
163	int err;
164
165	/* Register the red diode */
166	snprintf(rgb->red.name, sizeof(rgb->red.name),
167			"thingm%d:red:led%d", minor, rgb->num);
168	rgb->red.ldev.name = rgb->red.name;
169	rgb->red.ldev.max_brightness = 255;
170	rgb->red.ldev.brightness_set_blocking = thingm_led_set;
171	rgb->red.rgb = rgb;
172
173	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
174					 &rgb->red.ldev);
175	if (err)
176		return err;
177
178	/* Register the green diode */
179	snprintf(rgb->green.name, sizeof(rgb->green.name),
180			"thingm%d:green:led%d", minor, rgb->num);
181	rgb->green.ldev.name = rgb->green.name;
182	rgb->green.ldev.max_brightness = 255;
183	rgb->green.ldev.brightness_set_blocking = thingm_led_set;
184	rgb->green.rgb = rgb;
185
186	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
187					 &rgb->green.ldev);
188	if (err)
189		return err;
190
191	/* Register the blue diode */
192	snprintf(rgb->blue.name, sizeof(rgb->blue.name),
193			"thingm%d:blue:led%d", minor, rgb->num);
194	rgb->blue.ldev.name = rgb->blue.name;
195	rgb->blue.ldev.max_brightness = 255;
196	rgb->blue.ldev.brightness_set_blocking = thingm_led_set;
197	rgb->blue.rgb = rgb;
198
199	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
200					 &rgb->blue.ldev);
201	return err;
202}
203
204static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
205{
206	struct thingm_device *tdev;
207	int i, err;
208
209	tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
210			GFP_KERNEL);
211	if (!tdev)
212		return -ENOMEM;
213
214	tdev->hdev = hdev;
215	hid_set_drvdata(hdev, tdev);
216
217	err = hid_parse(hdev);
218	if (err)
219		return err;
220
221	mutex_init(&tdev->lock);
222
223	err = thingm_version(tdev);
224	if (err)
225		return err;
226
227	hid_dbg(hdev, "firmware version: %c.%c\n",
228			tdev->version.major, tdev->version.minor);
229
230	for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
231		if (thingm_fwinfo[i].major == tdev->version.major)
232			tdev->fwinfo = &thingm_fwinfo[i];
233
234	if (!tdev->fwinfo) {
235		hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
236		return -ENODEV;
237	}
238
239	tdev->rgb = devm_kzalloc(&hdev->dev,
240			sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
241			GFP_KERNEL);
242	if (!tdev->rgb)
243		return -ENOMEM;
244
245	err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
246	if (err)
247		return err;
248
249	for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
250		struct thingm_rgb *rgb = tdev->rgb + i;
251
252		rgb->tdev = tdev;
253		rgb->num = tdev->fwinfo->first + i;
254		err = thingm_init_rgb(rgb);
255		if (err) {
256			hid_hw_stop(hdev);
257			return err;
258		}
259	}
260
261	return 0;
262}
263
264static const struct hid_device_id thingm_table[] = {
265	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
266	{ }
267};
268MODULE_DEVICE_TABLE(hid, thingm_table);
269
270static struct hid_driver thingm_driver = {
271	.name = "thingm",
272	.probe = thingm_probe,
273	.id_table = thingm_table,
274};
275
276module_hid_driver(thingm_driver);
277
278MODULE_LICENSE("GPL");
279MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
280MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");