Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/leds/leds-lp5523.c

  1 /*
  2  * lp5523.c - LP5523, LP55231 LED Driver
  3  *
  4  * Copyright (C) 2010 Nokia Corporation
  5  * Copyright (C) 2012 Texas Instruments
  6  *
  7  * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
  8  *          Milo(Woogyom) Kim <milo.kim@ti.com>
  9  *
 10  * This program is free software; you can redistribute it and/or
 11  * modify it under the terms of the GNU General Public License
 12  * version 2 as published by the Free Software Foundation.
 13  *
 14  * This program is distributed in the hope that it will be useful, but
 15  * WITHOUT ANY WARRANTY; without even the implied warranty of
 16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 17  * General Public License for more details.
 18  *
 19  * You should have received a copy of the GNU General Public License
 20  * along with this program; if not, write to the Free Software
 21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 22  * 02110-1301 USA
 23  */
 24 
 25 #include <linux/delay.h>
 26 #include <linux/firmware.h>
 27 #include <linux/i2c.h>
 28 #include <linux/leds.h>
 29 #include <linux/module.h>
 30 #include <linux/mutex.h>
 31 #include <linux/of.h>
 32 #include <linux/platform_data/leds-lp55xx.h>
 33 #include <linux/slab.h>
 34 
 35 #include "leds-lp55xx-common.h"
 36 
 37 #define LP5523_PROGRAM_LENGTH           32      /* bytes */
 38 /* Memory is used like this:
 39    0x00 engine 1 program
 40    0x10 engine 2 program
 41    0x20 engine 3 program
 42    0x30 engine 1 muxing info
 43    0x40 engine 2 muxing info
 44    0x50 engine 3 muxing info
 45 */
 46 #define LP5523_MAX_LEDS                 9
 47 
 48 /* Registers */
 49 #define LP5523_REG_ENABLE               0x00
 50 #define LP5523_REG_OP_MODE              0x01
 51 #define LP5523_REG_ENABLE_LEDS_MSB      0x04
 52 #define LP5523_REG_ENABLE_LEDS_LSB      0x05
 53 #define LP5523_REG_LED_PWM_BASE         0x16
 54 #define LP5523_REG_LED_CURRENT_BASE     0x26
 55 #define LP5523_REG_CONFIG               0x36
 56 #define LP5523_REG_STATUS               0x3A
 57 #define LP5523_REG_RESET                0x3D
 58 #define LP5523_REG_LED_TEST_CTRL        0x41
 59 #define LP5523_REG_LED_TEST_ADC         0x42
 60 #define LP5523_REG_CH1_PROG_START       0x4C
 61 #define LP5523_REG_CH2_PROG_START       0x4D
 62 #define LP5523_REG_CH3_PROG_START       0x4E
 63 #define LP5523_REG_PROG_PAGE_SEL        0x4F
 64 #define LP5523_REG_PROG_MEM             0x50
 65 
 66 /* Bit description in registers */
 67 #define LP5523_ENABLE                   0x40
 68 #define LP5523_AUTO_INC                 0x40
 69 #define LP5523_PWR_SAVE                 0x20
 70 #define LP5523_PWM_PWR_SAVE             0x04
 71 #define LP5523_CP_AUTO                  0x18
 72 #define LP5523_AUTO_CLK                 0x02
 73 
 74 #define LP5523_EN_LEDTEST               0x80
 75 #define LP5523_LEDTEST_DONE             0x80
 76 #define LP5523_RESET                    0xFF
 77 #define LP5523_ADC_SHORTCIRC_LIM        80
 78 #define LP5523_EXT_CLK_USED             0x08
 79 #define LP5523_ENG_STATUS_MASK          0x07
 80 
 81 /* Memory Page Selection */
 82 #define LP5523_PAGE_ENG1                0
 83 #define LP5523_PAGE_ENG2                1
 84 #define LP5523_PAGE_ENG3                2
 85 #define LP5523_PAGE_MUX1                3
 86 #define LP5523_PAGE_MUX2                4
 87 #define LP5523_PAGE_MUX3                5
 88 
 89 /* Program Memory Operations */
 90 #define LP5523_MODE_ENG1_M              0x30    /* Operation Mode Register */
 91 #define LP5523_MODE_ENG2_M              0x0C
 92 #define LP5523_MODE_ENG3_M              0x03
 93 #define LP5523_LOAD_ENG1                0x10
 94 #define LP5523_LOAD_ENG2                0x04
 95 #define LP5523_LOAD_ENG3                0x01
 96 
 97 #define LP5523_ENG1_IS_LOADING(mode)    \
 98         ((mode & LP5523_MODE_ENG1_M) == LP5523_LOAD_ENG1)
 99 #define LP5523_ENG2_IS_LOADING(mode)    \
100         ((mode & LP5523_MODE_ENG2_M) == LP5523_LOAD_ENG2)
101 #define LP5523_ENG3_IS_LOADING(mode)    \
102         ((mode & LP5523_MODE_ENG3_M) == LP5523_LOAD_ENG3)
103 
104 #define LP5523_EXEC_ENG1_M              0x30    /* Enable Register */
105 #define LP5523_EXEC_ENG2_M              0x0C
106 #define LP5523_EXEC_ENG3_M              0x03
107 #define LP5523_EXEC_M                   0x3F
108 #define LP5523_RUN_ENG1                 0x20
109 #define LP5523_RUN_ENG2                 0x08
110 #define LP5523_RUN_ENG3                 0x02
111 
112 #define LED_ACTIVE(mux, led)            (!!(mux & (0x0001 << led)))
113 
114 enum lp5523_chip_id {
115         LP5523,
116         LP55231,
117 };
118 
119 static int lp5523_init_program_engine(struct lp55xx_chip *chip);
120 
121 static inline void lp5523_wait_opmode_done(void)
122 {
123         usleep_range(1000, 2000);
124 }
125 
126 static void lp5523_set_led_current(struct lp55xx_led *led, u8 led_current)
127 {
128         led->led_current = led_current;
129         lp55xx_write(led->chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
130                 led_current);
131 }
132 
133 static int lp5523_post_init_device(struct lp55xx_chip *chip)
134 {
135         int ret;
136 
137         ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE);
138         if (ret)
139                 return ret;
140 
141         /* Chip startup time is 500 us, 1 - 2 ms gives some margin */
142         usleep_range(1000, 2000);
143 
144         ret = lp55xx_write(chip, LP5523_REG_CONFIG,
145                             LP5523_AUTO_INC | LP5523_PWR_SAVE |
146                             LP5523_CP_AUTO | LP5523_AUTO_CLK |
147                             LP5523_PWM_PWR_SAVE);
148         if (ret)
149                 return ret;
150 
151         /* turn on all leds */
152         ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
153         if (ret)
154                 return ret;
155 
156         ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
157         if (ret)
158                 return ret;
159 
160         return lp5523_init_program_engine(chip);
161 }
162 
163 static void lp5523_load_engine(struct lp55xx_chip *chip)
164 {
165         enum lp55xx_engine_index idx = chip->engine_idx;
166         u8 mask[] = {
167                 [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
168                 [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
169                 [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
170         };
171 
172         u8 val[] = {
173                 [LP55XX_ENGINE_1] = LP5523_LOAD_ENG1,
174                 [LP55XX_ENGINE_2] = LP5523_LOAD_ENG2,
175                 [LP55XX_ENGINE_3] = LP5523_LOAD_ENG3,
176         };
177 
178         lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], val[idx]);
179 
180         lp5523_wait_opmode_done();
181 }
182 
183 static void lp5523_load_engine_and_select_page(struct lp55xx_chip *chip)
184 {
185         enum lp55xx_engine_index idx = chip->engine_idx;
186         u8 page_sel[] = {
187                 [LP55XX_ENGINE_1] = LP5523_PAGE_ENG1,
188                 [LP55XX_ENGINE_2] = LP5523_PAGE_ENG2,
189                 [LP55XX_ENGINE_3] = LP5523_PAGE_ENG3,
190         };
191 
192         lp5523_load_engine(chip);
193 
194         lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, page_sel[idx]);
195 }
196 
197 static void lp5523_stop_all_engines(struct lp55xx_chip *chip)
198 {
199         lp55xx_write(chip, LP5523_REG_OP_MODE, 0);
200         lp5523_wait_opmode_done();
201 }
202 
203 static void lp5523_stop_engine(struct lp55xx_chip *chip)
204 {
205         enum lp55xx_engine_index idx = chip->engine_idx;
206         u8 mask[] = {
207                 [LP55XX_ENGINE_1] = LP5523_MODE_ENG1_M,
208                 [LP55XX_ENGINE_2] = LP5523_MODE_ENG2_M,
209                 [LP55XX_ENGINE_3] = LP5523_MODE_ENG3_M,
210         };
211 
212         lp55xx_update_bits(chip, LP5523_REG_OP_MODE, mask[idx], 0);
213 
214         lp5523_wait_opmode_done();
215 }
216 
217 static void lp5523_turn_off_channels(struct lp55xx_chip *chip)
218 {
219         int i;
220 
221         for (i = 0; i < LP5523_MAX_LEDS; i++)
222                 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0);
223 }
224 
225 static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
226 {
227         int ret;
228         u8 mode;
229         u8 exec;
230 
231         /* stop engine */
232         if (!start) {
233                 lp5523_stop_engine(chip);
234                 lp5523_turn_off_channels(chip);
235                 return;
236         }
237 
238         /*
239          * To run the engine,
240          * operation mode and enable register should updated at the same time
241          */
242 
243         ret = lp55xx_read(chip, LP5523_REG_OP_MODE, &mode);
244         if (ret)
245                 return;
246 
247         ret = lp55xx_read(chip, LP5523_REG_ENABLE, &exec);
248         if (ret)
249                 return;
250 
251         /* change operation mode to RUN only when each engine is loading */
252         if (LP5523_ENG1_IS_LOADING(mode)) {
253                 mode = (mode & ~LP5523_MODE_ENG1_M) | LP5523_RUN_ENG1;
254                 exec = (exec & ~LP5523_EXEC_ENG1_M) | LP5523_RUN_ENG1;
255         }
256 
257         if (LP5523_ENG2_IS_LOADING(mode)) {
258                 mode = (mode & ~LP5523_MODE_ENG2_M) | LP5523_RUN_ENG2;
259                 exec = (exec & ~LP5523_EXEC_ENG2_M) | LP5523_RUN_ENG2;
260         }
261 
262         if (LP5523_ENG3_IS_LOADING(mode)) {
263                 mode = (mode & ~LP5523_MODE_ENG3_M) | LP5523_RUN_ENG3;
264                 exec = (exec & ~LP5523_EXEC_ENG3_M) | LP5523_RUN_ENG3;
265         }
266 
267         lp55xx_write(chip, LP5523_REG_OP_MODE, mode);
268         lp5523_wait_opmode_done();
269 
270         lp55xx_update_bits(chip, LP5523_REG_ENABLE, LP5523_EXEC_M, exec);
271 }
272 
273 static int lp5523_init_program_engine(struct lp55xx_chip *chip)
274 {
275         int i;
276         int j;
277         int ret;
278         u8 status;
279         /* one pattern per engine setting LED MUX start and stop addresses */
280         static const u8 pattern[][LP5523_PROGRAM_LENGTH] =  {
281                 { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
282                 { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
283                 { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
284         };
285 
286         /* hardcode 32 bytes of memory for each engine from program memory */
287         ret = lp55xx_write(chip, LP5523_REG_CH1_PROG_START, 0x00);
288         if (ret)
289                 return ret;
290 
291         ret = lp55xx_write(chip, LP5523_REG_CH2_PROG_START, 0x10);
292         if (ret)
293                 return ret;
294 
295         ret = lp55xx_write(chip, LP5523_REG_CH3_PROG_START, 0x20);
296         if (ret)
297                 return ret;
298 
299         /* write LED MUX address space for each engine */
300         for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) {
301                 chip->engine_idx = i;
302                 lp5523_load_engine_and_select_page(chip);
303 
304                 for (j = 0; j < LP5523_PROGRAM_LENGTH; j++) {
305                         ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + j,
306                                         pattern[i - 1][j]);
307                         if (ret)
308                                 goto out;
309                 }
310         }
311 
312         lp5523_run_engine(chip, true);
313 
314         /* Let the programs run for couple of ms and check the engine status */
315         usleep_range(3000, 6000);
316         lp55xx_read(chip, LP5523_REG_STATUS, &status);
317         status &= LP5523_ENG_STATUS_MASK;
318 
319         if (status != LP5523_ENG_STATUS_MASK) {
320                 dev_err(&chip->cl->dev,
321                         "cound not configure LED engine, status = 0x%.2x\n",
322                         status);
323                 ret = -1;
324         }
325 
326 out:
327         lp5523_stop_all_engines(chip);
328         return ret;
329 }
330 
331 static int lp5523_update_program_memory(struct lp55xx_chip *chip,
332                                         const u8 *data, size_t size)
333 {
334         u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
335         unsigned cmd;
336         char c[3];
337         int nrchars;
338         int ret;
339         int offset = 0;
340         int i = 0;
341 
342         while ((offset < size - 1) && (i < LP5523_PROGRAM_LENGTH)) {
343                 /* separate sscanfs because length is working only for %s */
344                 ret = sscanf(data + offset, "%2s%n ", c, &nrchars);
345                 if (ret != 1)
346                         goto err;
347 
348                 ret = sscanf(c, "%2x", &cmd);
349                 if (ret != 1)
350                         goto err;
351 
352                 pattern[i] = (u8)cmd;
353                 offset += nrchars;
354                 i++;
355         }
356 
357         /* Each instruction is 16bit long. Check that length is even */
358         if (i % 2)
359                 goto err;
360 
361         for (i = 0; i < LP5523_PROGRAM_LENGTH; i++) {
362                 ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + i, pattern[i]);
363                 if (ret)
364                         return -EINVAL;
365         }
366 
367         return size;
368 
369 err:
370         dev_err(&chip->cl->dev, "wrong pattern format\n");
371         return -EINVAL;
372 }
373 
374 static void lp5523_firmware_loaded(struct lp55xx_chip *chip)
375 {
376         const struct firmware *fw = chip->fw;
377 
378         if (fw->size > LP5523_PROGRAM_LENGTH) {
379                 dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
380                         fw->size);
381                 return;
382         }
383 
384         /*
385          * Program momery sequence
386          *  1) set engine mode to "LOAD"
387          *  2) write firmware data into program memory
388          */
389 
390         lp5523_load_engine_and_select_page(chip);
391         lp5523_update_program_memory(chip, fw->data, fw->size);
392 }
393 
394 static ssize_t show_engine_mode(struct device *dev,
395                                 struct device_attribute *attr,
396                                 char *buf, int nr)
397 {
398         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
399         struct lp55xx_chip *chip = led->chip;
400         enum lp55xx_engine_mode mode = chip->engines[nr - 1].mode;
401 
402         switch (mode) {
403         case LP55XX_ENGINE_RUN:
404                 return sprintf(buf, "run\n");
405         case LP55XX_ENGINE_LOAD:
406                 return sprintf(buf, "load\n");
407         case LP55XX_ENGINE_DISABLED:
408         default:
409                 return sprintf(buf, "disabled\n");
410         }
411 }
412 show_mode(1)
413 show_mode(2)
414 show_mode(3)
415 
416 static ssize_t store_engine_mode(struct device *dev,
417                                  struct device_attribute *attr,
418                                  const char *buf, size_t len, int nr)
419 {
420         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
421         struct lp55xx_chip *chip = led->chip;
422         struct lp55xx_engine *engine = &chip->engines[nr - 1];
423 
424         mutex_lock(&chip->lock);
425 
426         chip->engine_idx = nr;
427 
428         if (!strncmp(buf, "run", 3)) {
429                 lp5523_run_engine(chip, true);
430                 engine->mode = LP55XX_ENGINE_RUN;
431         } else if (!strncmp(buf, "load", 4)) {
432                 lp5523_stop_engine(chip);
433                 lp5523_load_engine(chip);
434                 engine->mode = LP55XX_ENGINE_LOAD;
435         } else if (!strncmp(buf, "disabled", 8)) {
436                 lp5523_stop_engine(chip);
437                 engine->mode = LP55XX_ENGINE_DISABLED;
438         }
439 
440         mutex_unlock(&chip->lock);
441 
442         return len;
443 }
444 store_mode(1)
445 store_mode(2)
446 store_mode(3)
447 
448 static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
449 {
450         u16 tmp_mux = 0;
451         int i;
452 
453         len = min_t(int, len, LP5523_MAX_LEDS);
454 
455         for (i = 0; i < len; i++) {
456                 switch (buf[i]) {
457                 case '1':
458                         tmp_mux |= (1 << i);
459                         break;
460                 case '':
461                         break;
462                 case '\n':
463                         i = len;
464                         break;
465                 default:
466                         return -1;
467                 }
468         }
469         *mux = tmp_mux;
470 
471         return 0;
472 }
473 
474 static void lp5523_mux_to_array(u16 led_mux, char *array)
475 {
476         int i, pos = 0;
477         for (i = 0; i < LP5523_MAX_LEDS; i++)
478                 pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));
479 
480         array[pos] = '\0';
481 }
482 
483 static ssize_t show_engine_leds(struct device *dev,
484                             struct device_attribute *attr,
485                             char *buf, int nr)
486 {
487         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
488         struct lp55xx_chip *chip = led->chip;
489         char mux[LP5523_MAX_LEDS + 1];
490 
491         lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);
492 
493         return sprintf(buf, "%s\n", mux);
494 }
495 show_leds(1)
496 show_leds(2)
497 show_leds(3)
498 
499 static int lp5523_load_mux(struct lp55xx_chip *chip, u16 mux, int nr)
500 {
501         struct lp55xx_engine *engine = &chip->engines[nr - 1];
502         int ret;
503         u8 mux_page[] = {
504                 [LP55XX_ENGINE_1] = LP5523_PAGE_MUX1,
505                 [LP55XX_ENGINE_2] = LP5523_PAGE_MUX2,
506                 [LP55XX_ENGINE_3] = LP5523_PAGE_MUX3,
507         };
508 
509         lp5523_load_engine(chip);
510 
511         ret = lp55xx_write(chip, LP5523_REG_PROG_PAGE_SEL, mux_page[nr]);
512         if (ret)
513                 return ret;
514 
515         ret = lp55xx_write(chip, LP5523_REG_PROG_MEM , (u8)(mux >> 8));
516         if (ret)
517                 return ret;
518 
519         ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + 1, (u8)(mux));
520         if (ret)
521                 return ret;
522 
523         engine->led_mux = mux;
524         return 0;
525 }
526 
527 static ssize_t store_engine_leds(struct device *dev,
528                              struct device_attribute *attr,
529                              const char *buf, size_t len, int nr)
530 {
531         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
532         struct lp55xx_chip *chip = led->chip;
533         struct lp55xx_engine *engine = &chip->engines[nr - 1];
534         u16 mux = 0;
535         ssize_t ret;
536 
537         if (lp5523_mux_parse(buf, &mux, len))
538                 return -EINVAL;
539 
540         mutex_lock(&chip->lock);
541 
542         chip->engine_idx = nr;
543         ret = -EINVAL;
544 
545         if (engine->mode != LP55XX_ENGINE_LOAD)
546                 goto leave;
547 
548         if (lp5523_load_mux(chip, mux, nr))
549                 goto leave;
550 
551         ret = len;
552 leave:
553         mutex_unlock(&chip->lock);
554         return ret;
555 }
556 store_leds(1)
557 store_leds(2)
558 store_leds(3)
559 
560 static ssize_t store_engine_load(struct device *dev,
561                              struct device_attribute *attr,
562                              const char *buf, size_t len, int nr)
563 {
564         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
565         struct lp55xx_chip *chip = led->chip;
566         int ret;
567 
568         mutex_lock(&chip->lock);
569 
570         chip->engine_idx = nr;
571         lp5523_load_engine_and_select_page(chip);
572         ret = lp5523_update_program_memory(chip, buf, len);
573 
574         mutex_unlock(&chip->lock);
575 
576         return ret;
577 }
578 store_load(1)
579 store_load(2)
580 store_load(3)
581 
582 static ssize_t lp5523_selftest(struct device *dev,
583                                struct device_attribute *attr,
584                                char *buf)
585 {
586         struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
587         struct lp55xx_chip *chip = led->chip;
588         struct lp55xx_platform_data *pdata = chip->pdata;
589         int i, ret, pos = 0;
590         u8 status, adc, vdd;
591 
592         mutex_lock(&chip->lock);
593 
594         ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
595         if (ret < 0)
596                 goto fail;
597 
598         /* Check that ext clock is really in use if requested */
599         if (pdata->clock_mode == LP55XX_CLOCK_EXT) {
600                 if  ((status & LP5523_EXT_CLK_USED) == 0)
601                         goto fail;
602         }
603 
604         /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
605         lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16);
606         usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
607         ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
608         if (ret < 0)
609                 goto fail;
610 
611         if (!(status & LP5523_LEDTEST_DONE))
612                 usleep_range(3000, 6000); /* Was not ready. Wait little bit */
613 
614         ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd);
615         if (ret < 0)
616                 goto fail;
617 
618         vdd--;  /* There may be some fluctuation in measurement */
619 
620         for (i = 0; i < LP5523_MAX_LEDS; i++) {
621                 /* Skip non-existing channels */
622                 if (pdata->led_config[i].led_current == 0)
623                         continue;
624 
625                 /* Set default current */
626                 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
627                         pdata->led_config[i].led_current);
628 
629                 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0xff);
630                 /* let current stabilize 2 - 4ms before measurements start */
631                 usleep_range(2000, 4000);
632                 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL,
633                              LP5523_EN_LEDTEST | i);
634                 /* ADC conversion time is 2.7 ms typically */
635                 usleep_range(3000, 6000);
636                 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
637                 if (ret < 0)
638                         goto fail;
639 
640                 if (!(status & LP5523_LEDTEST_DONE))
641                         usleep_range(3000, 6000);/* Was not ready. Wait. */
642 
643                 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc);
644                 if (ret < 0)
645                         goto fail;
646 
647                 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
648                         pos += sprintf(buf + pos, "LED %d FAIL\n", i);
649 
650                 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + i, 0x00);
651 
652                 /* Restore current */
653                 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + i,
654                         led->led_current);
655                 led++;
656         }
657         if (pos == 0)
658                 pos = sprintf(buf, "OK\n");
659         goto release_lock;
660 fail:
661         pos = sprintf(buf, "FAIL\n");
662 
663 release_lock:
664         mutex_unlock(&chip->lock);
665 
666         return pos;
667 }
668 
669 static void lp5523_led_brightness_work(struct work_struct *work)
670 {
671         struct lp55xx_led *led = container_of(work, struct lp55xx_led,
672                                               brightness_work);
673         struct lp55xx_chip *chip = led->chip;
674 
675         mutex_lock(&chip->lock);
676         lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
677                      led->brightness);
678         mutex_unlock(&chip->lock);
679 }
680 
681 static LP55XX_DEV_ATTR_RW(engine1_mode, show_engine1_mode, store_engine1_mode);
682 static LP55XX_DEV_ATTR_RW(engine2_mode, show_engine2_mode, store_engine2_mode);
683 static LP55XX_DEV_ATTR_RW(engine3_mode, show_engine3_mode, store_engine3_mode);
684 static LP55XX_DEV_ATTR_RW(engine1_leds, show_engine1_leds, store_engine1_leds);
685 static LP55XX_DEV_ATTR_RW(engine2_leds, show_engine2_leds, store_engine2_leds);
686 static LP55XX_DEV_ATTR_RW(engine3_leds, show_engine3_leds, store_engine3_leds);
687 static LP55XX_DEV_ATTR_WO(engine1_load, store_engine1_load);
688 static LP55XX_DEV_ATTR_WO(engine2_load, store_engine2_load);
689 static LP55XX_DEV_ATTR_WO(engine3_load, store_engine3_load);
690 static LP55XX_DEV_ATTR_RO(selftest, lp5523_selftest);
691 
692 static struct attribute *lp5523_attributes[] = {
693         &dev_attr_engine1_mode.attr,
694         &dev_attr_engine2_mode.attr,
695         &dev_attr_engine3_mode.attr,
696         &dev_attr_engine1_load.attr,
697         &dev_attr_engine2_load.attr,
698         &dev_attr_engine3_load.attr,
699         &dev_attr_engine1_leds.attr,
700         &dev_attr_engine2_leds.attr,
701         &dev_attr_engine3_leds.attr,
702         &dev_attr_selftest.attr,
703         NULL,
704 };
705 
706 static const struct attribute_group lp5523_group = {
707         .attrs = lp5523_attributes,
708 };
709 
710 /* Chip specific configurations */
711 static struct lp55xx_device_config lp5523_cfg = {
712         .reset = {
713                 .addr = LP5523_REG_RESET,
714                 .val  = LP5523_RESET,
715         },
716         .enable = {
717                 .addr = LP5523_REG_ENABLE,
718                 .val  = LP5523_ENABLE,
719         },
720         .max_channel  = LP5523_MAX_LEDS,
721         .post_init_device   = lp5523_post_init_device,
722         .brightness_work_fn = lp5523_led_brightness_work,
723         .set_led_current    = lp5523_set_led_current,
724         .firmware_cb        = lp5523_firmware_loaded,
725         .run_engine         = lp5523_run_engine,
726         .dev_attr_group     = &lp5523_group,
727 };
728 
729 static int lp5523_probe(struct i2c_client *client,
730                         const struct i2c_device_id *id)
731 {
732         int ret;
733         struct lp55xx_chip *chip;
734         struct lp55xx_led *led;
735         struct lp55xx_platform_data *pdata;
736         struct device_node *np = client->dev.of_node;
737 
738         if (!dev_get_platdata(&client->dev)) {
739                 if (np) {
740                         ret = lp55xx_of_populate_pdata(&client->dev, np);
741                         if (ret < 0)
742                                 return ret;
743                 } else {
744                         dev_err(&client->dev, "no platform data\n");
745                         return -EINVAL;
746                 }
747         }
748         pdata = dev_get_platdata(&client->dev);
749 
750         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
751         if (!chip)
752                 return -ENOMEM;
753 
754         led = devm_kzalloc(&client->dev,
755                         sizeof(*led) * pdata->num_channels, GFP_KERNEL);
756         if (!led)
757                 return -ENOMEM;
758 
759         chip->cl = client;
760         chip->pdata = pdata;
761         chip->cfg = &lp5523_cfg;
762 
763         mutex_init(&chip->lock);
764 
765         i2c_set_clientdata(client, led);
766 
767         ret = lp55xx_init_device(chip);
768         if (ret)
769                 goto err_init;
770 
771         dev_info(&client->dev, "%s Programmable led chip found\n", id->name);
772 
773         ret = lp55xx_register_leds(led, chip);
774         if (ret)
775                 goto err_register_leds;
776 
777         ret = lp55xx_register_sysfs(chip);
778         if (ret) {
779                 dev_err(&client->dev, "registering sysfs failed\n");
780                 goto err_register_sysfs;
781         }
782 
783         return 0;
784 
785 err_register_sysfs:
786         lp55xx_unregister_leds(led, chip);
787 err_register_leds:
788         lp55xx_deinit_device(chip);
789 err_init:
790         return ret;
791 }
792 
793 static int lp5523_remove(struct i2c_client *client)
794 {
795         struct lp55xx_led *led = i2c_get_clientdata(client);
796         struct lp55xx_chip *chip = led->chip;
797 
798         lp5523_stop_all_engines(chip);
799         lp55xx_unregister_sysfs(chip);
800         lp55xx_unregister_leds(led, chip);
801         lp55xx_deinit_device(chip);
802 
803         return 0;
804 }
805 
806 static const struct i2c_device_id lp5523_id[] = {
807         { "lp5523",  LP5523 },
808         { "lp55231", LP55231 },
809         { }
810 };
811 
812 MODULE_DEVICE_TABLE(i2c, lp5523_id);
813 
814 #ifdef CONFIG_OF
815 static const struct of_device_id of_lp5523_leds_match[] = {
816         { .compatible = "national,lp5523", },
817         { .compatible = "ti,lp55231", },
818         {},
819 };
820 
821 MODULE_DEVICE_TABLE(of, of_lp5523_leds_match);
822 #endif
823 
824 static struct i2c_driver lp5523_driver = {
825         .driver = {
826                 .name   = "lp5523x",
827                 .of_match_table = of_match_ptr(of_lp5523_leds_match),
828         },
829         .probe          = lp5523_probe,
830         .remove         = lp5523_remove,
831         .id_table       = lp5523_id,
832 };
833 
834 module_i2c_driver(lp5523_driver);
835 
836 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
837 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
838 MODULE_DESCRIPTION("LP5523 LED engine");
839 MODULE_LICENSE("GPL");
840 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us