1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74#include <linux/module.h>
75#include <linux/slab.h>
76#include <linux/leds.h>
77#include <linux/err.h>
78#include <linux/i2c.h>
79#include <linux/gpio/driver.h>
80#include <linux/property.h>
81#include <linux/workqueue.h>
82
83
84#define TCA6507_LS_LED_OFF 0x0
85#define TCA6507_LS_LED_OFF1 0x1
86#define TCA6507_LS_LED_PWM0 0x2
87#define TCA6507_LS_LED_PWM1 0x3
88#define TCA6507_LS_LED_ON 0x4
89#define TCA6507_LS_LED_MIR 0x5
90#define TCA6507_LS_BLINK0 0x6
91#define TCA6507_LS_BLINK1 0x7
92
93struct tca6507_platform_data {
94 struct led_platform_data leds;
95#ifdef CONFIG_GPIOLIB
96 int gpio_base;
97#endif
98};
99
100#define TCA6507_MAKE_GPIO 1
101
102enum {
103 BANK0,
104 BANK1,
105 MASTER,
106};
107static int bank_source[3] = {
108 TCA6507_LS_LED_PWM0,
109 TCA6507_LS_LED_PWM1,
110 TCA6507_LS_LED_MIR,
111};
112static int blink_source[2] = {
113 TCA6507_LS_BLINK0,
114 TCA6507_LS_BLINK1,
115};
116
117
118#define TCA6507_REG_CNT 11
119
120
121
122
123
124#define TCA6507_FADE_ON 0x03
125#define TCA6507_FULL_ON 0x04
126#define TCA6507_FADE_OFF 0x05
127#define TCA6507_FIRST_OFF 0x06
128#define TCA6507_SECOND_OFF 0x07
129#define TCA6507_MAX_INTENSITY 0x08
130#define TCA6507_MASTER_INTENSITY 0x09
131#define TCA6507_INITIALIZE 0x0A
132
133#define INIT_CODE 0x8
134
135#define TIMECODES 16
136static int time_codes[TIMECODES] = {
137 0, 64, 128, 192, 256, 384, 512, 768,
138 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
139};
140
141
142static inline int TO_LEVEL(int brightness)
143{
144 return brightness >> 4;
145}
146
147
148static inline int TO_BRIGHT(int level)
149{
150 if (level)
151 return (level << 4) | 0xf;
152 return 0;
153}
154
155#define NUM_LEDS 7
156struct tca6507_chip {
157 int reg_set;
158
159
160 u8 reg_file[TCA6507_REG_CNT];
161
162 struct bank {
163 int level;
164 int ontime, offtime;
165 int on_dflt, off_dflt;
166 int time_use, level_use;
167 } bank[3];
168 struct i2c_client *client;
169 struct work_struct work;
170 spinlock_t lock;
171
172 struct tca6507_led {
173 struct tca6507_chip *chip;
174 struct led_classdev led_cdev;
175 int num;
176 int ontime, offtime;
177 int on_dflt, off_dflt;
178 int bank;
179 int blink;
180 } leds[NUM_LEDS];
181#ifdef CONFIG_GPIOLIB
182 struct gpio_chip gpio;
183 int gpio_map[NUM_LEDS];
184#endif
185};
186
187static const struct i2c_device_id tca6507_id[] = {
188 { "tca6507" },
189 { }
190};
191MODULE_DEVICE_TABLE(i2c, tca6507_id);
192
193static int choose_times(int msec, int *c1p, int *c2p)
194{
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209 int c1, c2;
210 int tmax = msec * 9 / 8;
211 int tmin = msec * 7 / 8;
212 int diff = 65536;
213
214
215
216
217 for (c1 = 1; c1 < TIMECODES; c1++) {
218 int t = time_codes[c1];
219 if (t*2 < tmin)
220 continue;
221 if (t > tmax)
222 break;
223 for (c2 = 0; c2 <= c1; c2++) {
224 int tt = t + time_codes[c2];
225 int d;
226 if (tt < tmin)
227 continue;
228 if (tt > tmax)
229 break;
230
231 d = abs(msec - tt);
232 if (d >= diff)
233 continue;
234
235 *c1p = c1;
236 *c2p = c2;
237 diff = d;
238 if (d == 0)
239 return msec;
240 }
241 }
242 if (diff < 65536) {
243 int actual;
244 if (msec & 1) {
245 c1 = *c2p;
246 *c2p = *c1p;
247 *c1p = c1;
248 }
249 actual = time_codes[*c1p] + time_codes[*c2p];
250 if (*c1p < *c2p)
251 return actual + 1;
252 else
253 return actual;
254 }
255
256 return -EINVAL;
257}
258
259
260
261
262
263static void set_select(struct tca6507_chip *tca, int led, int val)
264{
265 int mask = (1 << led);
266 int bit;
267
268 for (bit = 0; bit < 3; bit++) {
269 int n = tca->reg_file[bit] & ~mask;
270 if (val & (1 << bit))
271 n |= mask;
272 if (tca->reg_file[bit] != n) {
273 tca->reg_file[bit] = n;
274 tca->reg_set |= (1 << bit);
275 }
276 }
277}
278
279
280
281
282
283static void set_code(struct tca6507_chip *tca, int reg, int bank, int new)
284{
285 int mask = 0xF;
286 int n;
287 if (bank) {
288 mask <<= 4;
289 new <<= 4;
290 }
291 n = tca->reg_file[reg] & ~mask;
292 n |= new;
293 if (tca->reg_file[reg] != n) {
294 tca->reg_file[reg] = n;
295 tca->reg_set |= 1 << reg;
296 }
297}
298
299
300static void set_level(struct tca6507_chip *tca, int bank, int level)
301{
302 switch (bank) {
303 case BANK0:
304 case BANK1:
305 set_code(tca, TCA6507_MAX_INTENSITY, bank, level);
306 break;
307 case MASTER:
308 set_code(tca, TCA6507_MASTER_INTENSITY, 0, level);
309 break;
310 }
311 tca->bank[bank].level = level;
312}
313
314
315static void set_times(struct tca6507_chip *tca, int bank)
316{
317 int c1, c2;
318 int result;
319
320 result = choose_times(tca->bank[bank].ontime, &c1, &c2);
321 if (result < 0)
322 return;
323 dev_dbg(&tca->client->dev,
324 "Chose on times %d(%d) %d(%d) for %dms\n",
325 c1, time_codes[c1],
326 c2, time_codes[c2], tca->bank[bank].ontime);
327 set_code(tca, TCA6507_FADE_ON, bank, c2);
328 set_code(tca, TCA6507_FULL_ON, bank, c1);
329 tca->bank[bank].ontime = result;
330
331 result = choose_times(tca->bank[bank].offtime, &c1, &c2);
332 dev_dbg(&tca->client->dev,
333 "Chose off times %d(%d) %d(%d) for %dms\n",
334 c1, time_codes[c1],
335 c2, time_codes[c2], tca->bank[bank].offtime);
336 set_code(tca, TCA6507_FADE_OFF, bank, c2);
337 set_code(tca, TCA6507_FIRST_OFF, bank, c1);
338 set_code(tca, TCA6507_SECOND_OFF, bank, c1);
339 tca->bank[bank].offtime = result;
340
341 set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);
342}
343
344
345
346static void tca6507_work(struct work_struct *work)
347{
348 struct tca6507_chip *tca = container_of(work, struct tca6507_chip,
349 work);
350 struct i2c_client *cl = tca->client;
351 int set;
352 u8 file[TCA6507_REG_CNT];
353 int r;
354
355 spin_lock_irq(&tca->lock);
356 set = tca->reg_set;
357 memcpy(file, tca->reg_file, TCA6507_REG_CNT);
358 tca->reg_set = 0;
359 spin_unlock_irq(&tca->lock);
360
361 for (r = 0; r < TCA6507_REG_CNT; r++)
362 if (set & (1<<r))
363 i2c_smbus_write_byte_data(cl, r, file[r]);
364}
365
366static void led_release(struct tca6507_led *led)
367{
368
369 struct tca6507_chip *tca = led->chip;
370 if (led->bank >= 0) {
371 struct bank *b = tca->bank + led->bank;
372 if (led->blink)
373 b->time_use--;
374 b->level_use--;
375 }
376 led->blink = 0;
377 led->bank = -1;
378}
379
380static int led_prepare(struct tca6507_led *led)
381{
382
383
384 int level = TO_LEVEL(led->led_cdev.brightness);
385 struct tca6507_chip *tca = led->chip;
386 int c1, c2;
387 int i;
388 struct bank *b;
389 int need_init = 0;
390
391 led->led_cdev.brightness = TO_BRIGHT(level);
392 if (level == 0) {
393 set_select(tca, led->num, TCA6507_LS_LED_OFF);
394 return 0;
395 }
396
397 if (led->ontime == 0 || led->offtime == 0) {
398
399
400
401
402
403
404 int best = -1;
405 int diff = 15-level;
406
407 if (level == 15) {
408 set_select(tca, led->num, TCA6507_LS_LED_ON);
409 return 0;
410 }
411
412 for (i = MASTER; i >= BANK0; i--) {
413 int d;
414 if (tca->bank[i].level == level ||
415 tca->bank[i].level_use == 0) {
416 best = i;
417 break;
418 }
419 d = abs(level - tca->bank[i].level);
420 if (d < diff) {
421 diff = d;
422 best = i;
423 }
424 }
425 if (best == -1) {
426
427 set_select(tca, led->num, TCA6507_LS_LED_ON);
428 led->led_cdev.brightness = LED_FULL;
429 return 0;
430 }
431
432 if (!tca->bank[best].level_use)
433 set_level(tca, best, level);
434
435 tca->bank[best].level_use++;
436 led->bank = best;
437 set_select(tca, led->num, bank_source[best]);
438 led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);
439 return 0;
440 }
441
442
443
444
445
446
447 if (choose_times(led->ontime, &c1, &c2) < 0)
448 return -EINVAL;
449 if (choose_times(led->offtime, &c1, &c2) < 0)
450 return -EINVAL;
451
452 for (i = BANK0; i <= BANK1; i++) {
453 if (tca->bank[i].level_use == 0)
454
455 break;
456 if (tca->bank[i].level != level)
457
458
459
460
461 continue;
462
463 if (tca->bank[i].time_use == 0)
464
465 break;
466
467 if (!(tca->bank[i].on_dflt ||
468 led->on_dflt ||
469 tca->bank[i].ontime == led->ontime))
470
471 continue;
472
473 if (!(tca->bank[i].off_dflt ||
474 led->off_dflt ||
475 tca->bank[i].offtime == led->offtime))
476
477 continue;
478
479
480 break;
481 }
482
483 if (i > BANK1)
484
485 return -EINVAL;
486
487 b = &tca->bank[i];
488 if (b->level_use == 0)
489 set_level(tca, i, level);
490 b->level_use++;
491 led->bank = i;
492
493 if (b->on_dflt ||
494 !led->on_dflt ||
495 b->time_use == 0) {
496 b->ontime = led->ontime;
497 b->on_dflt = led->on_dflt;
498 need_init = 1;
499 }
500
501 if (b->off_dflt ||
502 !led->off_dflt ||
503 b->time_use == 0) {
504 b->offtime = led->offtime;
505 b->off_dflt = led->off_dflt;
506 need_init = 1;
507 }
508
509 if (need_init)
510 set_times(tca, i);
511
512 led->ontime = b->ontime;
513 led->offtime = b->offtime;
514
515 b->time_use++;
516 led->blink = 1;
517 led->led_cdev.brightness = TO_BRIGHT(b->level);
518 set_select(tca, led->num, blink_source[i]);
519 return 0;
520}
521
522static int led_assign(struct tca6507_led *led)
523{
524 struct tca6507_chip *tca = led->chip;
525 int err;
526 unsigned long flags;
527
528 spin_lock_irqsave(&tca->lock, flags);
529 led_release(led);
530 err = led_prepare(led);
531 if (err) {
532
533
534
535
536 led->ontime = 0;
537 led->offtime = 0;
538 led_prepare(led);
539 }
540 spin_unlock_irqrestore(&tca->lock, flags);
541
542 if (tca->reg_set)
543 schedule_work(&tca->work);
544 return err;
545}
546
547static void tca6507_brightness_set(struct led_classdev *led_cdev,
548 enum led_brightness brightness)
549{
550 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
551 led_cdev);
552 led->led_cdev.brightness = brightness;
553 led->ontime = 0;
554 led->offtime = 0;
555 led_assign(led);
556}
557
558static int tca6507_blink_set(struct led_classdev *led_cdev,
559 unsigned long *delay_on,
560 unsigned long *delay_off)
561{
562 struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
563 led_cdev);
564
565 if (*delay_on == 0)
566 led->on_dflt = 1;
567 else if (delay_on != &led_cdev->blink_delay_on)
568 led->on_dflt = 0;
569 led->ontime = *delay_on;
570
571 if (*delay_off == 0)
572 led->off_dflt = 1;
573 else if (delay_off != &led_cdev->blink_delay_off)
574 led->off_dflt = 0;
575 led->offtime = *delay_off;
576
577 if (led->ontime == 0)
578 led->ontime = 512;
579 if (led->offtime == 0)
580 led->offtime = 512;
581
582 if (led->led_cdev.brightness == LED_OFF)
583 led->led_cdev.brightness = LED_FULL;
584 if (led_assign(led) < 0) {
585 led->ontime = 0;
586 led->offtime = 0;
587 led->led_cdev.brightness = LED_OFF;
588 return -EINVAL;
589 }
590 *delay_on = led->ontime;
591 *delay_off = led->offtime;
592 return 0;
593}
594
595#ifdef CONFIG_GPIOLIB
596static void tca6507_gpio_set_value(struct gpio_chip *gc,
597 unsigned offset, int val)
598{
599 struct tca6507_chip *tca = gpiochip_get_data(gc);
600 unsigned long flags;
601
602 spin_lock_irqsave(&tca->lock, flags);
603
604
605
606
607 set_select(tca, tca->gpio_map[offset],
608 val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);
609 spin_unlock_irqrestore(&tca->lock, flags);
610 if (tca->reg_set)
611 schedule_work(&tca->work);
612}
613
614static int tca6507_gpio_direction_output(struct gpio_chip *gc,
615 unsigned offset, int val)
616{
617 tca6507_gpio_set_value(gc, offset, val);
618 return 0;
619}
620
621static int tca6507_probe_gpios(struct device *dev,
622 struct tca6507_chip *tca,
623 struct tca6507_platform_data *pdata)
624{
625 int err;
626 int i = 0;
627 int gpios = 0;
628
629 for (i = 0; i < NUM_LEDS; i++)
630 if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {
631
632 tca->gpio_map[gpios] = i;
633 gpios++;
634 }
635
636 if (!gpios)
637 return 0;
638
639 tca->gpio.label = "gpio-tca6507";
640 tca->gpio.ngpio = gpios;
641 tca->gpio.base = pdata->gpio_base;
642 tca->gpio.owner = THIS_MODULE;
643 tca->gpio.direction_output = tca6507_gpio_direction_output;
644 tca->gpio.set = tca6507_gpio_set_value;
645 tca->gpio.parent = dev;
646#ifdef CONFIG_OF_GPIO
647 tca->gpio.of_node = of_node_get(dev_of_node(dev));
648#endif
649 err = gpiochip_add_data(&tca->gpio, tca);
650 if (err) {
651 tca->gpio.ngpio = 0;
652 return err;
653 }
654 return 0;
655}
656
657static void tca6507_remove_gpio(struct tca6507_chip *tca)
658{
659 if (tca->gpio.ngpio)
660 gpiochip_remove(&tca->gpio);
661}
662#else
663static int tca6507_probe_gpios(struct device *dev,
664 struct tca6507_chip *tca,
665 struct tca6507_platform_data *pdata)
666{
667 return 0;
668}
669static void tca6507_remove_gpio(struct tca6507_chip *tca)
670{
671}
672#endif
673
674static struct tca6507_platform_data *
675tca6507_led_dt_init(struct device *dev)
676{
677 struct tca6507_platform_data *pdata;
678 struct fwnode_handle *child;
679 struct led_info *tca_leds;
680 int count;
681
682 count = device_get_child_node_count(dev);
683 if (!count || count > NUM_LEDS)
684 return ERR_PTR(-ENODEV);
685
686 tca_leds = devm_kcalloc(dev, NUM_LEDS, sizeof(struct led_info),
687 GFP_KERNEL);
688 if (!tca_leds)
689 return ERR_PTR(-ENOMEM);
690
691 device_for_each_child_node(dev, child) {
692 struct led_info led;
693 u32 reg;
694 int ret;
695
696 if (fwnode_property_read_string(child, "label", &led.name))
697 led.name = fwnode_get_name(child);
698
699 fwnode_property_read_string(child, "linux,default-trigger",
700 &led.default_trigger);
701
702 led.flags = 0;
703 if (fwnode_property_match_string(child, "compatible",
704 "gpio") >= 0)
705 led.flags |= TCA6507_MAKE_GPIO;
706
707 ret = fwnode_property_read_u32(child, "reg", ®);
708 if (ret || reg >= NUM_LEDS) {
709 fwnode_handle_put(child);
710 return ERR_PTR(ret ? : -EINVAL);
711 }
712
713 tca_leds[reg] = led;
714 }
715
716 pdata = devm_kzalloc(dev, sizeof(struct tca6507_platform_data),
717 GFP_KERNEL);
718 if (!pdata)
719 return ERR_PTR(-ENOMEM);
720
721 pdata->leds.leds = tca_leds;
722 pdata->leds.num_leds = NUM_LEDS;
723#ifdef CONFIG_GPIOLIB
724 pdata->gpio_base = -1;
725#endif
726
727 return pdata;
728}
729
730static const struct of_device_id __maybe_unused of_tca6507_leds_match[] = {
731 { .compatible = "ti,tca6507", },
732 {},
733};
734MODULE_DEVICE_TABLE(of, of_tca6507_leds_match);
735
736static int tca6507_probe(struct i2c_client *client,
737 const struct i2c_device_id *id)
738{
739 struct device *dev = &client->dev;
740 struct i2c_adapter *adapter;
741 struct tca6507_chip *tca;
742 struct tca6507_platform_data *pdata;
743 int err;
744 int i = 0;
745
746 adapter = client->adapter;
747
748 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
749 return -EIO;
750
751 pdata = tca6507_led_dt_init(dev);
752 if (IS_ERR(pdata)) {
753 dev_err(dev, "Need %d entries in platform-data list\n", NUM_LEDS);
754 return PTR_ERR(pdata);
755 }
756 tca = devm_kzalloc(dev, sizeof(*tca), GFP_KERNEL);
757 if (!tca)
758 return -ENOMEM;
759
760 tca->client = client;
761 INIT_WORK(&tca->work, tca6507_work);
762 spin_lock_init(&tca->lock);
763 i2c_set_clientdata(client, tca);
764
765 for (i = 0; i < NUM_LEDS; i++) {
766 struct tca6507_led *l = tca->leds + i;
767
768 l->chip = tca;
769 l->num = i;
770 if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) {
771 l->led_cdev.name = pdata->leds.leds[i].name;
772 l->led_cdev.default_trigger
773 = pdata->leds.leds[i].default_trigger;
774 l->led_cdev.brightness_set = tca6507_brightness_set;
775 l->led_cdev.blink_set = tca6507_blink_set;
776 l->bank = -1;
777 err = led_classdev_register(dev, &l->led_cdev);
778 if (err < 0)
779 goto exit;
780 }
781 }
782 err = tca6507_probe_gpios(dev, tca, pdata);
783 if (err)
784 goto exit;
785
786 tca->reg_set = 0x7f;
787 schedule_work(&tca->work);
788
789 return 0;
790exit:
791 while (i--) {
792 if (tca->leds[i].led_cdev.name)
793 led_classdev_unregister(&tca->leds[i].led_cdev);
794 }
795 return err;
796}
797
798static int tca6507_remove(struct i2c_client *client)
799{
800 int i;
801 struct tca6507_chip *tca = i2c_get_clientdata(client);
802 struct tca6507_led *tca_leds = tca->leds;
803
804 for (i = 0; i < NUM_LEDS; i++) {
805 if (tca_leds[i].led_cdev.name)
806 led_classdev_unregister(&tca_leds[i].led_cdev);
807 }
808 tca6507_remove_gpio(tca);
809 cancel_work_sync(&tca->work);
810
811 return 0;
812}
813
814static struct i2c_driver tca6507_driver = {
815 .driver = {
816 .name = "leds-tca6507",
817 .of_match_table = of_match_ptr(of_tca6507_leds_match),
818 },
819 .probe = tca6507_probe,
820 .remove = tca6507_remove,
821 .id_table = tca6507_id,
822};
823
824module_i2c_driver(tca6507_driver);
825
826MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
827MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
828MODULE_LICENSE("GPL v2");
829