[SCSI] libsas: execute transport link resets with libata-eh via host workqueue
[linux-2.6.git] / drivers / leds / leds-tca6507.c
1 /*
2  * leds-tca6507
3  *
4  * The TCA6507 is a programmable LED controller that can drive 7
5  * separate lines either by holding them low, or by pulsing them
6  * with modulated width.
7  * The modulation can be varied in a simple pattern to produce a blink or
8  * double-blink.
9  *
10  * This driver can configure each line either as a 'GPIO' which is out-only
11  * (no pull-up) or as an LED with variable brightness and hardware-assisted
12  * blinking.
13  *
14  * Apart from OFF and ON there are three programmable brightness levels which
15  * can be programmed from 0 to 15 and indicate how many 500usec intervals in
16  * each 8msec that the led is 'on'.  The levels are named MASTER, BANK0 and
17  * BANK1.
18  *
19  * There are two different blink rates that can be programmed, each with
20  * separate time for rise, on, fall, off and second-off.  Thus if 3 or more
21  * different non-trivial rates are required, software must be used for the extra
22  * rates. The two different blink rates must align with the two levels BANK0 and
23  * BANK1.
24  * This driver does not support double-blink so 'second-off' always matches
25  * 'off'.
26  *
27  * Only 16 different times can be programmed in a roughly logarithmic scale from
28  * 64ms to 16320ms.  To be precise the possible times are:
29  *    0, 64, 128, 192, 256, 384, 512, 768,
30  *    1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
31  *
32  * Times that cannot be closely matched with these must be
33  * handled in software.  This driver allows 12.5% error in matching.
34  *
35  * This driver does not allow rise/fall rates to be set explicitly.  When trying
36  * to match a given 'on' or 'off' period, an appropriate pair of 'change' and
37  * 'hold' times are chosen to get a close match.  If the target delay is even,
38  * the 'change' number will be the smaller; if odd, the 'hold' number will be
39  * the smaller.
40
41  * Choosing pairs of delays with 12.5% errors allows us to match delays in the
42  * ranges: 56-72, 112-144, 168-216, 224-27504, 28560-36720.
43  * 26% of the achievable sums can be matched by multiple pairings. For example
44  * 1536 == 1536+0, 1024+512, or 768+768.  This driver will always choose the
45  * pairing with the least maximum - 768+768 in this case.  Other pairings are
46  * not available.
47  *
48  * Access to the 3 levels and 2 blinks are on a first-come, first-served basis.
49  * Access can be shared by multiple leds if they have the same level and
50  * either same blink rates, or some don't blink.
51  * When a led changes, it relinquishes access and tries again, so it might
52  * lose access to hardware blink.
53  * If a blink engine cannot be allocated, software blink is used.
54  * If the desired brightness cannot be allocated, the closest available non-zero
55  * brightness is used.  As 'full' is always available, the worst case would be
56  * to have two different blink rates at '1', with Max at '2', then other leds
57  * will have to choose between '2' and '16'.  Hopefully this is not likely.
58  *
59  * Each bank (BANK0 and BANK1) has two usage counts - LEDs using the brightness
60  * and LEDs using the blink.  It can only be reprogrammed when the appropriate
61  * counter is zero.  The MASTER level has a single usage count.
62  *
63  * Each Led has programmable 'on' and 'off' time as milliseconds.  With each
64  * there is a flag saying if it was explicitly requested or defaulted.
65  * Similarly the banks know if each time was explicit or a default.  Defaults
66  * are permitted to be changed freely - they are not recognised when matching.
67  *
68  *
69  * An led-tca6507 device must be provided with platform data.  This data
70  * lists for each output: the name, default trigger, and whether the signal
71  * is being used as a GPiO rather than an led.  'struct led_plaform_data'
72  * is used for this.  If 'name' is NULL, the output isn't used.  If 'flags'
73  * is TCA6507_MAKE_CPIO, the output is a GPO.
74  * The "struct led_platform_data" can be embedded in a
75  * "struct tca6507_platform_data" which adds a 'gpio_base' for the GPiOs,
76  * and a 'setup' callback which is called once the GPiOs are available.
77  *
78  */
79
80 #include <linux/module.h>
81 #include <linux/slab.h>
82 #include <linux/leds.h>
83 #include <linux/err.h>
84 #include <linux/i2c.h>
85 #include <linux/gpio.h>
86 #include <linux/workqueue.h>
87 #include <linux/leds-tca6507.h>
88
89 /* LED select registers determine the source that drives LED outputs */
90 #define TCA6507_LS_LED_OFF      0x0     /* Output HI-Z (off) */
91 #define TCA6507_LS_LED_OFF1     0x1     /* Output HI-Z (off) - not used */
92 #define TCA6507_LS_LED_PWM0     0x2     /* Output LOW with Bank0 rate */
93 #define TCA6507_LS_LED_PWM1     0x3     /* Output LOW with Bank1 rate */
94 #define TCA6507_LS_LED_ON       0x4     /* Output LOW (on) */
95 #define TCA6507_LS_LED_MIR      0x5     /* Output LOW with Master Intensity */
96 #define TCA6507_LS_BLINK0       0x6     /* Blink at Bank0 rate */
97 #define TCA6507_LS_BLINK1       0x7     /* Blink at Bank1 rate */
98
99 enum {
100         BANK0,
101         BANK1,
102         MASTER,
103 };
104 static int bank_source[3] = {
105         TCA6507_LS_LED_PWM0,
106         TCA6507_LS_LED_PWM1,
107         TCA6507_LS_LED_MIR,
108 };
109 static int blink_source[2] = {
110         TCA6507_LS_BLINK0,
111         TCA6507_LS_BLINK1,
112 };
113
114 /* PWM registers */
115 #define TCA6507_REG_CNT                 11
116
117 /*
118  * 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output
119  * owns one bit in each register
120  */
121 #define TCA6507_FADE_ON                 0x03
122 #define TCA6507_FULL_ON                 0x04
123 #define TCA6507_FADE_OFF                0x05
124 #define TCA6507_FIRST_OFF               0x06
125 #define TCA6507_SECOND_OFF              0x07
126 #define TCA6507_MAX_INTENSITY           0x08
127 #define TCA6507_MASTER_INTENSITY        0x09
128 #define TCA6507_INITIALIZE              0x0A
129
130 #define INIT_CODE                       0x8
131
132 #define TIMECODES 16
133 static int time_codes[TIMECODES] = {
134         0, 64, 128, 192, 256, 384, 512, 768,
135         1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
136 };
137
138 /* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */
139 static inline int TO_LEVEL(int brightness)
140 {
141         return brightness >> 4;
142 }
143
144 /* ...and convert back */
145 static inline int TO_BRIGHT(int level)
146 {
147         if (level)
148                 return (level << 4) | 0xf;
149         return 0;
150 }
151
152 #define NUM_LEDS 7
153 struct tca6507_chip {
154         int                     reg_set;        /* One bit per register where
155                                                  * a '1' means the register
156                                                  * should be written */
157         u8                      reg_file[TCA6507_REG_CNT];
158         /* Bank 2 is Master Intensity and doesn't use times */
159         struct bank {
160                 int level;
161                 int ontime, offtime;
162                 int on_dflt, off_dflt;
163                 int time_use, level_use;
164         } bank[3];
165         struct i2c_client       *client;
166         struct work_struct      work;
167         spinlock_t              lock;
168
169         struct tca6507_led {
170                 struct tca6507_chip     *chip;
171                 struct led_classdev     led_cdev;
172                 int                     num;
173                 int                     ontime, offtime;
174                 int                     on_dflt, off_dflt;
175                 int                     bank;   /* Bank used, or -1 */
176                 int                     blink;  /* Set if hardware-blinking */
177         } leds[NUM_LEDS];
178 #ifdef CONFIG_GPIOLIB
179         struct gpio_chip                gpio;
180         const char                      *gpio_name[NUM_LEDS];
181         int                             gpio_map[NUM_LEDS];
182 #endif
183 };
184
185 static const struct i2c_device_id tca6507_id[] = {
186         { "tca6507" },
187         { }
188 };
189 MODULE_DEVICE_TABLE(i2c, tca6507_id);
190
191 static int choose_times(int msec, int *c1p, int *c2p)
192 {
193         /*
194          * Choose two timecodes which add to 'msec' as near as possible.
195          * The first returned is the 'on' or 'off' time.  The second is to be
196          * used as a 'fade-on' or 'fade-off' time.  If 'msec' is even,
197          * the first will not be smaller than the second.  If 'msec' is odd,
198          * the first will not be larger than the second.
199          * If we cannot get a sum within 1/8 of 'msec' fail with -EINVAL,
200          * otherwise return the sum that was achieved, plus 1 if the first is
201          * smaller.
202          * If two possibilities are equally good (e.g. 512+0, 256+256), choose
203          * the first pair so there is more change-time visible (i.e. it is
204          * softer).
205          */
206         int c1, c2;
207         int tmax = msec * 9 / 8;
208         int tmin = msec * 7 / 8;
209         int diff = 65536;
210
211         /* We start at '1' to ensure we never even think of choosing a
212          * total time of '0'.
213          */
214         for (c1 = 1; c1 < TIMECODES; c1++) {
215                 int t = time_codes[c1];
216                 if (t*2 < tmin)
217                         continue;
218                 if (t > tmax)
219                         break;
220                 for (c2 = 0; c2 <= c1; c2++) {
221                         int tt = t + time_codes[c2];
222                         int d;
223                         if (tt < tmin)
224                                 continue;
225                         if (tt > tmax)
226                                 break;
227                         /* This works! */
228                         d = abs(msec - tt);
229                         if (d >= diff)
230                                 continue;
231                         /* Best yet */
232                         *c1p = c1;
233                         *c2p = c2;
234                         diff = d;
235                         if (d == 0)
236                                 return msec;
237                 }
238         }
239         if (diff < 65536) {
240                 int actual;
241                 if (msec & 1) {
242                         c1 = *c2p;
243                         *c2p = *c1p;
244                         *c1p = c1;
245                 }
246                 actual = time_codes[*c1p] + time_codes[*c2p];
247                 if (*c1p < *c2p)
248                         return actual + 1;
249                 else
250                         return actual;
251         }
252         /* No close match */
253         return -EINVAL;
254 }
255
256 /*
257  * Update the register file with the appropriate 3-bit state for
258  * the given led.
259  */
260 static void set_select(struct tca6507_chip *tca, int led, int val)
261 {
262         int mask = (1 << led);
263         int bit;
264
265         for (bit = 0; bit < 3; bit++) {
266                 int n = tca->reg_file[bit] & ~mask;
267                 if (val & (1 << bit))
268                         n |= mask;
269                 if (tca->reg_file[bit] != n) {
270                         tca->reg_file[bit] = n;
271                         tca->reg_set |= (1 << bit);
272                 }
273         }
274 }
275
276 /* Update the register file with the appropriate 4-bit code for
277  * one bank or other.  This can be used for timers, for levels, or
278  * for initialisation.
279  */
280 static void set_code(struct tca6507_chip *tca, int reg, int bank, int new)
281 {
282         int mask = 0xF;
283         int n;
284         if (bank) {
285                 mask <<= 4;
286                 new <<= 4;
287         }
288         n = tca->reg_file[reg] & ~mask;
289         n |= new;
290         if (tca->reg_file[reg] != n) {
291                 tca->reg_file[reg] = n;
292                 tca->reg_set |= 1 << reg;
293         }
294 }
295
296 /* Update brightness level. */
297 static void set_level(struct tca6507_chip *tca, int bank, int level)
298 {
299         switch (bank) {
300         case BANK0:
301         case BANK1:
302                 set_code(tca, TCA6507_MAX_INTENSITY, bank, level);
303                 break;
304         case MASTER:
305                 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level);
306                 break;
307         }
308         tca->bank[bank].level = level;
309 }
310
311 /* Record all relevant time code for a given bank */
312 static void set_times(struct tca6507_chip *tca, int bank)
313 {
314         int c1, c2;
315         int result;
316
317         result = choose_times(tca->bank[bank].ontime, &c1, &c2);
318         dev_dbg(&tca->client->dev,
319                 "Chose on  times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1],
320                 c2, time_codes[c2], tca->bank[bank].ontime);
321         set_code(tca, TCA6507_FADE_ON, bank, c2);
322         set_code(tca, TCA6507_FULL_ON, bank, c1);
323         tca->bank[bank].ontime = result;
324
325         result = choose_times(tca->bank[bank].offtime, &c1, &c2);
326         dev_dbg(&tca->client->dev,
327                 "Chose off times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1],
328                 c2, time_codes[c2], tca->bank[bank].offtime);
329         set_code(tca, TCA6507_FADE_OFF, bank, c2);
330         set_code(tca, TCA6507_FIRST_OFF, bank, c1);
331         set_code(tca, TCA6507_SECOND_OFF, bank, c1);
332         tca->bank[bank].offtime = result;
333
334         set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);
335 }
336
337 /* Write all needed register of tca6507 */
338
339 static void tca6507_work(struct work_struct *work)
340 {
341         struct tca6507_chip *tca = container_of(work, struct tca6507_chip,
342                                                 work);
343         struct i2c_client *cl = tca->client;
344         int set;
345         u8 file[TCA6507_REG_CNT];
346         int r;
347
348         spin_lock_irq(&tca->lock);
349         set = tca->reg_set;
350         memcpy(file, tca->reg_file, TCA6507_REG_CNT);
351         tca->reg_set = 0;
352         spin_unlock_irq(&tca->lock);
353
354         for (r = 0; r < TCA6507_REG_CNT; r++)
355                 if (set & (1<<r))
356                         i2c_smbus_write_byte_data(cl, r, file[r]);
357 }
358
359 static void led_release(struct tca6507_led *led)
360 {
361         /* If led owns any resource, release it. */
362         struct tca6507_chip *tca = led->chip;
363         if (led->bank >= 0) {
364                 struct bank *b = tca->bank + led->bank;
365                 if (led->blink)
366                         b->time_use--;
367                 b->level_use--;
368         }
369         led->blink = 0;
370         led->bank = -1;
371 }
372
373 static int led_prepare(struct tca6507_led *led)
374 {
375         /* Assign this led to a bank, configuring that bank if necessary. */
376         int level = TO_LEVEL(led->led_cdev.brightness);
377         struct tca6507_chip *tca = led->chip;
378         int c1, c2;
379         int i;
380         struct bank *b;
381         int need_init = 0;
382
383         led->led_cdev.brightness = TO_BRIGHT(level);
384         if (level == 0) {
385                 set_select(tca, led->num, TCA6507_LS_LED_OFF);
386                 return 0;
387         }
388
389         if (led->ontime == 0 || led->offtime == 0) {
390                 /*
391                  * Just set the brightness, choosing first usable bank.
392                  * If none perfect, choose best.
393                  * Count backwards so we check MASTER bank first
394                  * to avoid wasting a timer.
395                  */
396                 int best = -1;/* full-on */
397                 int diff = 15-level;
398
399                 if (level == 15) {
400                         set_select(tca, led->num, TCA6507_LS_LED_ON);
401                         return 0;
402                 }
403
404                 for (i = MASTER; i >= BANK0; i--) {
405                         int d;
406                         if (tca->bank[i].level == level ||
407                             tca->bank[i].level_use == 0) {
408                                 best = i;
409                                 break;
410                         }
411                         d = abs(level - tca->bank[i].level);
412                         if (d < diff) {
413                                 diff = d;
414                                 best = i;
415                         }
416                 }
417                 if (best == -1) {
418                         /* Best brightness is full-on */
419                         set_select(tca, led->num, TCA6507_LS_LED_ON);
420                         led->led_cdev.brightness = LED_FULL;
421                         return 0;
422                 }
423
424                 if (!tca->bank[best].level_use)
425                         set_level(tca, best, level);
426
427                 tca->bank[best].level_use++;
428                 led->bank = best;
429                 set_select(tca, led->num, bank_source[best]);
430                 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);
431                 return 0;
432         }
433
434         /*
435          * We have on/off time so we need to try to allocate a timing bank.
436          * First check if times are compatible with hardware and give up if
437          * not.
438          */
439         if (choose_times(led->ontime, &c1, &c2) < 0)
440                 return -EINVAL;
441         if (choose_times(led->offtime, &c1, &c2) < 0)
442                 return -EINVAL;
443
444         for (i = BANK0; i <= BANK1; i++) {
445                 if (tca->bank[i].level_use == 0)
446                         /* not in use - it is ours! */
447                         break;
448                 if (tca->bank[i].level != level)
449                         /* Incompatible level - skip */
450                         /* FIX: if timer matches we maybe should consider
451                          * this anyway...
452                          */
453                         continue;
454
455                 if (tca->bank[i].time_use == 0)
456                         /* Timer not in use, and level matches - use it */
457                         break;
458
459                 if (!(tca->bank[i].on_dflt ||
460                       led->on_dflt ||
461                       tca->bank[i].ontime == led->ontime))
462                         /* on time is incompatible */
463                         continue;
464
465                 if (!(tca->bank[i].off_dflt ||
466                       led->off_dflt ||
467                       tca->bank[i].offtime == led->offtime))
468                         /* off time is incompatible */
469                         continue;
470
471                 /* looks like a suitable match */
472                 break;
473         }
474
475         if (i > BANK1)
476                 /* Nothing matches - how sad */
477                 return -EINVAL;
478
479         b = &tca->bank[i];
480         if (b->level_use == 0)
481                 set_level(tca, i, level);
482         b->level_use++;
483         led->bank = i;
484
485         if (b->on_dflt ||
486             !led->on_dflt ||
487             b->time_use == 0) {
488                 b->ontime = led->ontime;
489                 b->on_dflt = led->on_dflt;
490                 need_init = 1;
491         }
492
493         if (b->off_dflt ||
494             !led->off_dflt ||
495             b->time_use == 0) {
496                 b->offtime = led->offtime;
497                 b->off_dflt = led->off_dflt;
498                 need_init = 1;
499         }
500
501         if (need_init)
502                 set_times(tca, i);
503
504         led->ontime = b->ontime;
505         led->offtime = b->offtime;
506
507         b->time_use++;
508         led->blink = 1;
509         led->led_cdev.brightness = TO_BRIGHT(b->level);
510         set_select(tca, led->num, blink_source[i]);
511         return 0;
512 }
513
514 static int led_assign(struct tca6507_led *led)
515 {
516         struct tca6507_chip *tca = led->chip;
517         int err;
518         unsigned long flags;
519
520         spin_lock_irqsave(&tca->lock, flags);
521         led_release(led);
522         err = led_prepare(led);
523         if (err) {
524                 /*
525                  * Can only fail on timer setup.  In that case we need to
526                  * re-establish as steady level.
527                  */
528                 led->ontime = 0;
529                 led->offtime = 0;
530                 led_prepare(led);
531         }
532         spin_unlock_irqrestore(&tca->lock, flags);
533
534         if (tca->reg_set)
535                 schedule_work(&tca->work);
536         return err;
537 }
538
539 static void tca6507_brightness_set(struct led_classdev *led_cdev,
540                                    enum led_brightness brightness)
541 {
542         struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
543                                                led_cdev);
544         led->led_cdev.brightness = brightness;
545         led->ontime = 0;
546         led->offtime = 0;
547         led_assign(led);
548 }
549
550 static int tca6507_blink_set(struct led_classdev *led_cdev,
551                              unsigned long *delay_on,
552                              unsigned long *delay_off)
553 {
554         struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
555                                                led_cdev);
556
557         if (*delay_on == 0)
558                 led->on_dflt = 1;
559         else if (delay_on != &led_cdev->blink_delay_on)
560                 led->on_dflt = 0;
561         led->ontime = *delay_on;
562
563         if (*delay_off == 0)
564                 led->off_dflt = 1;
565         else if (delay_off != &led_cdev->blink_delay_off)
566                 led->off_dflt = 0;
567         led->offtime = *delay_off;
568
569         if (led->ontime == 0)
570                 led->ontime = 512;
571         if (led->offtime == 0)
572                 led->offtime = 512;
573
574         if (led->led_cdev.brightness == LED_OFF)
575                 led->led_cdev.brightness = LED_FULL;
576         if (led_assign(led) < 0) {
577                 led->ontime = 0;
578                 led->offtime = 0;
579                 led->led_cdev.brightness = LED_OFF;
580                 return -EINVAL;
581         }
582         *delay_on = led->ontime;
583         *delay_off = led->offtime;
584         return 0;
585 }
586
587 #ifdef CONFIG_GPIOLIB
588 static void tca6507_gpio_set_value(struct gpio_chip *gc,
589                                    unsigned offset, int val)
590 {
591         struct tca6507_chip *tca = container_of(gc, struct tca6507_chip, gpio);
592         unsigned long flags;
593
594         spin_lock_irqsave(&tca->lock, flags);
595         /*
596          * 'OFF' is floating high, and 'ON' is pulled down, so it has the
597          * inverse sense of 'val'.
598          */
599         set_select(tca, tca->gpio_map[offset],
600                    val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);
601         spin_unlock_irqrestore(&tca->lock, flags);
602         if (tca->reg_set)
603                 schedule_work(&tca->work);
604 }
605
606 static int tca6507_gpio_direction_output(struct gpio_chip *gc,
607                                           unsigned offset, int val)
608 {
609         tca6507_gpio_set_value(gc, offset, val);
610         return 0;
611 }
612
613 static int tca6507_probe_gpios(struct i2c_client *client,
614                                struct tca6507_chip *tca,
615                                struct tca6507_platform_data *pdata)
616 {
617         int err;
618         int i = 0;
619         int gpios = 0;
620
621         for (i = 0; i < NUM_LEDS; i++)
622                 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {
623                         /* Configure as a gpio */
624                         tca->gpio_name[gpios] = pdata->leds.leds[i].name;
625                         tca->gpio_map[gpios] = i;
626                         gpios++;
627                 }
628
629         if (!gpios)
630                 return 0;
631
632         tca->gpio.label = "gpio-tca6507";
633         tca->gpio.names = tca->gpio_name;
634         tca->gpio.ngpio = gpios;
635         tca->gpio.base = pdata->gpio_base;
636         tca->gpio.owner = THIS_MODULE;
637         tca->gpio.direction_output = tca6507_gpio_direction_output;
638         tca->gpio.set = tca6507_gpio_set_value;
639         tca->gpio.dev = &client->dev;
640         err = gpiochip_add(&tca->gpio);
641         if (err) {
642                 tca->gpio.ngpio = 0;
643                 return err;
644         }
645         if (pdata->setup)
646                 pdata->setup(tca->gpio.base, tca->gpio.ngpio);
647         return 0;
648 }
649
650 static void tca6507_remove_gpio(struct tca6507_chip *tca)
651 {
652         if (tca->gpio.ngpio) {
653                 int err = gpiochip_remove(&tca->gpio);
654                 dev_err(&tca->client->dev, "%s failed, %d\n",
655                         "gpiochip_remove()", err);
656         }
657 }
658 #else /* CONFIG_GPIOLIB */
659 static int tca6507_probe_gpios(struct i2c_client *client,
660                                struct tca6507_chip *tca,
661                                struct tca6507_platform_data *pdata)
662 {
663         return 0;
664 }
665 static void tca6507_remove_gpio(struct tca6507_chip *tca)
666 {
667 }
668 #endif /* CONFIG_GPIOLIB */
669
670 static int __devinit tca6507_probe(struct i2c_client *client,
671                                    const struct i2c_device_id *id)
672 {
673         struct tca6507_chip *tca;
674         struct i2c_adapter *adapter;
675         struct tca6507_platform_data *pdata;
676         int err;
677         int i = 0;
678
679         adapter = to_i2c_adapter(client->dev.parent);
680         pdata = client->dev.platform_data;
681
682         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
683                 return -EIO;
684
685         if (!pdata || pdata->leds.num_leds != NUM_LEDS) {
686                 dev_err(&client->dev, "Need %d entries in platform-data list\n",
687                         NUM_LEDS);
688                 return -ENODEV;
689         }
690         err = -ENOMEM;
691         tca = kzalloc(sizeof(*tca), GFP_KERNEL);
692         if (!tca)
693                 goto exit;
694
695         tca->client = client;
696         INIT_WORK(&tca->work, tca6507_work);
697         spin_lock_init(&tca->lock);
698         i2c_set_clientdata(client, tca);
699
700         for (i = 0; i < NUM_LEDS; i++) {
701                 struct tca6507_led *l = tca->leds + i;
702
703                 l->chip = tca;
704                 l->num = i;
705                 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) {
706                         l->led_cdev.name = pdata->leds.leds[i].name;
707                         l->led_cdev.default_trigger
708                                 = pdata->leds.leds[i].default_trigger;
709                         l->led_cdev.brightness_set = tca6507_brightness_set;
710                         l->led_cdev.blink_set = tca6507_blink_set;
711                         l->bank = -1;
712                         err = led_classdev_register(&client->dev,
713                                                     &l->led_cdev);
714                         if (err < 0)
715                                 goto exit;
716                 }
717         }
718         err = tca6507_probe_gpios(client, tca, pdata);
719         if (err)
720                 goto exit;
721         /* set all registers to known state - zero */
722         tca->reg_set = 0x7f;
723         schedule_work(&tca->work);
724
725         return 0;
726 exit:
727         while (i--)
728                 if (tca->leds[i].led_cdev.name)
729                         led_classdev_unregister(&tca->leds[i].led_cdev);
730         cancel_work_sync(&tca->work);
731         i2c_set_clientdata(client, NULL);
732         kfree(tca);
733         return err;
734 }
735
736 static int __devexit tca6507_remove(struct i2c_client *client)
737 {
738         int i;
739         struct tca6507_chip *tca = i2c_get_clientdata(client);
740         struct tca6507_led *tca_leds = tca->leds;
741
742         for (i = 0; i < NUM_LEDS; i++) {
743                 if (tca_leds[i].led_cdev.name)
744                         led_classdev_unregister(&tca_leds[i].led_cdev);
745         }
746         tca6507_remove_gpio(tca);
747         cancel_work_sync(&tca->work);
748         i2c_set_clientdata(client, NULL);
749         kfree(tca);
750
751         return 0;
752 }
753
754 static struct i2c_driver tca6507_driver = {
755         .driver   = {
756                 .name    = "leds-tca6507",
757                 .owner   = THIS_MODULE,
758         },
759         .probe    = tca6507_probe,
760         .remove   = __devexit_p(tca6507_remove),
761         .id_table = tca6507_id,
762 };
763
764 static int __init tca6507_leds_init(void)
765 {
766         return i2c_add_driver(&tca6507_driver);
767 }
768
769 static void __exit tca6507_leds_exit(void)
770 {
771         i2c_del_driver(&tca6507_driver);
772 }
773
774 module_init(tca6507_leds_init);
775 module_exit(tca6507_leds_exit);
776
777 MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
778 MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
779 MODULE_LICENSE("GPL v2");