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