projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
leds-lp5523: add new device id for LP55231
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / leds / leds-lp5523.c
CommitLineData
0efba16c
SO		 1/*
2 * lp5523.c - LP5523 LED Driver
3 *
4 * Copyright (C) 2010 Nokia Corporation
5 *
6 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 */
22
23#include <linux/module.h>
24#include <linux/init.h>
25#include <linux/i2c.h>
26#include <linux/mutex.h>
27#include <linux/gpio.h>
28#include <linux/interrupt.h>
29#include <linux/delay.h>
30#include <linux/ctype.h>
31#include <linux/spinlock.h>
32#include <linux/wait.h>
33#include <linux/leds.h>
34#include <linux/leds-lp5523.h>
35#include <linux/workqueue.h>
36#include <linux/slab.h>
37
38#define LP5523_REG_ENABLE 0x00
39#define LP5523_REG_OP_MODE 0x01
40#define LP5523_REG_RATIOMETRIC_MSB 0x02
41#define LP5523_REG_RATIOMETRIC_LSB 0x03
42#define LP5523_REG_ENABLE_LEDS_MSB 0x04
43#define LP5523_REG_ENABLE_LEDS_LSB 0x05
44#define LP5523_REG_LED_CNTRL_BASE 0x06
45#define LP5523_REG_LED_PWM_BASE 0x16
46#define LP5523_REG_LED_CURRENT_BASE 0x26
47#define LP5523_REG_CONFIG 0x36
48#define LP5523_REG_CHANNEL1_PC 0x37
49#define LP5523_REG_CHANNEL2_PC 0x38
50#define LP5523_REG_CHANNEL3_PC 0x39
51#define LP5523_REG_STATUS 0x3a
52#define LP5523_REG_GPO 0x3b
53#define LP5523_REG_VARIABLE 0x3c
54#define LP5523_REG_RESET 0x3d
55#define LP5523_REG_TEMP_CTRL 0x3e
56#define LP5523_REG_TEMP_READ 0x3f
57#define LP5523_REG_TEMP_WRITE 0x40
58#define LP5523_REG_LED_TEST_CTRL 0x41
59#define LP5523_REG_LED_TEST_ADC 0x42
60#define LP5523_REG_ENG1_VARIABLE 0x45
61#define LP5523_REG_ENG2_VARIABLE 0x46
62#define LP5523_REG_ENG3_VARIABLE 0x47
63#define LP5523_REG_MASTER_FADER1 0x48
64#define LP5523_REG_MASTER_FADER2 0x49
65#define LP5523_REG_MASTER_FADER3 0x4a
66#define LP5523_REG_CH1_PROG_START 0x4c
67#define LP5523_REG_CH2_PROG_START 0x4d
68#define LP5523_REG_CH3_PROG_START 0x4e
69#define LP5523_REG_PROG_PAGE_SEL 0x4f
70#define LP5523_REG_PROG_MEM 0x50
71
72#define LP5523_CMD_LOAD 0x15 /* 00010101 */
73#define LP5523_CMD_RUN 0x2a /* 00101010 */
74#define LP5523_CMD_DISABLED 0x00 /* 00000000 */
75
76#define LP5523_ENABLE 0x40
77#define LP5523_AUTO_INC 0x40
78#define LP5523_PWR_SAVE 0x20
79#define LP5523_PWM_PWR_SAVE 0x04
80#define LP5523_CP_1 0x08
81#define LP5523_CP_1_5 0x10
82#define LP5523_CP_AUTO 0x18
83#define LP5523_INT_CLK 0x01
84#define LP5523_AUTO_CLK 0x02
85#define LP5523_EN_LEDTEST 0x80
86#define LP5523_LEDTEST_DONE 0x80
87
88#define LP5523_DEFAULT_CURRENT 50 /* microAmps */
89#define LP5523_PROGRAM_LENGTH 32 /* in bytes */
90#define LP5523_PROGRAM_PAGES 6
91#define LP5523_ADC_SHORTCIRC_LIM 80
92
93#define LP5523_LEDS 9
94#define LP5523_ENGINES 3
95
96#define LP5523_ENG_MASK_BASE 0x30 /* 00110000 */
97
98#define LP5523_ENG_STATUS_MASK 0x07 /* 00000111 */
99
100#define LP5523_IRQ_FLAGS IRQF_TRIGGER_FALLING
101
102#define LP5523_EXT_CLK_USED 0x08
103
104#define LED_ACTIVE(mux, led) (!!(mux & (0x0001 << led)))
105#define SHIFT_MASK(id) (((id) - 1) * 2)
106
27d7704e
KM		 107enum lp5523_chip_id {
108 LP5523,
109 LP55231,
110};
111
0efba16c 112struct lp5523_engine {
0efba16c
SO		 113 int id;
114 u8 mode;
115 u8 prog_page;
116 u8 mux_page;
117 u16 led_mux;
118 u8 engine_mask;
119};
120
121struct lp5523_led {
122 int id;
123 u8 chan_nr;
124 u8 led_current;
125 u8 max_current;
126 struct led_classdev cdev;
127 struct work_struct brightness_work;
128 u8 brightness;
129};
130
131struct lp5523_chip {
132 struct mutex lock; /* Serialize control */
133 struct i2c_client *client;
134 struct lp5523_engine engines[LP5523_ENGINES];
135 struct lp5523_led leds[LP5523_LEDS];
136 struct lp5523_platform_data *pdata;
137 u8 num_channels;
138 u8 num_leds;
139};
140
87dbf623
SO		 141static inline struct lp5523_led *cdev_to_led(struct led_classdev *cdev)
142{
143 return container_of(cdev, struct lp5523_led, cdev);
144}
0efba16c 145
87dbf623 146static inline struct lp5523_chip *engine_to_lp5523(struct lp5523_engine *engine)
0efba16c
SO		 147{
148 return container_of(engine, struct lp5523_chip,
149 engines[engine->id - 1]);
150}
151
87dbf623 152static inline struct lp5523_chip *led_to_lp5523(struct lp5523_led *led)
0efba16c
SO		 153{
154 return container_of(led, struct lp5523_chip,
155 leds[led->id]);
156}
157
6f6365fb 158static void lp5523_set_mode(struct lp5523_engine *engine, u8 mode);
0efba16c 159static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode);
d06cb46c 160static int lp5523_load_program(struct lp5523_engine *engine, const u8 *pattern);
0efba16c
SO		 161
162static void lp5523_led_brightness_work(struct work_struct *work);
163
164static int lp5523_write(struct i2c_client *client, u8 reg, u8 value)
165{
166 return i2c_smbus_write_byte_data(client, reg, value);
167}
168
169static int lp5523_read(struct i2c_client *client, u8 reg, u8 *buf)
170{
171 s32 ret = i2c_smbus_read_byte_data(client, reg);
172
173 if (ret < 0)
174 return -EIO;
175
176 *buf = ret;
177 return 0;
178}
179
180static int lp5523_detect(struct i2c_client *client)
181{
182 int ret;
183 u8 buf;
184
469eba02 185 ret = lp5523_write(client, LP5523_REG_ENABLE, LP5523_ENABLE);
0efba16c
SO		 186 if (ret)
187 return ret;
188 ret = lp5523_read(client, LP5523_REG_ENABLE, &buf);
189 if (ret)
190 return ret;
191 if (buf == 0x40)
192 return 0;
193 else
194 return -ENODEV;
195}
196
197static int lp5523_configure(struct i2c_client *client)
198{
199 struct lp5523_chip *chip = i2c_get_clientdata(client);
200 int ret = 0;
201 u8 status;
202
203 /* one pattern per engine setting led mux start and stop addresses */
d06cb46c 204 static const u8 pattern[][LP5523_PROGRAM_LENGTH] = {
0efba16c
SO		 205 { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
206 { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
207 { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
208 };
209
0efba16c 210 ret |= lp5523_write(client, LP5523_REG_ENABLE, LP5523_ENABLE);
2e4840ed
SO		 211 /* Chip startup time is 500 us, 1 - 2 ms gives some margin */
212 usleep_range(1000, 2000);
0efba16c
SO		 213
214 ret |= lp5523_write(client, LP5523_REG_CONFIG,
215 LP5523_AUTO_INC | LP5523_PWR_SAVE |
216 LP5523_CP_AUTO | LP5523_AUTO_CLK |
217 LP5523_PWM_PWR_SAVE);
218
219 /* turn on all leds */
220 ret |= lp5523_write(client, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
221 ret |= lp5523_write(client, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
222
223 /* hardcode 32 bytes of memory for each engine from program memory */
224 ret |= lp5523_write(client, LP5523_REG_CH1_PROG_START, 0x00);
225 ret |= lp5523_write(client, LP5523_REG_CH2_PROG_START, 0x10);
226 ret |= lp5523_write(client, LP5523_REG_CH3_PROG_START, 0x20);
227
228 /* write led mux address space for each channel */
229 ret |= lp5523_load_program(&chip->engines[0], pattern[0]);
230 ret |= lp5523_load_program(&chip->engines[1], pattern[1]);
231 ret |= lp5523_load_program(&chip->engines[2], pattern[2]);
232
233 if (ret) {
234 dev_err(&client->dev, "could not load mux programs\n");
235 return -1;
236 }
237
238 /* set all engines exec state and mode to run 00101010 */
239 ret |= lp5523_write(client, LP5523_REG_ENABLE,
240 (LP5523_CMD_RUN | LP5523_ENABLE));
241
242 ret |= lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_RUN);
243
244 if (ret) {
245 dev_err(&client->dev, "could not start mux programs\n");
246 return -1;
247 }
248
2e4840ed
SO		 249 /* Let the programs run for couple of ms and check the engine status */
250 usleep_range(3000, 6000);
0efba16c
SO		 251 lp5523_read(client, LP5523_REG_STATUS, &status);
252 status &= LP5523_ENG_STATUS_MASK;
253
254 if (status == LP5523_ENG_STATUS_MASK) {
255 dev_dbg(&client->dev, "all engines configured\n");
256 } else {
257 dev_info(&client->dev, "status == %x\n", status);
258 dev_err(&client->dev, "cound not configure LED engine\n");
259 return -1;
260 }
261
262 dev_info(&client->dev, "disabling engines\n");
263
264 ret |= lp5523_write(client, LP5523_REG_OP_MODE, LP5523_CMD_DISABLED);
265
266 return ret;
267}
268
269static int lp5523_set_engine_mode(struct lp5523_engine *engine, u8 mode)
270{
271 struct lp5523_chip *chip = engine_to_lp5523(engine);
272 struct i2c_client *client = chip->client;
273 int ret;
274 u8 engine_state;
275
276 ret = lp5523_read(client, LP5523_REG_OP_MODE, &engine_state);
277 if (ret)
278 goto fail;
279
280 engine_state &= ~(engine->engine_mask);
281
282 /* set mode only for this engine */
283 mode &= engine->engine_mask;
284
285 engine_state |= mode;
286
287 ret |= lp5523_write(client, LP5523_REG_OP_MODE, engine_state);
288fail:
289 return ret;
290}
291
292static int lp5523_load_mux(struct lp5523_engine *engine, u16 mux)
293{
294 struct lp5523_chip *chip = engine_to_lp5523(engine);
295 struct i2c_client *client = chip->client;
296 int ret = 0;
297
298 ret |= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
299
300 ret |= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL, engine->mux_page);
301 ret |= lp5523_write(client, LP5523_REG_PROG_MEM,
302 (u8)(mux >> 8));
303 ret |= lp5523_write(client, LP5523_REG_PROG_MEM + 1, (u8)(mux));
304 engine->led_mux = mux;
305
306 return ret;
307}
308
d06cb46c 309static int lp5523_load_program(struct lp5523_engine *engine, const u8 *pattern)
0efba16c
SO		 310{
311 struct lp5523_chip *chip = engine_to_lp5523(engine);
312 struct i2c_client *client = chip->client;
313
314 int ret = 0;
315
316 ret |= lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
317
318 ret |= lp5523_write(client, LP5523_REG_PROG_PAGE_SEL,
319 engine->prog_page);
320 ret |= i2c_smbus_write_i2c_block_data(client, LP5523_REG_PROG_MEM,
321 LP5523_PROGRAM_LENGTH, pattern);
322
323 return ret;
324}
325
326static int lp5523_run_program(struct lp5523_engine *engine)
327{
328 struct lp5523_chip *chip = engine_to_lp5523(engine);
329 struct i2c_client *client = chip->client;
330 int ret;
331
332 ret = lp5523_write(client, LP5523_REG_ENABLE,
333 LP5523_CMD_RUN | LP5523_ENABLE);
334 if (ret)
335 goto fail;
336
337 ret = lp5523_set_engine_mode(engine, LP5523_CMD_RUN);
338fail:
339 return ret;
340}
341
342static int lp5523_mux_parse(const char *buf, u16 *mux, size_t len)
343{
344 int i;
345 u16 tmp_mux = 0;
469eba02
KM		 346
347 len = min_t(int, len, LP5523_LEDS);
0efba16c
SO		 348 for (i = 0; i < len; i++) {
349 switch (buf[i]) {
350 case '1':
351 tmp_mux |= (1 << i);
352 break;
353 case '0':
354 break;
355 case '\n':
356 i = len;
357 break;
358 default:
359 return -1;
360 }
361 }
362 *mux = tmp_mux;
363
364 return 0;
365}
366
367static void lp5523_mux_to_array(u16 led_mux, char *array)
368{
369 int i, pos = 0;
370 for (i = 0; i < LP5523_LEDS; i++)
371 pos += sprintf(array + pos, "%x", LED_ACTIVE(led_mux, i));
372
373 array[pos] = '\0';
374}
375
376/*--------------------------------------------------------------*/
377/* Sysfs interface */
378/*--------------------------------------------------------------*/
379
380static ssize_t show_engine_leds(struct device *dev,
381 struct device_attribute *attr,
382 char *buf, int nr)
383{
384 struct i2c_client *client = to_i2c_client(dev);
385 struct lp5523_chip *chip = i2c_get_clientdata(client);
386 char mux[LP5523_LEDS + 1];
387
388 lp5523_mux_to_array(chip->engines[nr - 1].led_mux, mux);
389
390 return sprintf(buf, "%s\n", mux);
391}
392
393#define show_leds(nr) \
394static ssize_t show_engine##nr##_leds(struct device *dev, \
395 struct device_attribute *attr, \
396 char *buf) \
397{ \
398 return show_engine_leds(dev, attr, buf, nr); \
399}
400show_leds(1)
401show_leds(2)
402show_leds(3)
403
404static ssize_t store_engine_leds(struct device *dev,
405 struct device_attribute *attr,
406 const char *buf, size_t len, int nr)
407{
408 struct i2c_client *client = to_i2c_client(dev);
409 struct lp5523_chip *chip = i2c_get_clientdata(client);
410 u16 mux = 0;
fbac0812 411 ssize_t ret;
0efba16c
SO		 412
413 if (lp5523_mux_parse(buf, &mux, len))
414 return -EINVAL;
415
fbac0812
SO		 416 mutex_lock(&chip->lock);
417 ret = -EINVAL;
418 if (chip->engines[nr - 1].mode != LP5523_CMD_LOAD)
419 goto leave;
420
0efba16c 421 if (lp5523_load_mux(&chip->engines[nr - 1], mux))
fbac0812 422 goto leave;
0efba16c 423
fbac0812
SO		 424 ret = len;
425leave:
426 mutex_unlock(&chip->lock);
427 return ret;
0efba16c
SO		 428}
429
430#define store_leds(nr) \
431static ssize_t store_engine##nr##_leds(struct device *dev, \
432 struct device_attribute *attr, \
433 const char *buf, size_t len) \
434{ \
435 return store_engine_leds(dev, attr, buf, len, nr); \
436}
437store_leds(1)
438store_leds(2)
439store_leds(3)
440
441static ssize_t lp5523_selftest(struct device *dev,
442 struct device_attribute *attr,
443 char *buf)
444{
445 struct i2c_client *client = to_i2c_client(dev);
446 struct lp5523_chip *chip = i2c_get_clientdata(client);
447 int i, ret, pos = 0;
448 int led = 0;
449 u8 status, adc, vdd;
450
451 mutex_lock(&chip->lock);
452
453 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
454 if (ret < 0)
455 goto fail;
456
457 /* Check that ext clock is really in use if requested */
458 if ((chip->pdata) && (chip->pdata->clock_mode == LP5523_CLOCK_EXT))
459 if ((status & LP5523_EXT_CLK_USED) == 0)
460 goto fail;
461
462 /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
463 lp5523_write(chip->client, LP5523_REG_LED_TEST_CTRL,
464 LP5523_EN_LEDTEST | 16);
2e4840ed 465 usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
0efba16c
SO		 466 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
467 if (!(status & LP5523_LEDTEST_DONE))
2e4840ed 468 usleep_range(3000, 6000); /* Was not ready. Wait little bit */
0efba16c
SO		 469
470 ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &vdd);
471 vdd--; /* There may be some fluctuation in measurement */
472
473 for (i = 0; i < LP5523_LEDS; i++) {
474 /* Skip non-existing channels */
475 if (chip->pdata->led_config[i].led_current == 0)
476 continue;
477
478 /* Set default current */
479 lp5523_write(chip->client,
480 LP5523_REG_LED_CURRENT_BASE + i,
481 chip->pdata->led_config[i].led_current);
482
483 lp5523_write(chip->client, LP5523_REG_LED_PWM_BASE + i, 0xff);
2e4840ed
SO		 484 /* let current stabilize 2 - 4ms before measurements start */
485 usleep_range(2000, 4000);
0efba16c
SO		 486 lp5523_write(chip->client,
487 LP5523_REG_LED_TEST_CTRL,
488 LP5523_EN_LEDTEST | i);
2e4840ed
SO		 489 /* ADC conversion time is 2.7 ms typically */
490 usleep_range(3000, 6000);
0efba16c
SO		 491 ret = lp5523_read(chip->client, LP5523_REG_STATUS, &status);
492 if (!(status & LP5523_LEDTEST_DONE))
2e4840ed 493 usleep_range(3000, 6000);/* Was not ready. Wait. */
0efba16c
SO		 494 ret |= lp5523_read(chip->client, LP5523_REG_LED_TEST_ADC, &adc);
495
496 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
497 pos += sprintf(buf + pos, "LED %d FAIL\n", i);
498
499 lp5523_write(chip->client, LP5523_REG_LED_PWM_BASE + i, 0x00);
500
501 /* Restore current */
502 lp5523_write(chip->client,
503 LP5523_REG_LED_CURRENT_BASE + i,
504 chip->leds[led].led_current);
505 led++;
506 }
507 if (pos == 0)
508 pos = sprintf(buf, "OK\n");
509 goto release_lock;
510fail:
511 pos = sprintf(buf, "FAIL\n");
512
513release_lock:
514 mutex_unlock(&chip->lock);
515
516 return pos;
517}
518
519static void lp5523_set_brightness(struct led_classdev *cdev,
520 enum led_brightness brightness)
521{
522 struct lp5523_led *led = cdev_to_led(cdev);
523
524 led->brightness = (u8)brightness;
525
526 schedule_work(&led->brightness_work);
527}
528
529static void lp5523_led_brightness_work(struct work_struct *work)
530{
531 struct lp5523_led *led = container_of(work,
532 struct lp5523_led,
533 brightness_work);
534 struct lp5523_chip *chip = led_to_lp5523(led);
535 struct i2c_client *client = chip->client;
536
537 mutex_lock(&chip->lock);
538
539 lp5523_write(client, LP5523_REG_LED_PWM_BASE + led->chan_nr,
540 led->brightness);
541
542 mutex_unlock(&chip->lock);
543}
544
545static int lp5523_do_store_load(struct lp5523_engine *engine,
546 const char *buf, size_t len)
547{
548 struct lp5523_chip *chip = engine_to_lp5523(engine);
549 struct i2c_client *client = chip->client;
550 int ret, nrchars, offset = 0, i = 0;
551 char c[3];
552 unsigned cmd;
553 u8 pattern[LP5523_PROGRAM_LENGTH] = {0};
554
469eba02
KM		 555 if (engine->mode != LP5523_CMD_LOAD)
556 return -EINVAL;
557
0efba16c
SO		 558 while ((offset < len - 1) && (i < LP5523_PROGRAM_LENGTH)) {
559 /* separate sscanfs because length is working only for %s */
560 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
561 ret = sscanf(c, "%2x", &cmd);
562 if (ret != 1)
563 goto fail;
564 pattern[i] = (u8)cmd;
565
566 offset += nrchars;
567 i++;
568 }
569
570 /* Each instruction is 16bit long. Check that length is even */
571 if (i % 2)
572 goto fail;
573
574 mutex_lock(&chip->lock);
469eba02 575 ret = lp5523_load_program(engine, pattern);
0efba16c
SO		 576 mutex_unlock(&chip->lock);
577
578 if (ret) {
579 dev_err(&client->dev, "failed loading pattern\n");
580 return ret;
581 }
582
583 return len;
584fail:
585 dev_err(&client->dev, "wrong pattern format\n");
586 return -EINVAL;
587}
588
589static ssize_t store_engine_load(struct device *dev,
590 struct device_attribute *attr,
591 const char *buf, size_t len, int nr)
592{
593 struct i2c_client *client = to_i2c_client(dev);
594 struct lp5523_chip *chip = i2c_get_clientdata(client);
595 return lp5523_do_store_load(&chip->engines[nr - 1], buf, len);
596}
597
598#define store_load(nr) \
599static ssize_t store_engine##nr##_load(struct device *dev, \
600 struct device_attribute *attr, \
601 const char *buf, size_t len) \
602{ \
603 return store_engine_load(dev, attr, buf, len, nr); \
604}
605store_load(1)
606store_load(2)
607store_load(3)
608
609static ssize_t show_engine_mode(struct device *dev,
610 struct device_attribute *attr,
611 char *buf, int nr)
612{
613 struct i2c_client *client = to_i2c_client(dev);
614 struct lp5523_chip *chip = i2c_get_clientdata(client);
615 switch (chip->engines[nr - 1].mode) {
616 case LP5523_CMD_RUN:
617 return sprintf(buf, "run\n");
618 case LP5523_CMD_LOAD:
619 return sprintf(buf, "load\n");
620 case LP5523_CMD_DISABLED:
621 return sprintf(buf, "disabled\n");
622 default:
623 return sprintf(buf, "disabled\n");
624 }
625}
626
627#define show_mode(nr) \
628static ssize_t show_engine##nr##_mode(struct device *dev, \
629 struct device_attribute *attr, \
630 char *buf) \
631{ \
632 return show_engine_mode(dev, attr, buf, nr); \
633}
634show_mode(1)
635show_mode(2)
636show_mode(3)
637
638static ssize_t store_engine_mode(struct device *dev,
639 struct device_attribute *attr,
640 const char *buf, size_t len, int nr)
641{
642 struct i2c_client *client = to_i2c_client(dev);
643 struct lp5523_chip *chip = i2c_get_clientdata(client);
644 struct lp5523_engine *engine = &chip->engines[nr - 1];
645 mutex_lock(&chip->lock);
646
647 if (!strncmp(buf, "run", 3))
648 lp5523_set_mode(engine, LP5523_CMD_RUN);
649 else if (!strncmp(buf, "load", 4))
650 lp5523_set_mode(engine, LP5523_CMD_LOAD);
651 else if (!strncmp(buf, "disabled", 8))
652 lp5523_set_mode(engine, LP5523_CMD_DISABLED);
653
654 mutex_unlock(&chip->lock);
655 return len;
656}
657
658#define store_mode(nr) \
659static ssize_t store_engine##nr##_mode(struct device *dev, \
660 struct device_attribute *attr, \
661 const char *buf, size_t len) \
662{ \
663 return store_engine_mode(dev, attr, buf, len, nr); \
664}
665store_mode(1)
666store_mode(2)
667store_mode(3)
668
669static ssize_t show_max_current(struct device *dev,
670 struct device_attribute *attr,
671 char *buf)
672{
673 struct led_classdev *led_cdev = dev_get_drvdata(dev);
674 struct lp5523_led *led = cdev_to_led(led_cdev);
675
676 return sprintf(buf, "%d\n", led->max_current);
677}
678
679static ssize_t show_current(struct device *dev,
680 struct device_attribute *attr,
681 char *buf)
682{
683 struct led_classdev *led_cdev = dev_get_drvdata(dev);
684 struct lp5523_led *led = cdev_to_led(led_cdev);
685
686 return sprintf(buf, "%d\n", led->led_current);
687}
688
689static ssize_t store_current(struct device *dev,
690 struct device_attribute *attr,
691 const char *buf, size_t len)
692{
693 struct led_classdev *led_cdev = dev_get_drvdata(dev);
694 struct lp5523_led *led = cdev_to_led(led_cdev);
695 struct lp5523_chip *chip = led_to_lp5523(led);
696 ssize_t ret;
697 unsigned long curr;
698
699 if (strict_strtoul(buf, 0, &curr))
700 return -EINVAL;
701
702 if (curr > led->max_current)
703 return -EINVAL;
704
705 mutex_lock(&chip->lock);
706 ret = lp5523_write(chip->client,
707 LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
708 (u8)curr);
709 mutex_unlock(&chip->lock);
710
711 if (ret < 0)
712 return ret;
713
714 led->led_current = (u8)curr;
715
716 return len;
717}
718
719/* led class device attributes */
ccd7510f 720static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR, show_current, store_current);
0efba16c
SO		 721static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL);
722
723static struct attribute *lp5523_led_attributes[] = {
724 &dev_attr_led_current.attr,
725 &dev_attr_max_current.attr,
726 NULL,
727};
728
729static struct attribute_group lp5523_led_attribute_group = {
730 .attrs = lp5523_led_attributes
731};
732
733/* device attributes */
ccd7510f 734static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR,
0efba16c 735 show_engine1_mode, store_engine1_mode);
ccd7510f 736static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR,
0efba16c 737 show_engine2_mode, store_engine2_mode);
ccd7510f 738static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR,
0efba16c 739 show_engine3_mode, store_engine3_mode);
ccd7510f 740static DEVICE_ATTR(engine1_leds, S_IRUGO | S_IWUSR,
0efba16c 741 show_engine1_leds, store_engine1_leds);
ccd7510f 742static DEVICE_ATTR(engine2_leds, S_IRUGO | S_IWUSR,
0efba16c 743 show_engine2_leds, store_engine2_leds);
ccd7510f 744static DEVICE_ATTR(engine3_leds, S_IRUGO | S_IWUSR,
0efba16c 745 show_engine3_leds, store_engine3_leds);
ccd7510f
VK		 746static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
747static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
748static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
0efba16c
SO		 749static DEVICE_ATTR(selftest, S_IRUGO, lp5523_selftest, NULL);
750
751static struct attribute *lp5523_attributes[] = {
752 &dev_attr_engine1_mode.attr,
753 &dev_attr_engine2_mode.attr,
754 &dev_attr_engine3_mode.attr,
755 &dev_attr_selftest.attr,
0efba16c
SO		 756 &dev_attr_engine1_load.attr,
757 &dev_attr_engine1_leds.attr,
0efba16c
SO		 758 &dev_attr_engine2_load.attr,
759 &dev_attr_engine2_leds.attr,
0efba16c
SO		 760 &dev_attr_engine3_load.attr,
761 &dev_attr_engine3_leds.attr,
0efba16c
SO		 762};
763
764static const struct attribute_group lp5523_group = {
765 .attrs = lp5523_attributes,
766};
767
0efba16c
SO		 768static int lp5523_register_sysfs(struct i2c_client *client)
769{
770 struct device *dev = &client->dev;
771 int ret;
772
773 ret = sysfs_create_group(&dev->kobj, &lp5523_group);
774 if (ret < 0)
775 return ret;
776
777 return 0;
778}
779
780static void lp5523_unregister_sysfs(struct i2c_client *client)
781{
782 struct lp5523_chip *chip = i2c_get_clientdata(client);
783 struct device *dev = &client->dev;
784 int i;
785
786 sysfs_remove_group(&dev->kobj, &lp5523_group);
787
0efba16c
SO		 788 for (i = 0; i < chip->num_leds; i++)
789 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
790 &lp5523_led_attribute_group);
791}
792
793/*--------------------------------------------------------------*/
794/* Set chip operating mode */
795/*--------------------------------------------------------------*/
6f6365fb 796static void lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
0efba16c 797{
0efba16c
SO		 798 /* if in that mode already do nothing, except for run */
799 if (mode == engine->mode && mode != LP5523_CMD_RUN)
6f6365fb 800 return;
0efba16c 801
6f6365fb
KM		 802 switch (mode) {
803 case LP5523_CMD_RUN:
804 lp5523_run_program(engine);
805 break;
806 case LP5523_CMD_LOAD:
0efba16c
SO		 807 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
808 lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
6f6365fb
KM		 809 break;
810 case LP5523_CMD_DISABLED:
0efba16c 811 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
6f6365fb
KM		 812 break;
813 default:
814 return;
0efba16c
SO		 815 }
816
0efba16c 817 engine->mode = mode;
0efba16c
SO		 818}
819
820/*--------------------------------------------------------------*/
821/* Probe, Attach, Remove */
822/*--------------------------------------------------------------*/
823static int __init lp5523_init_engine(struct lp5523_engine *engine, int id)
824{
825 if (id < 1 || id > LP5523_ENGINES)
826 return -1;
827 engine->id = id;
828 engine->engine_mask = LP5523_ENG_MASK_BASE >> SHIFT_MASK(id);
829 engine->prog_page = id - 1;
830 engine->mux_page = id + 2;
0efba16c
SO		 831
832 return 0;
833}
834
33721bd3 835static int __devinit lp5523_init_led(struct lp5523_led *led, struct device *dev,
0efba16c
SO		 836 int chan, struct lp5523_platform_data *pdata)
837{
838 char name[32];
839 int res;
840
841 if (chan >= LP5523_LEDS)
842 return -EINVAL;
843
844 if (pdata->led_config[chan].led_current) {
845 led->led_current = pdata->led_config[chan].led_current;
846 led->max_current = pdata->led_config[chan].max_current;
847 led->chan_nr = pdata->led_config[chan].chan_nr;
848
849 if (led->chan_nr >= LP5523_LEDS) {
850 dev_err(dev, "Use channel numbers between 0 and %d\n",
851 LP5523_LEDS - 1);
852 return -EINVAL;
853 }
854
94b43b67
KM		 855 if (pdata->led_config[chan].name) {
856 led->cdev.name = pdata->led_config[chan].name;
857 } else {
858 snprintf(name, sizeof(name), "%s:channel%d",
859 pdata->label ?: "lp5523", chan);
860 led->cdev.name = name;
861 }
0efba16c 862
0efba16c
SO		 863 led->cdev.brightness_set = lp5523_set_brightness;
864 res = led_classdev_register(dev, &led->cdev);
865 if (res < 0) {
866 dev_err(dev, "couldn't register led on channel %d\n",
867 chan);
868 return res;
869 }
870 res = sysfs_create_group(&led->cdev.dev->kobj,
871 &lp5523_led_attribute_group);
872 if (res < 0) {
873 dev_err(dev, "couldn't register current attribute\n");
874 led_classdev_unregister(&led->cdev);
875 return res;
876 }
877 } else {
878 led->led_current = 0;
879 }
880 return 0;
881}
882
33721bd3 883static int __devinit lp5523_probe(struct i2c_client *client,
0efba16c
SO		 884 const struct i2c_device_id *id)
885{
886 struct lp5523_chip *chip;
887 struct lp5523_platform_data *pdata;
888 int ret, i, led;
889
94ca4bcc 890 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
0efba16c
SO		 891 if (!chip)
892 return -ENOMEM;
893
894 i2c_set_clientdata(client, chip);
895 chip->client = client;
896
897 pdata = client->dev.platform_data;
898
899 if (!pdata) {
900 dev_err(&client->dev, "no platform data\n");
94ca4bcc 901 return -EINVAL;
0efba16c
SO		 902 }
903
904 mutex_init(&chip->lock);
905
906 chip->pdata = pdata;
907
908 if (pdata->setup_resources) {
909 ret = pdata->setup_resources();
910 if (ret < 0)
94ca4bcc 911 return ret;
0efba16c
SO		 912 }
913
914 if (pdata->enable) {
915 pdata->enable(0);
2e4840ed 916 usleep_range(1000, 2000); /* Keep enable down at least 1ms */
0efba16c 917 pdata->enable(1);
2e4840ed 918 usleep_range(1000, 2000); /* 500us abs min. */
0efba16c
SO		 919 }
920
11e7946f
SO		 921 lp5523_write(client, LP5523_REG_RESET, 0xff);
922 usleep_range(10000, 20000); /*
923 * Exact value is not available. 10 - 20ms
924 * appears to be enough for reset.
925 */
0efba16c
SO		 926 ret = lp5523_detect(client);
927 if (ret)
94ca4bcc 928 goto fail1;
0efba16c
SO		 929
930 dev_info(&client->dev, "LP5523 Programmable led chip found\n");
931
932 /* Initialize engines */
933 for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
934 ret = lp5523_init_engine(&chip->engines[i], i + 1);
935 if (ret) {
936 dev_err(&client->dev, "error initializing engine\n");
94ca4bcc 937 goto fail1;
0efba16c
SO		 938 }
939 }
940 ret = lp5523_configure(client);
941 if (ret < 0) {
942 dev_err(&client->dev, "error configuring chip\n");
94ca4bcc 943 goto fail1;
0efba16c
SO		 944 }
945
946 /* Initialize leds */
947 chip->num_channels = pdata->num_channels;
948 chip->num_leds = 0;
949 led = 0;
950 for (i = 0; i < pdata->num_channels; i++) {
951 /* Do not initialize channels that are not connected */
952 if (pdata->led_config[i].led_current == 0)
953 continue;
954
5391dd0a
DC		 955 INIT_WORK(&chip->leds[led].brightness_work,
956 lp5523_led_brightness_work);
957
0efba16c
SO		 958 ret = lp5523_init_led(&chip->leds[led], &client->dev, i, pdata);
959 if (ret) {
960 dev_err(&client->dev, "error initializing leds\n");
94ca4bcc 961 goto fail2;
0efba16c
SO		 962 }
963 chip->num_leds++;
964
965 chip->leds[led].id = led;
966 /* Set LED current */
967 lp5523_write(client,
968 LP5523_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr,
969 chip->leds[led].led_current);
970
0efba16c
SO		 971 led++;
972 }
973
974 ret = lp5523_register_sysfs(client);
975 if (ret) {
976 dev_err(&client->dev, "registering sysfs failed\n");
94ca4bcc 977 goto fail2;
0efba16c
SO		 978 }
979 return ret;
94ca4bcc 980fail2:
0efba16c
SO		 981 for (i = 0; i < chip->num_leds; i++) {
982 led_classdev_unregister(&chip->leds[i].cdev);
a39b9854 983 flush_work(&chip->leds[i].brightness_work);
0efba16c 984 }
94ca4bcc 985fail1:
0efba16c
SO		 986 if (pdata->enable)
987 pdata->enable(0);
988 if (pdata->release_resources)
989 pdata->release_resources();
0efba16c
SO		 990 return ret;
991}
992
993static int lp5523_remove(struct i2c_client *client)
994{
995 struct lp5523_chip *chip = i2c_get_clientdata(client);
996 int i;
997
998 lp5523_unregister_sysfs(client);
999
1000 for (i = 0; i < chip->num_leds; i++) {
1001 led_classdev_unregister(&chip->leds[i].cdev);
a39b9854 1002 flush_work(&chip->leds[i].brightness_work);
0efba16c
SO		 1003 }
1004
1005 if (chip->pdata->enable)
1006 chip->pdata->enable(0);
1007 if (chip->pdata->release_resources)
1008 chip->pdata->release_resources();
0efba16c
SO		 1009 return 0;
1010}
1011
1012static const struct i2c_device_id lp5523_id[] = {
27d7704e
KM		 1013 { "lp5523", LP5523 },
1014 { "lp55231", LP55231 },
0efba16c
SO		 1015 { }
1016};
1017
1018MODULE_DEVICE_TABLE(i2c, lp5523_id);
1019
1020static struct i2c_driver lp5523_driver = {
1021 .driver = {
27d7704e 1022 .name = "lp5523x",
0efba16c
SO		 1023 },
1024 .probe = lp5523_probe,
1025 .remove = lp5523_remove,
1026 .id_table = lp5523_id,
1027};
1028
09a0d183 1029module_i2c_driver(lp5523_driver);
0efba16c
SO		 1030
1031MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
1032MODULE_DESCRIPTION("LP5523 LED engine");
1033MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)