Kernel

Kernel Git Source Tree

Root/drivers/leds/leds-blinkm.c

1	/*
2	* leds-blinkm.c
3	* (c) Jan-Simon Möller (dl9pf@gmx.de)
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18	*/
19
20	#include <linux/module.h>
21	#include <linux/init.h>
22	#include <linux/slab.h>
23	#include <linux/jiffies.h>
24	#include <linux/i2c.h>
25	#include <linux/err.h>
26	#include <linux/mutex.h>
27	#include <linux/sysfs.h>
28	#include <linux/printk.h>
29	#include <linux/pm_runtime.h>
30	#include <linux/leds.h>
31	#include <linux/delay.h>
32
33	/* Addresses to scan - BlinkM is on 0x09 by default*/
34	static const unsigned short normal_i2c[] = { 0x09, I2C_CLIENT_END };
35
36	static int blinkm_transfer_hw(struct i2c_client *client, int cmd);
37	static int blinkm_test_run(struct i2c_client *client);
38
39	struct blinkm_led {
40	struct i2c_client *i2c_client;
41	struct led_classdev led_cdev;
42	int id;
43	atomic_t active;
44	};
45
46	struct blinkm_work {
47	struct blinkm_led *blinkm_led;
48	struct work_struct work;
49	};
50
51	#define cdev_to_blmled(c) container_of(c, struct blinkm_led, led_cdev)
52	#define work_to_blmwork(c) container_of(c, struct blinkm_work, work)
53
54	struct blinkm_data {
55	struct i2c_client *i2c_client;
56	struct mutex update_lock;
57	/* used for led class interface */
58	struct blinkm_led blinkm_leds[3];
59	/* used for "blinkm" sysfs interface */
60	u8 red; /* color red */
61	u8 green; /* color green */
62	u8 blue; /* color blue */
63	/* next values to use for transfer */
64	u8 next_red; /* color red */
65	u8 next_green; /* color green */
66	u8 next_blue; /* color blue */
67	/* internal use */
68	u8 args[7]; /* set of args for transmission */
69	u8 i2c_addr; /* i2c addr */
70	u8 fw_ver; /* firmware version */
71	/* used, but not from userspace */
72	u8 hue; /* HSB hue */
73	u8 saturation; /* HSB saturation */
74	u8 brightness; /* HSB brightness */
75	u8 next_hue; /* HSB hue */
76	u8 next_saturation; /* HSB saturation */
77	u8 next_brightness; /* HSB brightness */
78	/* currently unused / todo */
79	u8 fade_speed; /* fade speed 1 - 255 */
80	s8 time_adjust; /* time adjust -128 - 127 */
81	u8 fade:1; /* fade on = 1, off = 0 */
82	u8 rand:1; /* rand fade mode on = 1 */
83	u8 script_id; /* script ID */
84	u8 script_repeats; /* repeats of script */
85	u8 script_startline; /* line to start */
86	};
87
88	/* Colors */
89	#define RED 0
90	#define GREEN 1
91	#define BLUE 2
92
93	/* mapping command names to cmd chars - see datasheet */
94	#define BLM_GO_RGB 0
95	#define BLM_FADE_RGB 1
96	#define BLM_FADE_HSB 2
97	#define BLM_FADE_RAND_RGB 3
98	#define BLM_FADE_RAND_HSB 4
99	#define BLM_PLAY_SCRIPT 5
100	#define BLM_STOP_SCRIPT 6
101	#define BLM_SET_FADE_SPEED 7
102	#define BLM_SET_TIME_ADJ 8
103	#define BLM_GET_CUR_RGB 9
104	#define BLM_WRITE_SCRIPT_LINE 10
105	#define BLM_READ_SCRIPT_LINE 11
106	#define BLM_SET_SCRIPT_LR 12 /* Length & Repeats */
107	#define BLM_SET_ADDR 13
108	#define BLM_GET_ADDR 14
109	#define BLM_GET_FW_VER 15
110	#define BLM_SET_STARTUP_PARAM 16
111
112	/* BlinkM Commands
113	* as extracted out of the datasheet:
114	*
115	* cmdchar = command (ascii)
116	* cmdbyte = command in hex
117	* nr_args = number of arguments (to send)
118	* nr_ret = number of return values (to read)
119	* dir = direction (0 = read, 1 = write, 2 = both)
120	*
121	*/
122	static const struct {
123	char cmdchar;
124	u8 cmdbyte;
125	u8 nr_args;
126	u8 nr_ret;
127	u8 dir:2;
128	} blinkm_cmds[17] = {
129	/* cmdchar, cmdbyte, nr_args, nr_ret, dir */
130	{ 'n', 0x6e, 3, 0, 1},
131	{ 'c', 0x63, 3, 0, 1},
132	{ 'h', 0x68, 3, 0, 1},
133	{ 'C', 0x43, 3, 0, 1},
134	{ 'H', 0x48, 3, 0, 1},
135	{ 'p', 0x70, 3, 0, 1},
136	{ 'o', 0x6f, 0, 0, 1},
137	{ 'f', 0x66, 1, 0, 1},
138	{ 't', 0x74, 1, 0, 1},
139	{ 'g', 0x67, 0, 3, 0},
140	{ 'W', 0x57, 7, 0, 1},
141	{ 'R', 0x52, 2, 5, 2},
142	{ 'L', 0x4c, 3, 0, 1},
143	{ 'A', 0x41, 4, 0, 1},
144	{ 'a', 0x61, 0, 1, 0},
145	{ 'Z', 0x5a, 0, 1, 0},
146	{ 'B', 0x42, 5, 0, 1},
147	};
148
149	static ssize_t show_color_common(struct device dev, char buf, int color)
150	{
151	struct i2c_client *client;
152	struct blinkm_data *data;
153	int ret;
154
155	client = to_i2c_client(dev);
156	data = i2c_get_clientdata(client);
157
158	ret = blinkm_transfer_hw(client, BLM_GET_CUR_RGB);
159	if (ret < 0)
160	return ret;
161	switch (color) {
162	case RED:
163	return scnprintf(buf, PAGE_SIZE, "%02X\n", data->red);
164	break;
165	case GREEN:
166	return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green);
167	break;
168	case BLUE:
169	return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue);
170	break;
171	default:
172	return -EINVAL;
173	}
174	return -EINVAL;
175	}
176
177	static int store_color_common(struct device dev, const char buf, int color)
178	{
179	struct i2c_client *client;
180	struct blinkm_data *data;
181	int ret;
182	u8 value;
183
184	client = to_i2c_client(dev);
185	data = i2c_get_clientdata(client);
186
187	ret = kstrtou8(buf, 10, &value);
188	if (ret < 0) {
189	dev_err(dev, "BlinkM: value too large!\n");
190	return ret;
191	}
192
193	switch (color) {
194	case RED:
195	data->next_red = value;
196	break;
197	case GREEN:
198	data->next_green = value;
199	break;
200	case BLUE:
201	data->next_blue = value;
202	break;
203	default:
204	return -EINVAL;
205	}
206
207	dev_dbg(dev, "next_red = %d, next_green = %d, next_blue = %d\n",
208	data->next_red, data->next_green, data->next_blue);
209
210	/* if mode ... */
211	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
212	if (ret < 0) {
213	dev_err(dev, "BlinkM: can't set RGB\n");
214	return ret;
215	}
216	return 0;
217	}
218
219	static ssize_t show_red(struct device dev, struct device_attribute attr,
220	char *buf)
221	{
222	return show_color_common(dev, buf, RED);
223	}
224
225	static ssize_t store_red(struct device dev, struct device_attribute attr,
226	const char *buf, size_t count)
227	{
228	int ret;
229
230	ret = store_color_common(dev, buf, RED);
231	if (ret < 0)
232	return ret;
233	return count;
234	}
235
236	static DEVICE_ATTR(red, S_IRUGO \| S_IWUSR, show_red, store_red);
237
238	static ssize_t show_green(struct device dev, struct device_attribute attr,
239	char *buf)
240	{
241	return show_color_common(dev, buf, GREEN);
242	}
243
244	static ssize_t store_green(struct device dev, struct device_attribute attr,
245	const char *buf, size_t count)
246	{
247
248	int ret;
249
250	ret = store_color_common(dev, buf, GREEN);
251	if (ret < 0)
252	return ret;
253	return count;
254	}
255
256	static DEVICE_ATTR(green, S_IRUGO \| S_IWUSR, show_green, store_green);
257
258	static ssize_t show_blue(struct device dev, struct device_attribute attr,
259	char *buf)
260	{
261	return show_color_common(dev, buf, BLUE);
262	}
263
264	static ssize_t store_blue(struct device dev, struct device_attribute attr,
265	const char *buf, size_t count)
266	{
267	int ret;
268
269	ret = store_color_common(dev, buf, BLUE);
270	if (ret < 0)
271	return ret;
272	return count;
273	}
274
275	static DEVICE_ATTR(blue, S_IRUGO \| S_IWUSR, show_blue, store_blue);
276
277	static ssize_t show_test(struct device dev, struct device_attribute attr,
278	char *buf)
279	{
280	return scnprintf(buf, PAGE_SIZE,
281	"#Write into test to start test sequence!#\n");
282	}
283
284	static ssize_t store_test(struct device dev, struct device_attribute attr,
285	const char *buf, size_t count)
286	{
287
288	struct i2c_client *client;
289	int ret;
290	client = to_i2c_client(dev);
291
292	/test /
293	ret = blinkm_test_run(client);
294	if (ret < 0)
295	return ret;
296
297	return count;
298	}
299
300	static DEVICE_ATTR(test, S_IRUGO \| S_IWUSR, show_test, store_test);
301
302	/* TODO: HSB, fade, timeadj, script ... */
303
304	static struct attribute *blinkm_attrs[] = {
305	&dev_attr_red.attr,
306	&dev_attr_green.attr,
307	&dev_attr_blue.attr,
308	&dev_attr_test.attr,
309	NULL,
310	};
311
312	static struct attribute_group blinkm_group = {
313	.name = "blinkm",
314	.attrs = blinkm_attrs,
315	};
316
317	static int blinkm_write(struct i2c_client client, int cmd, u8 arg)
318	{
319	int result;
320	int i;
321	int arglen = blinkm_cmds[cmd].nr_args;
322	/* write out cmd to blinkm - always / default step */
323	result = i2c_smbus_write_byte(client, blinkm_cmds[cmd].cmdbyte);
324	if (result < 0)
325	return result;
326	/* no args to write out */
327	if (arglen == 0)
328	return 0;
329
330	for (i = 0; i < arglen; i++) {
331	/* repeat for arglen */
332	result = i2c_smbus_write_byte(client, arg[i]);
333	if (result < 0)
334	return result;
335	}
336	return 0;
337	}
338
339	static int blinkm_read(struct i2c_client client, int cmd, u8 arg)
340	{
341	int result;
342	int i;
343	int retlen = blinkm_cmds[cmd].nr_ret;
344	for (i = 0; i < retlen; i++) {
345	/* repeat for retlen */
346	result = i2c_smbus_read_byte(client);
347	if (result < 0)
348	return result;
349	arg[i] = result;
350	}
351
352	return 0;
353	}
354
355	static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
356	{
357	/* the protocol is simple but non-standard:
358	* e.g. cmd 'g' (= 0x67) for "get device address"
359	* - which defaults to 0x09 - would be the sequence:
360	* a) write 0x67 to the device (byte write)
361	* b) read the value (0x09) back right after (byte read)
362	*
363	* Watch out for "unfinished" sequences (i.e. not enough reads
364	* or writes after a command. It will make the blinkM misbehave.
365	* Sequence is key here.
366	*/
367
368	/* args / return are in private data struct */
369	struct blinkm_data *data = i2c_get_clientdata(client);
370
371	/* We start hardware transfers which are not to be
372	* mixed with other commands. Aquire a lock now. */
373	if (mutex_lock_interruptible(&data->update_lock) < 0)
374	return -EAGAIN;
375
376	/* switch cmd - usually write before reads */
377	switch (cmd) {
378	case BLM_FADE_RAND_RGB:
379	case BLM_GO_RGB:
380	case BLM_FADE_RGB:
381	data->args[0] = data->next_red;
382	data->args[1] = data->next_green;
383	data->args[2] = data->next_blue;
384	blinkm_write(client, cmd, data->args);
385	data->red = data->args[0];
386	data->green = data->args[1];
387	data->blue = data->args[2];
388	break;
389	case BLM_FADE_HSB:
390	case BLM_FADE_RAND_HSB:
391	data->args[0] = data->next_hue;
392	data->args[1] = data->next_saturation;
393	data->args[2] = data->next_brightness;
394	blinkm_write(client, cmd, data->args);
395	data->hue = data->next_hue;
396	data->saturation = data->next_saturation;
397	data->brightness = data->next_brightness;
398	break;
399	case BLM_PLAY_SCRIPT:
400	data->args[0] = data->script_id;
401	data->args[1] = data->script_repeats;
402	data->args[2] = data->script_startline;
403	blinkm_write(client, cmd, data->args);
404	break;
405	case BLM_STOP_SCRIPT:
406	blinkm_write(client, cmd, NULL);
407	break;
408	case BLM_GET_CUR_RGB:
409	data->args[0] = data->red;
410	data->args[1] = data->green;
411	data->args[2] = data->blue;
412	blinkm_write(client, cmd, NULL);
413	blinkm_read(client, cmd, data->args);
414	data->red = data->args[0];
415	data->green = data->args[1];
416	data->blue = data->args[2];
417	break;
418	case BLM_GET_ADDR:
419	data->args[0] = data->i2c_addr;
420	blinkm_write(client, cmd, NULL);
421	blinkm_read(client, cmd, data->args);
422	data->i2c_addr = data->args[0];
423	break;
424	case BLM_SET_TIME_ADJ:
425	case BLM_SET_FADE_SPEED:
426	case BLM_READ_SCRIPT_LINE:
427	case BLM_WRITE_SCRIPT_LINE:
428	case BLM_SET_SCRIPT_LR:
429	case BLM_SET_ADDR:
430	case BLM_GET_FW_VER:
431	case BLM_SET_STARTUP_PARAM:
432	dev_err(&client->dev,
433	"BlinkM: cmd %d not implemented yet.\n", cmd);
434	break;
435	default:
436	dev_err(&client->dev, "BlinkM: unknown command %d\n", cmd);
437	mutex_unlock(&data->update_lock);
438	return -EINVAL;
439	} /* end switch(cmd) */
440
441	/* transfers done, unlock */
442	mutex_unlock(&data->update_lock);
443	return 0;
444	}
445
446	static void led_work(struct work_struct *work)
447	{
448	int ret;
449	struct blinkm_led *led;
450	struct blinkm_data *data ;
451	struct blinkm_work *blm_work = work_to_blmwork(work);
452
453	led = blm_work->blinkm_led;
454	data = i2c_get_clientdata(led->i2c_client);
455	ret = blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB);
456	atomic_dec(&led->active);
457	dev_dbg(&led->i2c_client->dev,
458	"# DONE # next_red = %d, next_green = %d,"
459	" next_blue = %d, active = %d\n",
460	data->next_red, data->next_green,
461	data->next_blue, atomic_read(&led->active));
462	kfree(blm_work);
463	}
464
465	static int blinkm_led_common_set(struct led_classdev *led_cdev,
466	enum led_brightness value, int color)
467	{
468	/* led_brightness is 0, 127 or 255 - we just use it here as-is */
469	struct blinkm_led *led = cdev_to_blmled(led_cdev);
470	struct blinkm_data *data = i2c_get_clientdata(led->i2c_client);
471	struct blinkm_work *bl_work;
472
473	switch (color) {
474	case RED:
475	/* bail out if there's no change */
476	if (data->next_red == (u8) value)
477	return 0;
478	/* we assume a quite fast sequence here ([off]->on->off)
479	* think of network led trigger - we cannot blink that fast, so
480	* in case we already have a off->on->off transition queued up,
481	* we refuse to queue up more.
482	* Revisit: fast-changing brightness. */
483	if (atomic_read(&led->active) > 1)
484	return 0;
485	data->next_red = (u8) value;
486	break;
487	case GREEN:
488	/* bail out if there's no change */
489	if (data->next_green == (u8) value)
490	return 0;
491	/* we assume a quite fast sequence here ([off]->on->off)
492	* Revisit: fast-changing brightness. */
493	if (atomic_read(&led->active) > 1)
494	return 0;
495	data->next_green = (u8) value;
496	break;
497	case BLUE:
498	/* bail out if there's no change */
499	if (data->next_blue == (u8) value)
500	return 0;
501	/* we assume a quite fast sequence here ([off]->on->off)
502	* Revisit: fast-changing brightness. */
503	if (atomic_read(&led->active) > 1)
504	return 0;
505	data->next_blue = (u8) value;
506	break;
507
508	default:
509	dev_err(&led->i2c_client->dev, "BlinkM: unknown color.\n");
510	return -EINVAL;
511	}
512
513	bl_work = kzalloc(sizeof(*bl_work), GFP_ATOMIC);
514	if (!bl_work)
515	return -ENOMEM;
516
517	atomic_inc(&led->active);
518	dev_dbg(&led->i2c_client->dev,
519	"#TO_SCHED# next_red = %d, next_green = %d,"
520	" next_blue = %d, active = %d\n",
521	data->next_red, data->next_green,
522	data->next_blue, atomic_read(&led->active));
523
524	/* a fresh work _item_ for each change */
525	bl_work->blinkm_led = led;
526	INIT_WORK(&bl_work->work, led_work);
527	/* queue work in own queue for easy sync on exit*/
528	schedule_work(&bl_work->work);
529
530	return 0;
531	}
532
533	static void blinkm_led_red_set(struct led_classdev *led_cdev,
534	enum led_brightness value)
535	{
536	blinkm_led_common_set(led_cdev, value, RED);
537	}
538
539	static void blinkm_led_green_set(struct led_classdev *led_cdev,
540	enum led_brightness value)
541	{
542	blinkm_led_common_set(led_cdev, value, GREEN);
543	}
544
545	static void blinkm_led_blue_set(struct led_classdev *led_cdev,
546	enum led_brightness value)
547	{
548	blinkm_led_common_set(led_cdev, value, BLUE);
549	}
550
551	static void blinkm_init_hw(struct i2c_client *client)
552	{
553	int ret;
554	ret = blinkm_transfer_hw(client, BLM_STOP_SCRIPT);
555	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
556	}
557
558	static int blinkm_test_run(struct i2c_client *client)
559	{
560	int ret;
561	struct blinkm_data *data = i2c_get_clientdata(client);
562
563	data->next_red = 0x01;
564	data->next_green = 0x05;
565	data->next_blue = 0x10;
566	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
567	if (ret < 0)
568	return ret;
569	msleep(2000);
570
571	data->next_red = 0x25;
572	data->next_green = 0x10;
573	data->next_blue = 0x31;
574	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
575	if (ret < 0)
576	return ret;
577	msleep(2000);
578
579	data->next_hue = 0x50;
580	data->next_saturation = 0x10;
581	data->next_brightness = 0x20;
582	ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
583	if (ret < 0)
584	return ret;
585	msleep(2000);
586
587	return 0;
588	}
589
590	/* Return 0 if detection is successful, -ENODEV otherwise */
591	static int blinkm_detect(struct i2c_client client, struct i2c_board_info info)
592	{
593	struct i2c_adapter *adapter = client->adapter;
594	int ret;
595	int count = 99;
596	u8 tmpargs[7];
597
598	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
599	\| I2C_FUNC_SMBUS_WORD_DATA
600	\| I2C_FUNC_SMBUS_WRITE_BYTE))
601	return -ENODEV;
602
603	/* Now, we do the remaining detection. Simple for now. */
604	/* We might need more guards to protect other i2c slaves */
605
606	/* make sure the blinkM is balanced (read/writes) */
607	while (count > 0) {
608	ret = blinkm_write(client, BLM_GET_ADDR, NULL);
609	usleep_range(5000, 10000);
610	ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
611	usleep_range(5000, 10000);
612	if (tmpargs[0] == 0x09)
613	count = 0;
614	count--;
615	}
616
617	/* Step 1: Read BlinkM address back - cmd_char 'a' */
618	ret = blinkm_write(client, BLM_GET_ADDR, NULL);
619	if (ret < 0)
620	return ret;
621	usleep_range(20000, 30000); /* allow a small delay */
622	ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
623	if (ret < 0)
624	return ret;
625
626	if (tmpargs[0] != 0x09) {
627	dev_err(&client->dev, "enodev DEV ADDR = 0x%02X\n", tmpargs[0]);
628	return -ENODEV;
629	}
630
631	strlcpy(info->type, "blinkm", I2C_NAME_SIZE);
632	return 0;
633	}
634
635	static int __devinit blinkm_probe(struct i2c_client *client,
636	const struct i2c_device_id *id)
637	{
638	struct blinkm_data *data;
639	struct blinkm_led *led[3];
640	int err, i;
641	char blinkm_led_name[28];
642
643	data = devm_kzalloc(&client->dev,
644	sizeof(struct blinkm_data), GFP_KERNEL);
645	if (!data) {
646	err = -ENOMEM;
647	goto exit;
648	}
649
650	data->i2c_addr = 0x09;
651	data->i2c_addr = 0x08;
652	/* i2c addr - use fake addr of 0x08 initially (real is 0x09) */
653	data->fw_ver = 0xfe;
654	/* firmware version - use fake until we read real value
655	* (currently broken - BlinkM confused!) */
656	data->script_id = 0x01;
657	data->i2c_client = client;
658
659	i2c_set_clientdata(client, data);
660	mutex_init(&data->update_lock);
661
662	/* Register sysfs hooks */
663	err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
664	if (err < 0) {
665	dev_err(&client->dev, "couldn't register sysfs group\n");
666	goto exit;
667	}
668
669	for (i = 0; i < 3; i++) {
670	/* RED = 0, GREEN = 1, BLUE = 2 */
671	led[i] = &data->blinkm_leds[i];
672	led[i]->i2c_client = client;
673	led[i]->id = i;
674	led[i]->led_cdev.max_brightness = 255;
675	led[i]->led_cdev.flags = LED_CORE_SUSPENDRESUME;
676	atomic_set(&led[i]->active, 0);
677	switch (i) {
678	case RED:
679	snprintf(blinkm_led_name, sizeof(blinkm_led_name),
680	"blinkm-%d-%d-red",
681	client->adapter->nr,
682	client->addr);
683	led[i]->led_cdev.name = blinkm_led_name;
684	led[i]->led_cdev.brightness_set = blinkm_led_red_set;
685	err = led_classdev_register(&client->dev,
686	&led[i]->led_cdev);
687	if (err < 0) {
688	dev_err(&client->dev,
689	"couldn't register LED %s\n",
690	led[i]->led_cdev.name);
691	goto failred;
692	}
693	break;
694	case GREEN:
695	snprintf(blinkm_led_name, sizeof(blinkm_led_name),
696	"blinkm-%d-%d-green",
697	client->adapter->nr,
698	client->addr);
699	led[i]->led_cdev.name = blinkm_led_name;
700	led[i]->led_cdev.brightness_set = blinkm_led_green_set;
701	err = led_classdev_register(&client->dev,
702	&led[i]->led_cdev);
703	if (err < 0) {
704	dev_err(&client->dev,
705	"couldn't register LED %s\n",
706	led[i]->led_cdev.name);
707	goto failgreen;
708	}
709	break;
710	case BLUE:
711	snprintf(blinkm_led_name, sizeof(blinkm_led_name),
712	"blinkm-%d-%d-blue",
713	client->adapter->nr,
714	client->addr);
715	led[i]->led_cdev.name = blinkm_led_name;
716	led[i]->led_cdev.brightness_set = blinkm_led_blue_set;
717	err = led_classdev_register(&client->dev,
718	&led[i]->led_cdev);
719	if (err < 0) {
720	dev_err(&client->dev,
721	"couldn't register LED %s\n",
722	led[i]->led_cdev.name);
723	goto failblue;
724	}
725	break;
726	} /* end switch */
727	} /* end for */
728
729	/* Initialize the blinkm */
730	blinkm_init_hw(client);
731
732	return 0;
733
734	failblue:
735	led_classdev_unregister(&led[GREEN]->led_cdev);
736
737	failgreen:
738	led_classdev_unregister(&led[RED]->led_cdev);
739
740	failred:
741	sysfs_remove_group(&client->dev.kobj, &blinkm_group);
742	exit:
743	return err;
744	}
745
746	static int __devexit blinkm_remove(struct i2c_client *client)
747	{
748	struct blinkm_data *data = i2c_get_clientdata(client);
749	int ret = 0;
750	int i;
751
752	/* make sure no workqueue entries are pending */
753	for (i = 0; i < 3; i++) {
754	flush_scheduled_work();
755	led_classdev_unregister(&data->blinkm_leds[i].led_cdev);
756	}
757
758	/* reset rgb */
759	data->next_red = 0x00;
760	data->next_green = 0x00;
761	data->next_blue = 0x00;
762	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
763	if (ret < 0)
764	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
765
766	/* reset hsb */
767	data->next_hue = 0x00;
768	data->next_saturation = 0x00;
769	data->next_brightness = 0x00;
770	ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
771	if (ret < 0)
772	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
773
774	/* red fade to off */
775	data->next_red = 0xff;
776	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
777	if (ret < 0)
778	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
779
780	/* off */
781	data->next_red = 0x00;
782	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
783	if (ret < 0)
784	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
785
786	sysfs_remove_group(&client->dev.kobj, &blinkm_group);
787	return 0;
788	}
789
790	static const struct i2c_device_id blinkm_id[] = {
791	{"blinkm", 0},
792	{}
793	};
794
795	MODULE_DEVICE_TABLE(i2c, blinkm_id);
796
797	/* This is the driver that will be inserted */
798	static struct i2c_driver blinkm_driver = {
799	.class = I2C_CLASS_HWMON,
800	.driver = {
801	.name = "blinkm",
802	},
803	.probe = blinkm_probe,
804	.remove = __devexit_p(blinkm_remove),
805	.id_table = blinkm_id,
806	.detect = blinkm_detect,
807	.address_list = normal_i2c,
808	};
809
810	module_i2c_driver(blinkm_driver);
811
812	MODULE_AUTHOR("Jan-Simon Moeller <dl9pf@gmx.de>");
813	MODULE_DESCRIPTION("BlinkM RGB LED driver");
814	MODULE_LICENSE("GPL");
815
816

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/leds/leds-blinkm.c

interactive