?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / leds / leds-blinkm.c
blob66d0a57db2210b01ffe2fa0ceb9e5a8f449b6c74
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 case GREEN:
165 return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green);
166 case BLUE:
167 return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue);
168 default:
169 return -EINVAL;
170 }
171 return -EINVAL;
172 }
173
174 static int store_color_common(struct device *dev, const char *buf, int color)
175 {
176 struct i2c_client *client;
177 struct blinkm_data *data;
178 int ret;
179 u8 value;
180
181 client = to_i2c_client(dev);
182 data = i2c_get_clientdata(client);
183
184 ret = kstrtou8(buf, 10, &value);
185 if (ret < 0) {
186 dev_err(dev, "BlinkM: value too large!\n");
187 return ret;
188 }
189
190 switch (color) {
191 case RED:
192 data->next_red = value;
193 break;
194 case GREEN:
195 data->next_green = value;
196 break;
197 case BLUE:
198 data->next_blue = value;
199 break;
200 default:
201 return -EINVAL;
202 }
203
204 dev_dbg(dev, "next_red = %d, next_green = %d, next_blue = %d\n",
205 data->next_red, data->next_green, data->next_blue);
206
207 /* if mode ... */
208 ret = blinkm_transfer_hw(client, BLM_GO_RGB);
209 if (ret < 0) {
210 dev_err(dev, "BlinkM: can't set RGB\n");
211 return ret;
212 }
213 return 0;
214 }
215
216 static ssize_t show_red(struct device *dev, struct device_attribute *attr,
217 char *buf)
218 {
219 return show_color_common(dev, buf, RED);
220 }
221
222 static ssize_t store_red(struct device *dev, struct device_attribute *attr,
223 const char *buf, size_t count)
224 {
225 int ret;
226
227 ret = store_color_common(dev, buf, RED);
228 if (ret < 0)
229 return ret;
230 return count;
231 }
232
233 static DEVICE_ATTR(red, S_IRUGO | S_IWUSR, show_red, store_red);
234
235 static ssize_t show_green(struct device *dev, struct device_attribute *attr,
236 char *buf)
237 {
238 return show_color_common(dev, buf, GREEN);
239 }
240
241 static ssize_t store_green(struct device *dev, struct device_attribute *attr,
242 const char *buf, size_t count)
243 {
244
245 int ret;
246
247 ret = store_color_common(dev, buf, GREEN);
248 if (ret < 0)
249 return ret;
250 return count;
251 }
252
253 static DEVICE_ATTR(green, S_IRUGO | S_IWUSR, show_green, store_green);
254
255 static ssize_t show_blue(struct device *dev, struct device_attribute *attr,
256 char *buf)
257 {
258 return show_color_common(dev, buf, BLUE);
259 }
260
261 static ssize_t store_blue(struct device *dev, struct device_attribute *attr,
262 const char *buf, size_t count)
263 {
264 int ret;
265
266 ret = store_color_common(dev, buf, BLUE);
267 if (ret < 0)
268 return ret;
269 return count;
270 }
271
272 static DEVICE_ATTR(blue, S_IRUGO | S_IWUSR, show_blue, store_blue);
273
274 static ssize_t show_test(struct device *dev, struct device_attribute *attr,
275 char *buf)
276 {
277 return scnprintf(buf, PAGE_SIZE,
278 "#Write into test to start test sequence!#\n");
279 }
280
281 static ssize_t store_test(struct device *dev, struct device_attribute *attr,
282 const char *buf, size_t count)
283 {
284
285 struct i2c_client *client;
286 int ret;
287 client = to_i2c_client(dev);
288
289 /*test */
290 ret = blinkm_test_run(client);
291 if (ret < 0)
292 return ret;
293
294 return count;
295 }
296
297 static DEVICE_ATTR(test, S_IRUGO | S_IWUSR, show_test, store_test);
298
299 /* TODO: HSB, fade, timeadj, script ... */
300
301 static struct attribute *blinkm_attrs[] = {
302 &dev_attr_red.attr,
303 &dev_attr_green.attr,
304 &dev_attr_blue.attr,
305 &dev_attr_test.attr,
306 NULL,
307 };
308
309 static struct attribute_group blinkm_group = {
310 .name = "blinkm",
311 .attrs = blinkm_attrs,
312 };
313
314 static int blinkm_write(struct i2c_client *client, int cmd, u8 *arg)
315 {
316 int result;
317 int i;
318 int arglen = blinkm_cmds[cmd].nr_args;
319 /* write out cmd to blinkm - always / default step */
320 result = i2c_smbus_write_byte(client, blinkm_cmds[cmd].cmdbyte);
321 if (result < 0)
322 return result;
323 /* no args to write out */
324 if (arglen == 0)
325 return 0;
326
327 for (i = 0; i < arglen; i++) {
328 /* repeat for arglen */
329 result = i2c_smbus_write_byte(client, arg[i]);
330 if (result < 0)
331 return result;
332 }
333 return 0;
334 }
335
336 static int blinkm_read(struct i2c_client *client, int cmd, u8 *arg)
337 {
338 int result;
339 int i;
340 int retlen = blinkm_cmds[cmd].nr_ret;
341 for (i = 0; i < retlen; i++) {
342 /* repeat for retlen */
343 result = i2c_smbus_read_byte(client);
344 if (result < 0)
345 return result;
346 arg[i] = result;
347 }
348
349 return 0;
350 }
351
352 static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
353 {
354 /* the protocol is simple but non-standard:
355 * e.g. cmd 'g' (= 0x67) for "get device address"
356 * - which defaults to 0x09 - would be the sequence:
357 * a) write 0x67 to the device (byte write)
358 * b) read the value (0x09) back right after (byte read)
359 *
360 * Watch out for "unfinished" sequences (i.e. not enough reads
361 * or writes after a command. It will make the blinkM misbehave.
362 * Sequence is key here.
363 */
364
365 /* args / return are in private data struct */
366 struct blinkm_data *data = i2c_get_clientdata(client);
367
368 /* We start hardware transfers which are not to be
369 * mixed with other commands. Aquire a lock now. */
370 if (mutex_lock_interruptible(&data->update_lock) < 0)
371 return -EAGAIN;
372
373 /* switch cmd - usually write before reads */
374 switch (cmd) {
375 case BLM_FADE_RAND_RGB:
376 case BLM_GO_RGB:
377 case BLM_FADE_RGB:
378 data->args[0] = data->next_red;
379 data->args[1] = data->next_green;
380 data->args[2] = data->next_blue;
381 blinkm_write(client, cmd, data->args);
382 data->red = data->args[0];
383 data->green = data->args[1];
384 data->blue = data->args[2];
385 break;
386 case BLM_FADE_HSB:
387 case BLM_FADE_RAND_HSB:
388 data->args[0] = data->next_hue;
389 data->args[1] = data->next_saturation;
390 data->args[2] = data->next_brightness;
391 blinkm_write(client, cmd, data->args);
392 data->hue = data->next_hue;
393 data->saturation = data->next_saturation;
394 data->brightness = data->next_brightness;
395 break;
396 case BLM_PLAY_SCRIPT:
397 data->args[0] = data->script_id;
398 data->args[1] = data->script_repeats;
399 data->args[2] = data->script_startline;
400 blinkm_write(client, cmd, data->args);
401 break;
402 case BLM_STOP_SCRIPT:
403 blinkm_write(client, cmd, NULL);
404 break;
405 case BLM_GET_CUR_RGB:
406 data->args[0] = data->red;
407 data->args[1] = data->green;
408 data->args[2] = data->blue;
409 blinkm_write(client, cmd, NULL);
410 blinkm_read(client, cmd, data->args);
411 data->red = data->args[0];
412 data->green = data->args[1];
413 data->blue = data->args[2];
414 break;
415 case BLM_GET_ADDR:
416 data->args[0] = data->i2c_addr;
417 blinkm_write(client, cmd, NULL);
418 blinkm_read(client, cmd, data->args);
419 data->i2c_addr = data->args[0];
420 break;
421 case BLM_SET_TIME_ADJ:
422 case BLM_SET_FADE_SPEED:
423 case BLM_READ_SCRIPT_LINE:
424 case BLM_WRITE_SCRIPT_LINE:
425 case BLM_SET_SCRIPT_LR:
426 case BLM_SET_ADDR:
427 case BLM_GET_FW_VER:
428 case BLM_SET_STARTUP_PARAM:
429 dev_err(&client->dev,
430 "BlinkM: cmd %d not implemented yet.\n", cmd);
431 break;
432 default:
433 dev_err(&client->dev, "BlinkM: unknown command %d\n", cmd);
434 mutex_unlock(&data->update_lock);
435 return -EINVAL;
436 } /* end switch(cmd) */
437
438 /* transfers done, unlock */
439 mutex_unlock(&data->update_lock);
440 return 0;
441 }
442
443 static void led_work(struct work_struct *work)
444 {
445 int ret;
446 struct blinkm_led *led;
447 struct blinkm_data *data ;
448 struct blinkm_work *blm_work = work_to_blmwork(work);
449
450 led = blm_work->blinkm_led;
451 data = i2c_get_clientdata(led->i2c_client);
452 ret = blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB);
453 atomic_dec(&led->active);
454 dev_dbg(&led->i2c_client->dev,
455 "# DONE # next_red = %d, next_green = %d,"
456 " next_blue = %d, active = %d\n",
457 data->next_red, data->next_green,
458 data->next_blue, atomic_read(&led->active));
459 kfree(blm_work);
460 }
461
462 static int blinkm_led_common_set(struct led_classdev *led_cdev,
463 enum led_brightness value, int color)
464 {
465 /* led_brightness is 0, 127 or 255 - we just use it here as-is */
466 struct blinkm_led *led = cdev_to_blmled(led_cdev);
467 struct blinkm_data *data = i2c_get_clientdata(led->i2c_client);
468 struct blinkm_work *bl_work;
469
470 switch (color) {
471 case RED:
472 /* bail out if there's no change */
473 if (data->next_red == (u8) value)
474 return 0;
475 /* we assume a quite fast sequence here ([off]->on->off)
476 * think of network led trigger - we cannot blink that fast, so
477 * in case we already have a off->on->off transition queued up,
478 * we refuse to queue up more.
479 * Revisit: fast-changing brightness. */
480 if (atomic_read(&led->active) > 1)
481 return 0;
482 data->next_red = (u8) value;
483 break;
484 case GREEN:
485 /* bail out if there's no change */
486 if (data->next_green == (u8) value)
487 return 0;
488 /* we assume a quite fast sequence here ([off]->on->off)
489 * Revisit: fast-changing brightness. */
490 if (atomic_read(&led->active) > 1)
491 return 0;
492 data->next_green = (u8) value;
493 break;
494 case BLUE:
495 /* bail out if there's no change */
496 if (data->next_blue == (u8) value)
497 return 0;
498 /* we assume a quite fast sequence here ([off]->on->off)
499 * Revisit: fast-changing brightness. */
500 if (atomic_read(&led->active) > 1)
501 return 0;
502 data->next_blue = (u8) value;
503 break;
504
505 default:
506 dev_err(&led->i2c_client->dev, "BlinkM: unknown color.\n");
507 return -EINVAL;
508 }
509
510 bl_work = kzalloc(sizeof(*bl_work), GFP_ATOMIC);
511 if (!bl_work)
512 return -ENOMEM;
513
514 atomic_inc(&led->active);
515 dev_dbg(&led->i2c_client->dev,
516 "#TO_SCHED# next_red = %d, next_green = %d,"
517 " next_blue = %d, active = %d\n",
518 data->next_red, data->next_green,
519 data->next_blue, atomic_read(&led->active));
520
521 /* a fresh work _item_ for each change */
522 bl_work->blinkm_led = led;
523 INIT_WORK(&bl_work->work, led_work);
524 /* queue work in own queue for easy sync on exit*/
525 schedule_work(&bl_work->work);
526
527 return 0;
528 }
529
530 static void blinkm_led_red_set(struct led_classdev *led_cdev,
531 enum led_brightness value)
532 {
533 blinkm_led_common_set(led_cdev, value, RED);
534 }
535
536 static void blinkm_led_green_set(struct led_classdev *led_cdev,
537 enum led_brightness value)
538 {
539 blinkm_led_common_set(led_cdev, value, GREEN);
540 }
541
542 static void blinkm_led_blue_set(struct led_classdev *led_cdev,
543 enum led_brightness value)
544 {
545 blinkm_led_common_set(led_cdev, value, BLUE);
546 }
547
548 static void blinkm_init_hw(struct i2c_client *client)
549 {
550 int ret;
551 ret = blinkm_transfer_hw(client, BLM_STOP_SCRIPT);
552 ret = blinkm_transfer_hw(client, BLM_GO_RGB);
553 }
554
555 static int blinkm_test_run(struct i2c_client *client)
556 {
557 int ret;
558 struct blinkm_data *data = i2c_get_clientdata(client);
559
560 data->next_red = 0x01;
561 data->next_green = 0x05;
562 data->next_blue = 0x10;
563 ret = blinkm_transfer_hw(client, BLM_GO_RGB);
564 if (ret < 0)
565 return ret;
566 msleep(2000);
567
568 data->next_red = 0x25;
569 data->next_green = 0x10;
570 data->next_blue = 0x31;
571 ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
572 if (ret < 0)
573 return ret;
574 msleep(2000);
575
576 data->next_hue = 0x50;
577 data->next_saturation = 0x10;
578 data->next_brightness = 0x20;
579 ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
580 if (ret < 0)
581 return ret;
582 msleep(2000);
583
584 return 0;
585 }
586
587 /* Return 0 if detection is successful, -ENODEV otherwise */
588 static int blinkm_detect(struct i2c_client *client, struct i2c_board_info *info)
589 {
590 struct i2c_adapter *adapter = client->adapter;
591 int ret;
592 int count = 99;
593 u8 tmpargs[7];
594
595 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
596 | I2C_FUNC_SMBUS_WORD_DATA
597 | I2C_FUNC_SMBUS_WRITE_BYTE))
598 return -ENODEV;
599
600 /* Now, we do the remaining detection. Simple for now. */
601 /* We might need more guards to protect other i2c slaves */
602
603 /* make sure the blinkM is balanced (read/writes) */
604 while (count > 0) {
605 ret = blinkm_write(client, BLM_GET_ADDR, NULL);
606 usleep_range(5000, 10000);
607 ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
608 usleep_range(5000, 10000);
609 if (tmpargs[0] == 0x09)
610 count = 0;
611 count--;
612 }
613
614 /* Step 1: Read BlinkM address back - cmd_char 'a' */
615 ret = blinkm_write(client, BLM_GET_ADDR, NULL);
616 if (ret < 0)
617 return ret;
618 usleep_range(20000, 30000); /* allow a small delay */
619 ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
620 if (ret < 0)
621 return ret;
622
623 if (tmpargs[0] != 0x09) {
624 dev_err(&client->dev, "enodev DEV ADDR = 0x%02X\n", tmpargs[0]);
625 return -ENODEV;
626 }
627
628 strlcpy(info->type, "blinkm", I2C_NAME_SIZE);
629 return 0;
630 }
631
632 static int blinkm_probe(struct i2c_client *client,
633 const struct i2c_device_id *id)
634 {
635 struct blinkm_data *data;
636 struct blinkm_led *led[3];
637 int err, i;
638 char blinkm_led_name[28];
639
640 data = devm_kzalloc(&client->dev,
641 sizeof(struct blinkm_data), GFP_KERNEL);
642 if (!data) {
643 err = -ENOMEM;
644 goto exit;
645 }
646
647 data->i2c_addr = 0x09;
648 data->i2c_addr = 0x08;
649 /* i2c addr - use fake addr of 0x08 initially (real is 0x09) */
650 data->fw_ver = 0xfe;
651 /* firmware version - use fake until we read real value
652 * (currently broken - BlinkM confused!) */
653 data->script_id = 0x01;
654 data->i2c_client = client;
655
656 i2c_set_clientdata(client, data);
657 mutex_init(&data->update_lock);
658
659 /* Register sysfs hooks */
660 err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
661 if (err < 0) {
662 dev_err(&client->dev, "couldn't register sysfs group\n");
663 goto exit;
664 }
665
666 for (i = 0; i < 3; i++) {
667 /* RED = 0, GREEN = 1, BLUE = 2 */
668 led[i] = &data->blinkm_leds[i];
669 led[i]->i2c_client = client;
670 led[i]->id = i;
671 led[i]->led_cdev.max_brightness = 255;
672 led[i]->led_cdev.flags = LED_CORE_SUSPENDRESUME;
673 atomic_set(&led[i]->active, 0);
674 switch (i) {
675 case RED:
676 snprintf(blinkm_led_name, sizeof(blinkm_led_name),
677 "blinkm-%d-%d-red",
678 client->adapter->nr,
679 client->addr);
680 led[i]->led_cdev.name = blinkm_led_name;
681 led[i]->led_cdev.brightness_set = blinkm_led_red_set;
682 err = led_classdev_register(&client->dev,
683 &led[i]->led_cdev);
684 if (err < 0) {
685 dev_err(&client->dev,
686 "couldn't register LED %s\n",
687 led[i]->led_cdev.name);
688 goto failred;
689 }
690 break;
691 case GREEN:
692 snprintf(blinkm_led_name, sizeof(blinkm_led_name),
693 "blinkm-%d-%d-green",
694 client->adapter->nr,
695 client->addr);
696 led[i]->led_cdev.name = blinkm_led_name;
697 led[i]->led_cdev.brightness_set = blinkm_led_green_set;
698 err = led_classdev_register(&client->dev,
699 &led[i]->led_cdev);
700 if (err < 0) {
701 dev_err(&client->dev,
702 "couldn't register LED %s\n",
703 led[i]->led_cdev.name);
704 goto failgreen;
705 }
706 break;
707 case BLUE:
708 snprintf(blinkm_led_name, sizeof(blinkm_led_name),
709 "blinkm-%d-%d-blue",
710 client->adapter->nr,
711 client->addr);
712 led[i]->led_cdev.name = blinkm_led_name;
713 led[i]->led_cdev.brightness_set = blinkm_led_blue_set;
714 err = led_classdev_register(&client->dev,
715 &led[i]->led_cdev);
716 if (err < 0) {
717 dev_err(&client->dev,
718 "couldn't register LED %s\n",
719 led[i]->led_cdev.name);
720 goto failblue;
721 }
722 break;
723 } /* end switch */
724 } /* end for */
725
726 /* Initialize the blinkm */
727 blinkm_init_hw(client);
728
729 return 0;
730
731 failblue:
732 led_classdev_unregister(&led[GREEN]->led_cdev);
733
734 failgreen:
735 led_classdev_unregister(&led[RED]->led_cdev);
736
737 failred:
738 sysfs_remove_group(&client->dev.kobj, &blinkm_group);
739 exit:
740 return err;
741 }
742
743 static int blinkm_remove(struct i2c_client *client)
744 {
745 struct blinkm_data *data = i2c_get_clientdata(client);
746 int ret = 0;
747 int i;
748
749 /* make sure no workqueue entries are pending */
750 for (i = 0; i < 3; i++) {
751 flush_scheduled_work();
752 led_classdev_unregister(&data->blinkm_leds[i].led_cdev);
753 }
754
755 /* reset rgb */
756 data->next_red = 0x00;
757 data->next_green = 0x00;
758 data->next_blue = 0x00;
759 ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
760 if (ret < 0)
761 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
762
763 /* reset hsb */
764 data->next_hue = 0x00;
765 data->next_saturation = 0x00;
766 data->next_brightness = 0x00;
767 ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
768 if (ret < 0)
769 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
770
771 /* red fade to off */
772 data->next_red = 0xff;
773 ret = blinkm_transfer_hw(client, BLM_GO_RGB);
774 if (ret < 0)
775 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
776
777 /* off */
778 data->next_red = 0x00;
779 ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
780 if (ret < 0)
781 dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
782
783 sysfs_remove_group(&client->dev.kobj, &blinkm_group);
784 return 0;
785 }
786
787 static const struct i2c_device_id blinkm_id[] = {
788 {"blinkm", 0},
789 {}
790 };
791
792 MODULE_DEVICE_TABLE(i2c, blinkm_id);
793
794 /* This is the driver that will be inserted */
795 static struct i2c_driver blinkm_driver = {
796 .class = I2C_CLASS_HWMON,
797 .driver = {
798 .name = "blinkm",
799 },
800 .probe = blinkm_probe,
801 .remove = blinkm_remove,
802 .id_table = blinkm_id,
803 .detect = blinkm_detect,
804 .address_list = normal_i2c,
805 };
806
807 module_i2c_driver(blinkm_driver);
808
809 MODULE_AUTHOR("Jan-Simon Moeller <dl9pf@gmx.de>");
810 MODULE_DESCRIPTION("BlinkM RGB LED driver");
811 MODULE_LICENSE("GPL");
812
Linux with added FPC-III support