[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hid / hid-thingm.c

/*
 * ThingM blink(1) USB RGB LED driver
 *
 * Copyright 2013 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/leds.h>
#include <linux/module.h>

#include "hid-ids.h"

#define BLINK1_CMD_SIZE		9

#define blink1_rgb_to_r(rgb)	((rgb & 0xFF0000) >> 16)
#define blink1_rgb_to_g(rgb)	((rgb & 0x00FF00) >> 8)
#define blink1_rgb_to_b(rgb)	((rgb & 0x0000FF) >> 0)

/**
 * struct blink1_data - blink(1) device specific data
 * @hdev:		HID device.
 * @led_cdev:		LED class instance.
 * @rgb:		8-bit per channel RGB notation.
 * @fade:		fade time in hundredths of a second.
 * @brightness:		brightness coefficient.
 * @play:		play/pause in-memory patterns.
 */
struct blink1_data {
	struct hid_device *hdev;
	struct led_classdev led_cdev;
	u32 rgb;
	u16 fade;
	u8 brightness;
	bool play;
};

static int blink1_send_command(struct blink1_data *data,
		u8 buf[BLINK1_CMD_SIZE])
{
	int ret;

	hid_dbg(data->hdev, "command: %d%c%.2x%.2x%.2x%.2x%.2x%.2x%.2x\n",
			buf[0], buf[1], buf[2], buf[3], buf[4],
			buf[5], buf[6], buf[7], buf[8]);

	ret = data->hdev->hid_output_raw_report(data->hdev, buf,
			BLINK1_CMD_SIZE, HID_FEATURE_REPORT);

	return ret < 0 ? ret : 0;
}

static int blink1_update_color(struct blink1_data *data)
{
	u8 buf[BLINK1_CMD_SIZE] = { 1, 'n', 0, 0, 0, 0, 0, 0, 0 };

	if (data->brightness) {
		unsigned int coef = DIV_ROUND_CLOSEST(255, data->brightness);

		buf[2] = DIV_ROUND_CLOSEST(blink1_rgb_to_r(data->rgb), coef);
		buf[3] = DIV_ROUND_CLOSEST(blink1_rgb_to_g(data->rgb), coef);
		buf[4] = DIV_ROUND_CLOSEST(blink1_rgb_to_b(data->rgb), coef);
	}

	if (data->fade) {
		buf[1] = 'c';
		buf[5] = (data->fade & 0xFF00) >> 8;
		buf[6] = (data->fade & 0x00FF);
	}

	return blink1_send_command(data, buf);
}

static void blink1_led_set(struct led_classdev *led_cdev,
		enum led_brightness brightness)
{
	struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);

	data->brightness = brightness;
	if (blink1_update_color(data))
		hid_err(data->hdev, "failed to update color\n");
}

static enum led_brightness blink1_led_get(struct led_classdev *led_cdev)
{
	struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);

	return data->brightness;
}

static ssize_t blink1_show_rgb(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct blink1_data *data = dev_get_drvdata(dev->parent);

	return sprintf(buf, "%.6X\n", data->rgb);
}

static ssize_t blink1_store_rgb(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct blink1_data *data = dev_get_drvdata(dev->parent);
	long unsigned int rgb;
	int ret;

	ret = kstrtoul(buf, 16, &rgb);
	if (ret)
		return ret;

	/* RGB triplet notation is 24-bit hexadecimal */
	if (rgb > 0xFFFFFF)
		return -EINVAL;

	data->rgb = rgb;
	ret = blink1_update_color(data);

	return ret ? ret : count;
}

static DEVICE_ATTR(rgb, S_IRUGO | S_IWUSR, blink1_show_rgb, blink1_store_rgb);

static ssize_t blink1_show_fade(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct blink1_data *data = dev_get_drvdata(dev->parent);

	return sprintf(buf, "%d\n", data->fade * 10);
}

static ssize_t blink1_store_fade(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct blink1_data *data = dev_get_drvdata(dev->parent);
	long unsigned int fade;
	int ret;

	ret = kstrtoul(buf, 10, &fade);
	if (ret)
		return ret;

	/* blink(1) accepts 16-bit fade time, number of 10ms ticks */
	fade = DIV_ROUND_CLOSEST(fade, 10);
	if (fade > 65535)
		return -EINVAL;

	data->fade = fade;

	return count;
}

static DEVICE_ATTR(fade, S_IRUGO | S_IWUSR,
		blink1_show_fade, blink1_store_fade);

static ssize_t blink1_show_play(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct blink1_data *data = dev_get_drvdata(dev->parent);

	return sprintf(buf, "%d\n", data->play);
}

static ssize_t blink1_store_play(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct blink1_data *data = dev_get_drvdata(dev->parent);
	u8 cmd[BLINK1_CMD_SIZE] = { 1, 'p', 0, 0, 0, 0, 0, 0, 0 };
	long unsigned int play;
	int ret;

	ret = kstrtoul(buf, 10, &play);
	if (ret)
		return ret;

	data->play = !!play;
	cmd[2] = data->play;
	ret = blink1_send_command(data, cmd);

	return ret ? ret : count;
}

static DEVICE_ATTR(play, S_IRUGO | S_IWUSR,
		blink1_show_play, blink1_store_play);

static const struct attribute_group blink1_sysfs_group = {
	.attrs = (struct attribute *[]) {
		&dev_attr_rgb.attr,
		&dev_attr_fade.attr,
		&dev_attr_play.attr,
		NULL
	},
};

static int thingm_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	struct blink1_data *data;
	struct led_classdev *led;
	char led_name[13];
	int ret;

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

	hid_set_drvdata(hdev, data);
	data->hdev = hdev;
	data->rgb = 0xFFFFFF; /* set a default white color */

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

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

	/* blink(1) serial numbers range is 0x1A001000 to 0x1A002FFF */
	led = &data->led_cdev;
	snprintf(led_name, sizeof(led_name), "blink1::%s", hdev->uniq + 4);
	led->name = led_name;
	led->brightness_set = blink1_led_set;
	led->brightness_get = blink1_led_get;
	ret = led_classdev_register(&hdev->dev, led);
	if (ret)
		goto stop;

	ret = sysfs_create_group(&led->dev->kobj, &blink1_sysfs_group);
	if (ret)
		goto remove_led;

	return 0;

remove_led:
	led_classdev_unregister(led);
stop:
	hid_hw_stop(hdev);
error:
	return ret;
}

static void thingm_remove(struct hid_device *hdev)
{
	struct blink1_data *data = hid_get_drvdata(hdev);
	struct led_classdev *led = &data->led_cdev;

	sysfs_remove_group(&led->dev->kobj, &blink1_sysfs_group);
	led_classdev_unregister(led);
	hid_hw_stop(hdev);
}

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	*
	4	* Copyright 2013 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/leds.h>
	14	#include <linux/module.h>
30ba2fbd VD	15
	16	#include "hid-ids.h"
	17
	18	#define BLINK1_CMD_SIZE 9
	19
	20	#define blink1_rgb_to_r(rgb) ((rgb & 0xFF0000) >> 16)
	21	#define blink1_rgb_to_g(rgb) ((rgb & 0x00FF00) >> 8)
	22	#define blink1_rgb_to_b(rgb) ((rgb & 0x0000FF) >> 0)
	23
	24	/**
	25	* struct blink1_data - blink(1) device specific data
	26	* @hdev: HID device.
	27	* @led_cdev: LED class instance.
	28	* @rgb: 8-bit per channel RGB notation.
	29	* @fade: fade time in hundredths of a second.
	30	* @brightness: brightness coefficient.
	31	* @play: play/pause in-memory patterns.
	32	*/
	33	struct blink1_data {
	34	struct hid_device *hdev;
	35	struct led_classdev led_cdev;
	36	u32 rgb;
	37	u16 fade;
	38	u8 brightness;
	39	bool play;
	40	};
	41
	42	static int blink1_send_command(struct blink1_data *data,
	43	u8 buf[BLINK1_CMD_SIZE])
	44	{
	45	int ret;
	46
	47	hid_dbg(data->hdev, "command: %d%c%.2x%.2x%.2x%.2x%.2x%.2x%.2x\n",
	48	buf[0], buf[1], buf[2], buf[3], buf[4],
	49	buf[5], buf[6], buf[7], buf[8]);
	50
	51	ret = data->hdev->hid_output_raw_report(data->hdev, buf,
	52	BLINK1_CMD_SIZE, HID_FEATURE_REPORT);
	53
	54	return ret < 0 ? ret : 0;
	55	}
	56
	57	static int blink1_update_color(struct blink1_data *data)
	58	{
	59	u8 buf[BLINK1_CMD_SIZE] = { 1, 'n', 0, 0, 0, 0, 0, 0, 0 };
	60
	61	if (data->brightness) {
	62	unsigned int coef = DIV_ROUND_CLOSEST(255, data->brightness);
	63
	64	buf[2] = DIV_ROUND_CLOSEST(blink1_rgb_to_r(data->rgb), coef);
	65	buf[3] = DIV_ROUND_CLOSEST(blink1_rgb_to_g(data->rgb), coef);
	66	buf[4] = DIV_ROUND_CLOSEST(blink1_rgb_to_b(data->rgb), coef);
	67	}
	68
	69	if (data->fade) {
	70	buf[1] = 'c';
	71	buf[5] = (data->fade & 0xFF00) >> 8;
	72	buf[6] = (data->fade & 0x00FF);
	73	}
	74
	75	return blink1_send_command(data, buf);
	76	}
	77
	78	static void blink1_led_set(struct led_classdev *led_cdev,
79	enum led_brightness brightness)
80	{
81	struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
82
83	data->brightness = brightness;
84	if (blink1_update_color(data))
85	hid_err(data->hdev, "failed to update color\n");
86	}
87
88	static enum led_brightness blink1_led_get(struct led_classdev *led_cdev)
89	{
90	struct blink1_data *data = dev_get_drvdata(led_cdev->dev->parent);
91
92	return data->brightness;
93	}
94
95	static ssize_t blink1_show_rgb(struct device *dev,
96	struct device_attribute attr, char buf)
97	{
98	struct blink1_data *data = dev_get_drvdata(dev->parent);
99
100	return sprintf(buf, "%.6X\n", data->rgb);
101	}
102
103	static ssize_t blink1_store_rgb(struct device *dev,
104	struct device_attribute attr, const char buf, size_t count)
105	{
106	struct blink1_data *data = dev_get_drvdata(dev->parent);
107	long unsigned int rgb;
108	int ret;
109
110	ret = kstrtoul(buf, 16, &rgb);
111	if (ret)
112	return ret;
113
114	/* RGB triplet notation is 24-bit hexadecimal */
115	if (rgb > 0xFFFFFF)
116	return -EINVAL;
117
118	data->rgb = rgb;
119	ret = blink1_update_color(data);
120
121	return ret ? ret : count;
122	}
123
124	static DEVICE_ATTR(rgb, S_IRUGO \| S_IWUSR, blink1_show_rgb, blink1_store_rgb);
125
126	static ssize_t blink1_show_fade(struct device *dev,
127	struct device_attribute attr, char buf)
128	{
129	struct blink1_data *data = dev_get_drvdata(dev->parent);
130
131	return sprintf(buf, "%d\n", data->fade * 10);
132	}
133
134	static ssize_t blink1_store_fade(struct device *dev,
135	struct device_attribute attr, const char buf, size_t count)
136	{
137	struct blink1_data *data = dev_get_drvdata(dev->parent);
138	long unsigned int fade;
139	int ret;
140
141	ret = kstrtoul(buf, 10, &fade);
142	if (ret)
143	return ret;
144
145	/* blink(1) accepts 16-bit fade time, number of 10ms ticks */
146	fade = DIV_ROUND_CLOSEST(fade, 10);
147	if (fade > 65535)
148	return -EINVAL;
149
150	data->fade = fade;
151
152	return count;
153	}
154
155	static DEVICE_ATTR(fade, S_IRUGO \| S_IWUSR,
156	blink1_show_fade, blink1_store_fade);
157
158	static ssize_t blink1_show_play(struct device *dev,
159	struct device_attribute attr, char buf)
160	{
161	struct blink1_data *data = dev_get_drvdata(dev->parent);
162
163	return sprintf(buf, "%d\n", data->play);
164	}
165
166	static ssize_t blink1_store_play(struct device *dev,
167	struct device_attribute attr, const char buf, size_t count)
168	{
169	struct blink1_data *data = dev_get_drvdata(dev->parent);
170	u8 cmd[BLINK1_CMD_SIZE] = { 1, 'p', 0, 0, 0, 0, 0, 0, 0 };
171	long unsigned int play;
172	int ret;
173
174	ret = kstrtoul(buf, 10, &play);
175	if (ret)
176	return ret;
177
178	data->play = !!play;
179	cmd[2] = data->play;
180	ret = blink1_send_command(data, cmd);
181
182	return ret ? ret : count;
183	}
184
185	static DEVICE_ATTR(play, S_IRUGO \| S_IWUSR,
186	blink1_show_play, blink1_store_play);
187
188	static const struct attribute_group blink1_sysfs_group = {
189	.attrs = (struct attribute *[]) {
190	&dev_attr_rgb.attr,
191	&dev_attr_fade.attr,
192	&dev_attr_play.attr,
193	NULL
194	},
195	};
196
197	static int thingm_probe(struct hid_device hdev, const struct hid_device_id id)
198	{
199	struct blink1_data *data;
200	struct led_classdev *led;
201	char led_name[13];
202	int ret;
203
204	data = devm_kzalloc(&hdev->dev, sizeof(struct blink1_data), GFP_KERNEL);
205	if (!data)
206	return -ENOMEM;
207
208	hid_set_drvdata(hdev, data);
209	data->hdev = hdev;
210	data->rgb = 0xFFFFFF; /* set a default white color */
211
212	ret = hid_parse(hdev);
213	if (ret)
214	goto error;
215
216	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
217	if (ret)
218	goto error;
219
220	/* blink(1) serial numbers range is 0x1A001000 to 0x1A002FFF */
221	led = &data->led_cdev;
222	snprintf(led_name, sizeof(led_name), "blink1::%s", hdev->uniq + 4);
223	led->name = led_name;
224	led->brightness_set = blink1_led_set;
225	led->brightness_get = blink1_led_get;
226	ret = led_classdev_register(&hdev->dev, led);
227	if (ret)
228	goto stop;
229
230	ret = sysfs_create_group(&led->dev->kobj, &blink1_sysfs_group);
231	if (ret)
232	goto remove_led;
233
234	return 0;
235
236	remove_led:
237	led_classdev_unregister(led);
238	stop:
239	hid_hw_stop(hdev);
240	error:
241	return ret;
242	}
243
244	static void thingm_remove(struct hid_device *hdev)
245	{
246	struct blink1_data *data = hid_get_drvdata(hdev);
247	struct led_classdev *led = &data->led_cdev;
248
249	sysfs_remove_group(&led->dev->kobj, &blink1_sysfs_group);
250	led_classdev_unregister(led);
251	hid_hw_stop(hdev);
252	}
253
254	static const struct hid_device_id thingm_table[] = {
255	{ HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
256	{ }
257	};
258	MODULE_DEVICE_TABLE(hid, thingm_table);
259
260	static struct hid_driver thingm_driver = {
261	.name = "thingm",
262	.probe = thingm_probe,
263	.remove = thingm_remove,
264	.id_table = thingm_table,
265	};
266
267	module_hid_driver(thingm_driver);
268
269	MODULE_LICENSE("GPL");
270	MODULE_AUTHOR("Vivien Didelot <vivien.didelot@savoirfairelinux.com>");
271	MODULE_DESCRIPTION("ThingM blink(1) USB RGB LED driver");