[linux-2.6-block.git] / drivers / hid / hid-thingm.c

/*
 * ThingM blink(1) USB RGB LED driver
 *
 * Copyright 2013-2014 Savoir-faire Linux Inc.
 *	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
 *
 * 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, version 2.
 */

#include <linux/hid.h>
#include <linux/hidraw.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>

#include "hid-ids.h"

#define REPORT_ID	1
#define REPORT_SIZE	9

/* Firmware major number of supported devices */
#define THINGM_MAJOR_MK1	'1'
#define THINGM_MAJOR_MK2	'2'

struct thingm_fwinfo {
	char major;
	unsigned numrgb;
	unsigned first;
};

static const struct thingm_fwinfo thingm_fwinfo[] = {
	{
		.major = THINGM_MAJOR_MK1,
		.numrgb = 1,
		.first = 0,
	}, {
		.major = THINGM_MAJOR_MK2,
		.numrgb = 2,
		.first = 1,
	}
};

/* A red, green or blue channel, part of an RGB chip */
struct thingm_led {
	struct thingm_rgb *rgb;
	struct led_classdev ldev;
	char name[32];
};

/* Basically a WS2812 5050 RGB LED chip */
struct thingm_rgb {
	struct thingm_device *tdev;
	struct thingm_led red;
	struct thingm_led green;
	struct thingm_led blue;
	struct work_struct work;
	u8 num;
};

struct thingm_device {
	struct hid_device *hdev;
	struct {
		char major;
		char minor;
	} version;
	const struct thingm_fwinfo *fwinfo;
	struct mutex lock;
	struct thingm_rgb *rgb;
};

static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
{
	int ret;

	hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
			buf[0], buf[1], buf[2], buf[3], buf[4],
			buf[5], buf[6], buf[7], buf[8]);

	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
			HID_FEATURE_REPORT, HID_REQ_SET_REPORT);

	return ret < 0 ? ret : 0;
}

static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
{
	int ret;

	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
			HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
	if (ret < 0)
		return ret;

	hid_dbg(tdev->hdev, "<- %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
			buf[0], buf[1], buf[2], buf[3], buf[4],
			buf[5], buf[6], buf[7], buf[8]);

	return 0;
}

static int thingm_version(struct thingm_device *tdev)
{
	u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
	int err;

	err = thingm_send(tdev, buf);
	if (err)
		return err;

	err = thingm_recv(tdev, buf);
	if (err)
		return err;

	tdev->version.major = buf[3];
	tdev->version.minor = buf[4];

	return 0;
}

static int thingm_write_color(struct thingm_rgb *rgb)
{
	u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };

	buf[2] = rgb->red.ldev.brightness;
	buf[3] = rgb->green.ldev.brightness;
	buf[4] = rgb->blue.ldev.brightness;

	return thingm_send(rgb->tdev, buf);
}

static void thingm_work(struct work_struct *work)
{
	struct thingm_rgb *rgb = container_of(work, struct thingm_rgb, work);

	mutex_lock(&rgb->tdev->lock);

	if (thingm_write_color(rgb))
		hid_err(rgb->tdev->hdev, "failed to write color\n");

	mutex_unlock(&rgb->tdev->lock);
}

static void thingm_led_set(struct led_classdev *ldev,
		enum led_brightness brightness)
{
	struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);

	/* the ledclass has already stored the brightness value */
	schedule_work(&led->rgb->work);
}

static int thingm_init_rgb(struct thingm_rgb *rgb)
{
	const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
	int err;

	/* Register the red diode */
	snprintf(rgb->red.name, sizeof(rgb->red.name),
			"thingm%d:red:led%d", minor, rgb->num);
	rgb->red.ldev.name = rgb->red.name;
	rgb->red.ldev.max_brightness = 255;
	rgb->red.ldev.brightness_set = thingm_led_set;
	rgb->red.rgb = rgb;

	err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->red.ldev);
	if (err)
		return err;

	/* Register the green diode */
	snprintf(rgb->green.name, sizeof(rgb->green.name),
			"thingm%d:green:led%d", minor, rgb->num);
	rgb->green.ldev.name = rgb->green.name;
	rgb->green.ldev.max_brightness = 255;
	rgb->green.ldev.brightness_set = thingm_led_set;
	rgb->green.rgb = rgb;

	err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->green.ldev);
	if (err)
		goto unregister_red;

	/* Register the blue diode */
	snprintf(rgb->blue.name, sizeof(rgb->blue.name),
			"thingm%d:blue:led%d", minor, rgb->num);
	rgb->blue.ldev.name = rgb->blue.name;
	rgb->blue.ldev.max_brightness = 255;
	rgb->blue.ldev.brightness_set = thingm_led_set;
	rgb->blue.rgb = rgb;

	err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->blue.ldev);
	if (err)
		goto unregister_green;

	INIT_WORK(&rgb->work, thingm_work);

	return 0;

unregister_green:
	led_classdev_unregister(&rgb->green.ldev);

unregister_red:
	led_classdev_unregister(&rgb->red.ldev);

	return err;
}

static void thingm_remove_rgb(struct thingm_rgb *rgb)
{
	led_classdev_unregister(&rgb->red.ldev);
	led_classdev_unregister(&rgb->green.ldev);
	led_classdev_unregister(&rgb->blue.ldev);
	flush_work(&rgb->work);
}

static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	struct thingm_device *tdev;
	int i, err;

	tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
			GFP_KERNEL);
	if (!tdev)
		return -ENOMEM;

	tdev->hdev = hdev;
	hid_set_drvdata(hdev, tdev);

	err = hid_parse(hdev);
	if (err)
		goto error;

	err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	if (err)
		goto error;

	mutex_init(&tdev->lock);

	err = thingm_version(tdev);
	if (err)
		goto stop;

	hid_dbg(hdev, "firmware version: %c.%c\n",
			tdev->version.major, tdev->version.minor);

	for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
		if (thingm_fwinfo[i].major == tdev->version.major)
			tdev->fwinfo = &thingm_fwinfo[i];

	if (!tdev->fwinfo) {
		hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
		err = -ENODEV;
		goto stop;
	}

	tdev->rgb = devm_kzalloc(&hdev->dev,
			sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
			GFP_KERNEL);
	if (!tdev->rgb) {
		err = -ENOMEM;
		goto stop;
	}

	for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
		struct thingm_rgb *rgb = tdev->rgb + i;

		rgb->tdev = tdev;
		rgb->num = tdev->fwinfo->first + i;
		err = thingm_init_rgb(rgb);
		if (err) {
			while (--i >= 0)
				thingm_remove_rgb(tdev->rgb + i);
			goto stop;
		}
	}

	return 0;
stop:
	hid_hw_stop(hdev);
error:
	return err;
}

static void thingm_remove(struct hid_device *hdev)
{
	struct thingm_device *tdev = hid_get_drvdata(hdev);
	int i;

	hid_hw_stop(hdev);

	for (i = 0; i < tdev->fwinfo->numrgb; ++i)
		thingm_remove_rgb(tdev->rgb + i);
}

static const struct hid_device_id thingm_table[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
	{ }
};
MODULE_DEVICE_TABLE(hid, thingm_table);

static struct hid_driver thingm_driver = {
	.name = "thingm",
	.probe = thingm_probe,
	.remove = thingm_remove,
	.id_table = thingm_table,
};

module_hid_driver(thingm_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");
Commit	Line	Data
30ba2fbd VD	1	/*
	2	* ThingM blink(1) USB RGB LED driver
	3	*
f70ed8a6	4	* Copyright 2013-2014 Savoir-faire Linux Inc.
30ba2fbd VD	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>
f70ed8a6	13	#include <linux/hidraw.h>
30ba2fbd VD	14	#include <linux/leds.h>
30ba2fbd VD	15	#include <linux/module.h>
f70ed8a6 VD	16	#include <linux/mutex.h>
f70ed8a6 VD	17	#include <linux/workqueue.h>
30ba2fbd VD	18
	19	#include "hid-ids.h"
	20
f70ed8a6 VD	21	#define REPORT_ID 1
f70ed8a6 VD	22	#define REPORT_SIZE 9
30ba2fbd	23
f70ed8a6 VD	24	/* Firmware major number of supported devices */
f70ed8a6 VD	25	#define THINGM_MAJOR_MK1 '1'
3121b1c4	26	#define THINGM_MAJOR_MK2 '2'
30ba2fbd	27
f70ed8a6 VD	28	struct thingm_fwinfo {
	29	char major;
	30	unsigned numrgb;
	31	unsigned first;
	32	};
	33
e4aecaf2	34	static const struct thingm_fwinfo thingm_fwinfo[] = {
f70ed8a6 VD	35	{
	36	.major = THINGM_MAJOR_MK1,
	37	.numrgb = 1,
	38	.first = 0,
3121b1c4 VD	39	}, {
	40	.major = THINGM_MAJOR_MK2,
	41	.numrgb = 2,
	42	.first = 1,
f70ed8a6 VD	43	}
	44	};
	45
	46	/* A red, green or blue channel, part of an RGB chip */
	47	struct thingm_led {
	48	struct thingm_rgb *rgb;
	49	struct led_classdev ldev;
	50	char name[32];
	51	};
	52
	53	/* Basically a WS2812 5050 RGB LED chip */
	54	struct thingm_rgb {
	55	struct thingm_device *tdev;
	56	struct thingm_led red;
	57	struct thingm_led green;
	58	struct thingm_led blue;
	59	struct work_struct work;
	60	u8 num;
	61	};
	62
	63	struct thingm_device {
30ba2fbd	64	struct hid_device *hdev;
f70ed8a6 VD	65	struct {
	66	char major;
	67	char minor;
	68	} version;
	69	const struct thingm_fwinfo *fwinfo;
	70	struct mutex lock;
	71	struct thingm_rgb *rgb;
30ba2fbd VD	72	};
30ba2fbd VD	73
f70ed8a6	74	static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
30ba2fbd VD	75	{
	76	int ret;
	77
f70ed8a6	78	hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
30ba2fbd VD	79	buf[0], buf[1], buf[2], buf[3], buf[4],
	80	buf[5], buf[6], buf[7], buf[8]);
	81
f70ed8a6 VD	82	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
f70ed8a6 VD	83	HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
30ba2fbd VD	84
	85	return ret < 0 ? ret : 0;
	86	}
	87
f70ed8a6	88	static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
30ba2fbd	89	{
f70ed8a6	90	int ret;
30ba2fbd	91
f70ed8a6 VD	92	ret = hid_hw_raw_request(tdev->hdev, buf[0], buf, REPORT_SIZE,
	93	HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
	94	if (ret < 0)
	95	return ret;
30ba2fbd	96
f70ed8a6 VD	97	hid_dbg(tdev->hdev, "<- %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
	98	buf[0], buf[1], buf[2], buf[3], buf[4],
	99	buf[5], buf[6], buf[7], buf[8]);
30ba2fbd	100
f70ed8a6	101	return 0;
30ba2fbd VD	102	}
30ba2fbd VD	103
f70ed8a6	104	static int thingm_version(struct thingm_device *tdev)
30ba2fbd	105	{
f70ed8a6 VD	106	u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
	107	int err;
	108
	109	err = thingm_send(tdev, buf);
	110	if (err)
	111	return err;
	112
	113	err = thingm_recv(tdev, buf);
	114	if (err)
	115	return err;
30ba2fbd	116
f70ed8a6 VD	117	tdev->version.major = buf[3];
	118	tdev->version.minor = buf[4];
	119
	120	return 0;
30ba2fbd VD	121	}
30ba2fbd VD	122
f70ed8a6	123	static int thingm_write_color(struct thingm_rgb *rgb)
30ba2fbd	124	{
3121b1c4	125	u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };
f70ed8a6 VD	126
	127	buf[2] = rgb->red.ldev.brightness;
	128	buf[3] = rgb->green.ldev.brightness;
	129	buf[4] = rgb->blue.ldev.brightness;
30ba2fbd	130
f70ed8a6	131	return thingm_send(rgb->tdev, buf);
30ba2fbd VD	132	}
30ba2fbd VD	133
f70ed8a6	134	static void thingm_work(struct work_struct *work)
30ba2fbd	135	{
f70ed8a6	136	struct thingm_rgb *rgb = container_of(work, struct thingm_rgb, work);
30ba2fbd	137
f70ed8a6 VD	138	mutex_lock(&rgb->tdev->lock);
	139
	140	if (thingm_write_color(rgb))
	141	hid_err(rgb->tdev->hdev, "failed to write color\n");
	142
	143	mutex_unlock(&rgb->tdev->lock);
30ba2fbd VD	144	}
30ba2fbd VD	145
f70ed8a6 VD	146	static void thingm_led_set(struct led_classdev *ldev,
f70ed8a6 VD	147	enum led_brightness brightness)
30ba2fbd	148	{
f70ed8a6	149	struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
30ba2fbd	150
f70ed8a6 VD	151	/* the ledclass has already stored the brightness value */
	152	schedule_work(&led->rgb->work);
	153	}
30ba2fbd	154
f70ed8a6 VD	155	static int thingm_init_rgb(struct thingm_rgb *rgb)
	156	{
	157	const int minor = ((struct hidraw *) rgb->tdev->hdev->hidraw)->minor;
	158	int err;
	159
	160	/* Register the red diode */
	161	snprintf(rgb->red.name, sizeof(rgb->red.name),
	162	"thingm%d:red:led%d", minor, rgb->num);
	163	rgb->red.ldev.name = rgb->red.name;
	164	rgb->red.ldev.max_brightness = 255;
	165	rgb->red.ldev.brightness_set = thingm_led_set;
	166	rgb->red.rgb = rgb;
	167
	168	err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->red.ldev);
	169	if (err)
	170	return err;
	171
	172	/* Register the green diode */
	173	snprintf(rgb->green.name, sizeof(rgb->green.name),
	174	"thingm%d:green:led%d", minor, rgb->num);
	175	rgb->green.ldev.name = rgb->green.name;
	176	rgb->green.ldev.max_brightness = 255;
	177	rgb->green.ldev.brightness_set = thingm_led_set;
	178	rgb->green.rgb = rgb;
	179
	180	err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->green.ldev);
	181	if (err)
	182	goto unregister_red;
	183
	184	/* Register the blue diode */
	185	snprintf(rgb->blue.name, sizeof(rgb->blue.name),
	186	"thingm%d:blue:led%d", minor, rgb->num);
	187	rgb->blue.ldev.name = rgb->blue.name;
	188	rgb->blue.ldev.max_brightness = 255;
	189	rgb->blue.ldev.brightness_set = thingm_led_set;
	190	rgb->blue.rgb = rgb;
	191
	192	err = led_classdev_register(&rgb->tdev->hdev->dev, &rgb->blue.ldev);
	193	if (err)
	194	goto unregister_green;
	195
	196	INIT_WORK(&rgb->work, thingm_work);
30ba2fbd	197
f70ed8a6	198	return 0;
30ba2fbd	199
f70ed8a6 VD	200	unregister_green:
f70ed8a6 VD	201	led_classdev_unregister(&rgb->green.ldev);
30ba2fbd	202
f70ed8a6 VD	203	unregister_red:
f70ed8a6 VD	204	led_classdev_unregister(&rgb->red.ldev);
30ba2fbd	205
f70ed8a6 VD	206	return err;
	207	}
	208
	209	static void thingm_remove_rgb(struct thingm_rgb *rgb)
	210	{
f70ed8a6 VD	211	led_classdev_unregister(&rgb->red.ldev);
	212	led_classdev_unregister(&rgb->green.ldev);
	213	led_classdev_unregister(&rgb->blue.ldev);
67a97845	214	flush_work(&rgb->work);
f70ed8a6	215	}
30ba2fbd VD	216
	217	static int thingm_probe(struct hid_device hdev, const struct hid_device_id id)
	218	{
f70ed8a6 VD	219	struct thingm_device *tdev;
f70ed8a6 VD	220	int i, err;
30ba2fbd	221
f70ed8a6 VD	222	tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
	223	GFP_KERNEL);
	224	if (!tdev)
30ba2fbd VD	225	return -ENOMEM;
30ba2fbd VD	226
f70ed8a6 VD	227	tdev->hdev = hdev;
f70ed8a6 VD	228	hid_set_drvdata(hdev, tdev);
30ba2fbd	229
f70ed8a6 VD	230	err = hid_parse(hdev);
f70ed8a6 VD	231	if (err)
30ba2fbd VD	232	goto error;
30ba2fbd VD	233
f70ed8a6 VD	234	err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
f70ed8a6 VD	235	if (err)
30ba2fbd VD	236	goto error;
30ba2fbd VD	237
f70ed8a6 VD	238	mutex_init(&tdev->lock);
	239
	240	err = thingm_version(tdev);
	241	if (err)
30ba2fbd VD	242	goto stop;
30ba2fbd VD	243
f70ed8a6 VD	244	hid_dbg(hdev, "firmware version: %c.%c\n",
f70ed8a6 VD	245	tdev->version.major, tdev->version.minor);
30ba2fbd	246
f70ed8a6 VD	247	for (i = 0; i < ARRAY_SIZE(thingm_fwinfo) && !tdev->fwinfo; ++i)
	248	if (thingm_fwinfo[i].major == tdev->version.major)
	249	tdev->fwinfo = &thingm_fwinfo[i];
	250
	251	if (!tdev->fwinfo) {
	252	hid_err(hdev, "unsupported firmware %c\n", tdev->version.major);
e4cf19ff	253	err = -ENODEV;
f70ed8a6 VD	254	goto stop;
	255	}
	256
	257	tdev->rgb = devm_kzalloc(&hdev->dev,
	258	sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
	259	GFP_KERNEL);
	260	if (!tdev->rgb) {
	261	err = -ENOMEM;
	262	goto stop;
	263	}
	264
	265	for (i = 0; i < tdev->fwinfo->numrgb; ++i) {
	266	struct thingm_rgb *rgb = tdev->rgb + i;
	267
	268	rgb->tdev = tdev;
	269	rgb->num = tdev->fwinfo->first + i;
	270	err = thingm_init_rgb(rgb);
	271	if (err) {
	272	while (--i >= 0)
	273	thingm_remove_rgb(tdev->rgb + i);
	274	goto stop;
	275	}
	276	}
30ba2fbd	277
f70ed8a6	278	return 0;
30ba2fbd VD	279	stop:
	280	hid_hw_stop(hdev);
	281	error:
f70ed8a6	282	return err;
30ba2fbd VD	283	}
	284
	285	static void thingm_remove(struct hid_device *hdev)
	286	{
f70ed8a6 VD	287	struct thingm_device *tdev = hid_get_drvdata(hdev);
	288	int i;
	289
67a97845 JK	290	hid_hw_stop(hdev);
67a97845 JK	291
f70ed8a6 VD	292	for (i = 0; i < tdev->fwinfo->numrgb; ++i)
f70ed8a6 VD	293	thingm_remove_rgb(tdev->rgb + i);
30ba2fbd VD	294	}
	295
	296	static const struct hid_device_id thingm_table[] = {
	297	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
	298	{ }
	299	};
	300	MODULE_DEVICE_TABLE(hid, thingm_table);
	301
	302	static struct hid_driver thingm_driver = {
	303	.name = "thingm",
	304	.probe = thingm_probe,
	305	.remove = thingm_remove,
	306	.id_table = thingm_table,
	307	};
	308
	309	module_hid_driver(thingm_driver);
	310
	311	MODULE_LICENSE("GPL");
	312	MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
	313	MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");