[deliverable/linux.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 "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;
	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]);

	mutex_lock(&tdev->lock);

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

	mutex_unlock(&tdev->lock);

	return ret < 0 ? ret : 0;
}

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

	/*
	 * A read consists of two operations: sending the read command
	 * and the actual read from the device. Use the mutex to protect
	 * the full sequence of both operations.
	 */
	mutex_lock(&tdev->lock);

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

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

	ret = 0;

	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]);
err:
	mutex_unlock(&tdev->lock);
	return ret;
}

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_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 int thingm_led_set(struct led_classdev *ldev,
			  enum led_brightness brightness)
{
	struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
	int ret;

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

	return ret;
}

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_blocking = thingm_led_set;
	rgb->red.rgb = rgb;

	err = devm_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_blocking = thingm_led_set;
	rgb->green.rgb = rgb;

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

	/* 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_blocking = thingm_led_set;
	rgb->blue.rgb = rgb;

	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
					 &rgb->blue.ldev);
	return err;
}

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)
		return err;

	mutex_init(&tdev->lock);

	err = thingm_version(tdev);
	if (err)
		return err;

	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);
		return -ENODEV;
	}

	tdev->rgb = devm_kzalloc(&hdev->dev,
			sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
			GFP_KERNEL);
	if (!tdev->rgb)
		return -ENOMEM;

	err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	if (err)
		return err;

	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) {
			hid_hw_stop(hdev);
			return err;
		}
	}

	return 0;
}

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,
	.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	16	#include <linux/mutex.h>
30ba2fbd VD	17
	18	#include "hid-ids.h"
	19
f70ed8a6 VD	20	#define REPORT_ID 1
f70ed8a6 VD	21	#define REPORT_SIZE 9
30ba2fbd	22
f70ed8a6 VD	23	/* Firmware major number of supported devices */
f70ed8a6 VD	24	#define THINGM_MAJOR_MK1 '1'
3121b1c4	25	#define THINGM_MAJOR_MK2 '2'
30ba2fbd	26
f70ed8a6 VD	27	struct thingm_fwinfo {
	28	char major;
	29	unsigned numrgb;
	30	unsigned first;
	31	};
	32
e4aecaf2	33	static const struct thingm_fwinfo thingm_fwinfo[] = {
f70ed8a6 VD	34	{
	35	.major = THINGM_MAJOR_MK1,
	36	.numrgb = 1,
	37	.first = 0,
3121b1c4 VD	38	}, {
	39	.major = THINGM_MAJOR_MK2,
	40	.numrgb = 2,
	41	.first = 1,
f70ed8a6 VD	42	}
	43	};
	44
	45	/* A red, green or blue channel, part of an RGB chip */
	46	struct 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 */
	53	struct thingm_rgb {
	54	struct thingm_device *tdev;
	55	struct thingm_led red;
	56	struct thingm_led green;
	57	struct thingm_led blue;
f70ed8a6 VD	58	u8 num;
	59	};
	60
	61	struct thingm_device {
30ba2fbd	62	struct hid_device *hdev;
f70ed8a6 VD	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;
30ba2fbd VD	70	};
30ba2fbd VD	71
f70ed8a6	72	static int thingm_send(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
30ba2fbd VD	73	{
	74	int ret;
	75
f70ed8a6	76	hid_dbg(tdev->hdev, "-> %d %c %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
30ba2fbd VD	77	buf[0], buf[1], buf[2], buf[3], buf[4],
	78	buf[5], buf[6], buf[7], buf[8]);
	79
43a4a04d HK	80	mutex_lock(&tdev->lock);
43a4a04d HK	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	84
43a4a04d HK	85	mutex_unlock(&tdev->lock);
43a4a04d HK	86
30ba2fbd VD	87	return ret < 0 ? ret : 0;
	88	}
	89
f70ed8a6	90	static int thingm_recv(struct thingm_device *tdev, u8 buf[REPORT_SIZE])
30ba2fbd	91	{
f70ed8a6	92	int ret;
30ba2fbd	93
43a4a04d HK	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
f70ed8a6 VD	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)
43a4a04d HK	109	goto err;
	110
	111	ret = 0;
30ba2fbd	112
f70ed8a6 VD	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]);
43a4a04d HK	116	err:
	117	mutex_unlock(&tdev->lock);
	118	return ret;
30ba2fbd VD	119	}
30ba2fbd VD	120
f70ed8a6	121	static int thingm_version(struct thingm_device *tdev)
30ba2fbd	122	{
f70ed8a6 VD	123	u8 buf[REPORT_SIZE] = { REPORT_ID, 'v', 0, 0, 0, 0, 0, 0, 0 };
	124	int err;
	125
f70ed8a6 VD	126	err = thingm_recv(tdev, buf);
	127	if (err)
	128	return err;
30ba2fbd	129
f70ed8a6 VD	130	tdev->version.major = buf[3];
	131	tdev->version.minor = buf[4];
	132
	133	return 0;
30ba2fbd VD	134	}
30ba2fbd VD	135
f70ed8a6	136	static int thingm_write_color(struct thingm_rgb *rgb)
30ba2fbd	137	{
3121b1c4	138	u8 buf[REPORT_SIZE] = { REPORT_ID, 'c', 0, 0, 0, 0, 0, rgb->num, 0 };
f70ed8a6 VD	139
	140	buf[2] = rgb->red.ldev.brightness;
	141	buf[3] = rgb->green.ldev.brightness;
	142	buf[4] = rgb->blue.ldev.brightness;
30ba2fbd	143
f70ed8a6	144	return thingm_send(rgb->tdev, buf);
30ba2fbd VD	145	}
30ba2fbd VD	146
3de68ce9 HK	147	static int thingm_led_set(struct led_classdev *ldev,
3de68ce9 HK	148	enum led_brightness brightness)
30ba2fbd	149	{
3de68ce9 HK	150	struct thingm_led *led = container_of(ldev, struct thingm_led, ldev);
3de68ce9 HK	151	int ret;
30ba2fbd	152
3de68ce9 HK	153	ret = thingm_write_color(led->rgb);
	154	if (ret)
	155	hid_err(led->rgb->tdev->hdev, "failed to write color\n");
f70ed8a6	156
3de68ce9	157	return ret;
f70ed8a6	158	}
30ba2fbd	159
f70ed8a6 VD	160	static 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;
3de68ce9	170	rgb->red.ldev.brightness_set_blocking = thingm_led_set;
f70ed8a6 VD	171	rgb->red.rgb = rgb;
f70ed8a6 VD	172
c46fab28 HK	173	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
c46fab28 HK	174	&rgb->red.ldev);
f70ed8a6 VD	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;
3de68ce9	183	rgb->green.ldev.brightness_set_blocking = thingm_led_set;
f70ed8a6 VD	184	rgb->green.rgb = rgb;
f70ed8a6 VD	185
c46fab28 HK	186	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
c46fab28 HK	187	&rgb->green.ldev);
f70ed8a6	188	if (err)
c46fab28	189	return err;
f70ed8a6 VD	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;
3de68ce9	196	rgb->blue.ldev.brightness_set_blocking = thingm_led_set;
f70ed8a6 VD	197	rgb->blue.rgb = rgb;
f70ed8a6 VD	198
c46fab28 HK	199	err = devm_led_classdev_register(&rgb->tdev->hdev->dev,
c46fab28 HK	200	&rgb->blue.ldev);
f70ed8a6 VD	201	return err;
	202	}
	203
30ba2fbd VD	204	static int thingm_probe(struct hid_device hdev, const struct hid_device_id id)
30ba2fbd VD	205	{
f70ed8a6 VD	206	struct thingm_device *tdev;
f70ed8a6 VD	207	int i, err;
30ba2fbd	208
f70ed8a6 VD	209	tdev = devm_kzalloc(&hdev->dev, sizeof(struct thingm_device),
	210	GFP_KERNEL);
	211	if (!tdev)
30ba2fbd VD	212	return -ENOMEM;
30ba2fbd VD	213
f70ed8a6 VD	214	tdev->hdev = hdev;
f70ed8a6 VD	215	hid_set_drvdata(hdev, tdev);
30ba2fbd	216
f70ed8a6 VD	217	err = hid_parse(hdev);
f70ed8a6 VD	218	if (err)
1d1b564f	219	return err;
30ba2fbd	220
f70ed8a6 VD	221	mutex_init(&tdev->lock);
	222
	223	err = thingm_version(tdev);
	224	if (err)
1d1b564f	225	return err;
30ba2fbd	226
f70ed8a6 VD	227	hid_dbg(hdev, "firmware version: %c.%c\n",
f70ed8a6 VD	228	tdev->version.major, tdev->version.minor);
30ba2fbd	229
f70ed8a6 VD	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);
1d1b564f	236	return -ENODEV;
f70ed8a6 VD	237	}
	238
	239	tdev->rgb = devm_kzalloc(&hdev->dev,
	240	sizeof(struct thingm_rgb) * tdev->fwinfo->numrgb,
	241	GFP_KERNEL);
1d1b564f HK	242	if (!tdev->rgb)
	243	return -ENOMEM;
	244
	245	err = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	246	if (err)
	247	return err;
f70ed8a6 VD	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);
1d1b564f HK	255	if (err) {
	256	hid_hw_stop(hdev);
	257	return err;
	258	}
f70ed8a6	259	}
30ba2fbd	260
f70ed8a6	261	return 0;
30ba2fbd VD	262	}
30ba2fbd VD	263
30ba2fbd VD	264	static const struct hid_device_id thingm_table[] = {
	265	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
	266	{ }
	267	};
	268	MODULE_DEVICE_TABLE(hid, thingm_table);
	269
	270	static struct hid_driver thingm_driver = {
	271	.name = "thingm",
	272	.probe = thingm_probe,
30ba2fbd VD	273	.id_table = thingm_table,
	274	};
	275
	276	module_hid_driver(thingm_driver);
	277
	278	MODULE_LICENSE("GPL");
	279	MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
	280	MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");