projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
leds-lp55xx: use lp55xx common init function - reset
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / leds / leds-lp5521.c
CommitLineData
500fe141
SO		 1/*
2 * LP5521 LED chip 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-lp5521.h>
35#include <linux/workqueue.h>
36#include <linux/slab.h>
6a0c9a47
MWK		 37#include <linux/platform_data/leds-lp55xx.h>
38
39#include "leds-lp55xx-common.h"
500fe141
SO		 40
41#define LP5521_PROGRAM_LENGTH 32 /* in bytes */
42
43#define LP5521_MAX_LEDS 3 /* Maximum number of LEDs */
44#define LP5521_MAX_ENGINES 3 /* Maximum number of engines */
45
46#define LP5521_ENG_MASK_BASE 0x30 /* 00110000 */
47#define LP5521_ENG_STATUS_MASK 0x07 /* 00000111 */
48
49#define LP5521_CMD_LOAD 0x15 /* 00010101 */
50#define LP5521_CMD_RUN 0x2a /* 00101010 */
51#define LP5521_CMD_DIRECT 0x3f /* 00111111 */
52#define LP5521_CMD_DISABLED 0x00 /* 00000000 */
53
54/* Registers */
55#define LP5521_REG_ENABLE 0x00
56#define LP5521_REG_OP_MODE 0x01
57#define LP5521_REG_R_PWM 0x02
58#define LP5521_REG_G_PWM 0x03
59#define LP5521_REG_B_PWM 0x04
60#define LP5521_REG_R_CURRENT 0x05
61#define LP5521_REG_G_CURRENT 0x06
62#define LP5521_REG_B_CURRENT 0x07
63#define LP5521_REG_CONFIG 0x08
64#define LP5521_REG_R_CHANNEL_PC 0x09
65#define LP5521_REG_G_CHANNEL_PC 0x0A
66#define LP5521_REG_B_CHANNEL_PC 0x0B
67#define LP5521_REG_STATUS 0x0C
68#define LP5521_REG_RESET 0x0D
69#define LP5521_REG_GPO 0x0E
70#define LP5521_REG_R_PROG_MEM 0x10
71#define LP5521_REG_G_PROG_MEM 0x30
72#define LP5521_REG_B_PROG_MEM 0x50
73
74#define LP5521_PROG_MEM_BASE LP5521_REG_R_PROG_MEM
75#define LP5521_PROG_MEM_SIZE 0x20
76
77/* Base register to set LED current */
78#define LP5521_REG_LED_CURRENT_BASE LP5521_REG_R_CURRENT
79
80/* Base register to set the brightness */
81#define LP5521_REG_LED_PWM_BASE LP5521_REG_R_PWM
82
83/* Bits in ENABLE register */
84#define LP5521_MASTER_ENABLE 0x40 /* Chip master enable */
85#define LP5521_LOGARITHMIC_PWM 0x80 /* Logarithmic PWM adjustment */
86#define LP5521_EXEC_RUN 0x2A
32a2f747
KM		 87#define LP5521_ENABLE_DEFAULT \
88 (LP5521_MASTER_ENABLE | LP5521_LOGARITHMIC_PWM)
89#define LP5521_ENABLE_RUN_PROGRAM \
90 (LP5521_ENABLE_DEFAULT | LP5521_EXEC_RUN)
500fe141 91
500fe141
SO		 92/* Status */
93#define LP5521_EXT_CLK_USED 0x08
94
b3c49c05
SK		 95/* default R channel current register value */
96#define LP5521_REG_R_CURR_DEFAULT 0xAF
97
011af7bc
KM		 98/* Pattern Mode */
99#define PATTERN_OFF 0
100
48068d5d
MWK		 101/* Reset register value */
102#define LP5521_RESET 0xFF
103
500fe141 104struct lp5521_engine {
500fe141
SO		 105 int id;
106 u8 mode;
107 u8 prog_page;
108 u8 engine_mask;
109};
110
111struct lp5521_led {
112 int id;
113 u8 chan_nr;
114 u8 led_current;
115 u8 max_current;
116 struct led_classdev cdev;
117 struct work_struct brightness_work;
118 u8 brightness;
119};
120
121struct lp5521_chip {
122 struct lp5521_platform_data *pdata;
123 struct mutex lock; /* Serialize control */
124 struct i2c_client *client;
125 struct lp5521_engine engines[LP5521_MAX_ENGINES];
126 struct lp5521_led leds[LP5521_MAX_LEDS];
127 u8 num_channels;
128 u8 num_leds;
129};
130
94482174
MWK		 131static inline void lp5521_wait_enable_done(void)
132{
133 /* it takes more 488 us to update ENABLE register */
134 usleep_range(500, 600);
135}
136
9fdb18b6
SO		 137static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev)
138{
139 return container_of(cdev, struct lp5521_led, cdev);
140}
141
142static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine)
143{
144 return container_of(engine, struct lp5521_chip,
145 engines[engine->id - 1]);
146}
147
148static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led)
149{
150 return container_of(led, struct lp5521_chip,
151 leds[led->id]);
152}
500fe141
SO		 153
154static void lp5521_led_brightness_work(struct work_struct *work);
155
156static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value)
157{
158 return i2c_smbus_write_byte_data(client, reg, value);
159}
160
161static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf)
162{
163 s32 ret;
164
165 ret = i2c_smbus_read_byte_data(client, reg);
166 if (ret < 0)
313e8b50 167 return ret;
500fe141
SO		 168
169 *buf = ret;
170 return 0;
171}
172
173static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
174{
175 struct lp5521_chip *chip = engine_to_lp5521(engine);
176 struct i2c_client *client = chip->client;
177 int ret;
178 u8 engine_state;
179
180 /* Only transition between RUN and DIRECT mode are handled here */
181 if (mode == LP5521_CMD_LOAD)
182 return 0;
183
184 if (mode == LP5521_CMD_DISABLED)
185 mode = LP5521_CMD_DIRECT;
186
187 ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
fa0ea0e1
AL		 188 if (ret < 0)
189 return ret;
500fe141
SO		 190
191 /* set mode only for this engine */
192 engine_state &= ~(engine->engine_mask);
193 mode &= engine->engine_mask;
194 engine_state |= mode;
fa0ea0e1 195 return lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
500fe141
SO		 196}
197
198static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
199{
200 struct lp5521_chip *chip = engine_to_lp5521(eng);
201 struct i2c_client *client = chip->client;
202 int ret;
203 int addr;
204 u8 mode;
205
206 /* move current engine to direct mode and remember the state */
207 ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT);
5bc9ad77
DC		 208 if (ret)
209 return ret;
210
09c76b0f
SO		 211 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
212 usleep_range(1000, 2000);
5bc9ad77
DC		 213 ret = lp5521_read(client, LP5521_REG_OP_MODE, &mode);
214 if (ret)
215 return ret;
500fe141
SO		 216
217 /* For loading, all the engines to load mode */
218 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
09c76b0f
SO		 219 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
220 usleep_range(1000, 2000);
500fe141 221 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
09c76b0f
SO		 222 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
223 usleep_range(1000, 2000);
500fe141
SO		 224
225 addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE;
226 i2c_smbus_write_i2c_block_data(client,
227 addr,
228 LP5521_PROG_MEM_SIZE,
229 pattern);
230
5bc9ad77 231 return lp5521_write(client, LP5521_REG_OP_MODE, mode);
500fe141
SO		 232}
233
234static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr)
235{
236 return lp5521_write(chip->client,
237 LP5521_REG_LED_CURRENT_BASE + chip->leds[led].chan_nr,
238 curr);
239}
240
d4e7ad03 241static int lp5521_configure(struct i2c_client *client)
500fe141
SO		 242{
243 struct lp5521_chip *chip = i2c_get_clientdata(client);
244 int ret;
3b49aacd 245 u8 cfg;
94482174 246 u8 val;
500fe141 247
94482174
MWK		 248 /*
249 * Make sure that the chip is reset by reading back the r channel
250 * current reg. This is dummy read is required on some platforms -
251 * otherwise further access to the R G B channels in the
252 * LP5521_REG_ENABLE register will not have any effect - strange!
253 */
254 ret = lp5521_read(client, LP5521_REG_R_CURRENT, &val);
255 if (ret) {
256 dev_err(&client->dev, "error in resetting chip\n");
257 return ret;
258 }
259 if (val != LP5521_REG_R_CURR_DEFAULT) {
260 dev_err(&client->dev,
261 "unexpected data in register (expected 0x%x got 0x%x)\n",
262 LP5521_REG_R_CURR_DEFAULT, val);
263 ret = -EINVAL;
264 return ret;
265 }
266 usleep_range(10000, 20000);
500fe141 267
500fe141 268 /* Set all PWMs to direct control mode */
32a2f747 269 ret = lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
500fe141 270
3b49aacd
KM		 271 cfg = chip->pdata->update_config ?
272 : (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
94482174
MWK		 273 ret = lp5521_write(client, LP5521_REG_CONFIG, cfg);
274 if (ret)
275 return ret;
500fe141
SO		 276
277 /* Initialize all channels PWM to zero -> leds off */
94482174
MWK		 278 lp5521_write(client, LP5521_REG_R_PWM, 0);
279 lp5521_write(client, LP5521_REG_G_PWM, 0);
280 lp5521_write(client, LP5521_REG_B_PWM, 0);
500fe141
SO		 281
282 /* Set engines are set to run state when OP_MODE enables engines */
94482174 283 ret = lp5521_write(client, LP5521_REG_ENABLE,
32a2f747 284 LP5521_ENABLE_RUN_PROGRAM);
94482174
MWK		 285 if (ret)
286 return ret;
500fe141 287
94482174
MWK		 288 lp5521_wait_enable_done();
289
290 return 0;
500fe141
SO		 291}
292
293static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf)
294{
295 int ret;
296 u8 status;
297
298 ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status);
299 if (ret < 0)
300 return ret;
301
302 /* Check that ext clock is really in use if requested */
303 if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT)
304 if ((status & LP5521_EXT_CLK_USED) == 0)
305 return -EIO;
306 return 0;
307}
308
309static void lp5521_set_brightness(struct led_classdev *cdev,
310 enum led_brightness brightness)
311{
312 struct lp5521_led *led = cdev_to_led(cdev);
313 led->brightness = (u8)brightness;
314 schedule_work(&led->brightness_work);
315}
316
317static void lp5521_led_brightness_work(struct work_struct *work)
318{
319 struct lp5521_led *led = container_of(work,
320 struct lp5521_led,
321 brightness_work);
322 struct lp5521_chip *chip = led_to_lp5521(led);
323 struct i2c_client *client = chip->client;
324
325 mutex_lock(&chip->lock);
326 lp5521_write(client, LP5521_REG_LED_PWM_BASE + led->chan_nr,
327 led->brightness);
328 mutex_unlock(&chip->lock);
329}
330
331/* Detect the chip by setting its ENABLE register and reading it back. */
332static int lp5521_detect(struct i2c_client *client)
333{
334 int ret;
335 u8 buf;
336
32a2f747 337 ret = lp5521_write(client, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
500fe141
SO		 338 if (ret)
339 return ret;
09c76b0f
SO		 340 /* enable takes 500us. 1 - 2 ms leaves some margin */
341 usleep_range(1000, 2000);
500fe141
SO		 342 ret = lp5521_read(client, LP5521_REG_ENABLE, &buf);
343 if (ret)
344 return ret;
32a2f747 345 if (buf != LP5521_ENABLE_DEFAULT)
500fe141
SO		 346 return -ENODEV;
347
348 return 0;
349}
350
351/* Set engine mode and create appropriate sysfs attributes, if required. */
352static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
353{
500fe141
SO		 354 int ret = 0;
355
356 /* if in that mode already do nothing, except for run */
357 if (mode == engine->mode && mode != LP5521_CMD_RUN)
358 return 0;
359
360 if (mode == LP5521_CMD_RUN) {
361 ret = lp5521_set_engine_mode(engine, LP5521_CMD_RUN);
362 } else if (mode == LP5521_CMD_LOAD) {
363 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
364 lp5521_set_engine_mode(engine, LP5521_CMD_LOAD);
500fe141
SO		 365 } else if (mode == LP5521_CMD_DISABLED) {
366 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
367 }
368
500fe141
SO		 369 engine->mode = mode;
370
371 return ret;
372}
373
374static int lp5521_do_store_load(struct lp5521_engine *engine,
375 const char *buf, size_t len)
376{
377 struct lp5521_chip *chip = engine_to_lp5521(engine);
378 struct i2c_client *client = chip->client;
379 int ret, nrchars, offset = 0, i = 0;
380 char c[3];
381 unsigned cmd;
382 u8 pattern[LP5521_PROGRAM_LENGTH] = {0};
383
384 while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) {
385 /* separate sscanfs because length is working only for %s */
386 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
2260209c
VK		 387 if (ret != 2)
388 goto fail;
500fe141
SO		 389 ret = sscanf(c, "%2x", &cmd);
390 if (ret != 1)
391 goto fail;
392 pattern[i] = (u8)cmd;
393
394 offset += nrchars;
395 i++;
396 }
397
398 /* Each instruction is 16bit long. Check that length is even */
399 if (i % 2)
400 goto fail;
401
402 mutex_lock(&chip->lock);
d4e7ad03
SO		 403 if (engine->mode == LP5521_CMD_LOAD)
404 ret = lp5521_load_program(engine, pattern);
405 else
406 ret = -EINVAL;
500fe141
SO		 407 mutex_unlock(&chip->lock);
408
409 if (ret) {
410 dev_err(&client->dev, "failed loading pattern\n");
411 return ret;
412 }
413
414 return len;
415fail:
416 dev_err(&client->dev, "wrong pattern format\n");
417 return -EINVAL;
418}
419
420static ssize_t store_engine_load(struct device *dev,
421 struct device_attribute *attr,
422 const char *buf, size_t len, int nr)
423{
424 struct i2c_client *client = to_i2c_client(dev);
425 struct lp5521_chip *chip = i2c_get_clientdata(client);
426 return lp5521_do_store_load(&chip->engines[nr - 1], buf, len);
427}
428
429#define store_load(nr) \
430static ssize_t store_engine##nr##_load(struct device *dev, \
431 struct device_attribute *attr, \
432 const char *buf, size_t len) \
433{ \
434 return store_engine_load(dev, attr, buf, len, nr); \
435}
436store_load(1)
437store_load(2)
438store_load(3)
439
440static ssize_t show_engine_mode(struct device *dev,
441 struct device_attribute *attr,
442 char *buf, int nr)
443{
444 struct i2c_client *client = to_i2c_client(dev);
445 struct lp5521_chip *chip = i2c_get_clientdata(client);
446 switch (chip->engines[nr - 1].mode) {
447 case LP5521_CMD_RUN:
448 return sprintf(buf, "run\n");
449 case LP5521_CMD_LOAD:
450 return sprintf(buf, "load\n");
451 case LP5521_CMD_DISABLED:
452 return sprintf(buf, "disabled\n");
453 default:
454 return sprintf(buf, "disabled\n");
455 }
456}
457
458#define show_mode(nr) \
459static ssize_t show_engine##nr##_mode(struct device *dev, \
460 struct device_attribute *attr, \
461 char *buf) \
462{ \
463 return show_engine_mode(dev, attr, buf, nr); \
464}
465show_mode(1)
466show_mode(2)
467show_mode(3)
468
469static ssize_t store_engine_mode(struct device *dev,
470 struct device_attribute *attr,
471 const char *buf, size_t len, int nr)
472{
473 struct i2c_client *client = to_i2c_client(dev);
474 struct lp5521_chip *chip = i2c_get_clientdata(client);
475 struct lp5521_engine *engine = &chip->engines[nr - 1];
476 mutex_lock(&chip->lock);
477
478 if (!strncmp(buf, "run", 3))
479 lp5521_set_mode(engine, LP5521_CMD_RUN);
480 else if (!strncmp(buf, "load", 4))
481 lp5521_set_mode(engine, LP5521_CMD_LOAD);
482 else if (!strncmp(buf, "disabled", 8))
483 lp5521_set_mode(engine, LP5521_CMD_DISABLED);
484
485 mutex_unlock(&chip->lock);
486 return len;
487}
488
489#define store_mode(nr) \
490static ssize_t store_engine##nr##_mode(struct device *dev, \
491 struct device_attribute *attr, \
492 const char *buf, size_t len) \
493{ \
494 return store_engine_mode(dev, attr, buf, len, nr); \
495}
496store_mode(1)
497store_mode(2)
498store_mode(3)
499
500static ssize_t show_max_current(struct device *dev,
501 struct device_attribute *attr,
502 char *buf)
503{
504 struct led_classdev *led_cdev = dev_get_drvdata(dev);
505 struct lp5521_led *led = cdev_to_led(led_cdev);
506
507 return sprintf(buf, "%d\n", led->max_current);
508}
509
510static ssize_t show_current(struct device *dev,
511 struct device_attribute *attr,
512 char *buf)
513{
514 struct led_classdev *led_cdev = dev_get_drvdata(dev);
515 struct lp5521_led *led = cdev_to_led(led_cdev);
516
517 return sprintf(buf, "%d\n", led->led_current);
518}
519
520static ssize_t store_current(struct device *dev,
521 struct device_attribute *attr,
522 const char *buf, size_t len)
523{
524 struct led_classdev *led_cdev = dev_get_drvdata(dev);
525 struct lp5521_led *led = cdev_to_led(led_cdev);
526 struct lp5521_chip *chip = led_to_lp5521(led);
527 ssize_t ret;
528 unsigned long curr;
529
011af7bc 530 if (kstrtoul(buf, 0, &curr))
500fe141
SO		 531 return -EINVAL;
532
533 if (curr > led->max_current)
534 return -EINVAL;
535
536 mutex_lock(&chip->lock);
537 ret = lp5521_set_led_current(chip, led->id, curr);
538 mutex_unlock(&chip->lock);
539
540 if (ret < 0)
541 return ret;
542
543 led->led_current = (u8)curr;
544
545 return len;
546}
547
548static ssize_t lp5521_selftest(struct device *dev,
549 struct device_attribute *attr,
550 char *buf)
551{
552 struct i2c_client *client = to_i2c_client(dev);
553 struct lp5521_chip *chip = i2c_get_clientdata(client);
554 int ret;
555
556 mutex_lock(&chip->lock);
557 ret = lp5521_run_selftest(chip, buf);
558 mutex_unlock(&chip->lock);
559 return sprintf(buf, "%s\n", ret ? "FAIL" : "OK");
560}
561
011af7bc
KM		 562static void lp5521_clear_program_memory(struct i2c_client *cl)
563{
564 int i;
565 u8 rgb_mem[] = {
566 LP5521_REG_R_PROG_MEM,
567 LP5521_REG_G_PROG_MEM,
568 LP5521_REG_B_PROG_MEM,
569 };
570
571 for (i = 0; i < ARRAY_SIZE(rgb_mem); i++) {
572 lp5521_write(cl, rgb_mem[i], 0);
573 lp5521_write(cl, rgb_mem[i] + 1, 0);
574 }
575}
576
577static void lp5521_write_program_memory(struct i2c_client *cl,
578 u8 base, u8 *rgb, int size)
579{
580 int i;
581
582 if (!rgb || size <= 0)
583 return;
584
585 for (i = 0; i < size; i++)
586 lp5521_write(cl, base + i, *(rgb + i));
587
588 lp5521_write(cl, base + i, 0);
589 lp5521_write(cl, base + i + 1, 0);
590}
591
592static inline struct lp5521_led_pattern *lp5521_get_pattern
593 (struct lp5521_chip *chip, u8 offset)
594{
595 struct lp5521_led_pattern *ptn;
596 ptn = chip->pdata->patterns + (offset - 1);
597 return ptn;
598}
599
600static void lp5521_run_led_pattern(int mode, struct lp5521_chip *chip)
601{
602 struct lp5521_led_pattern *ptn;
603 struct i2c_client *cl = chip->client;
604 int num_patterns = chip->pdata->num_patterns;
605
606 if (mode > num_patterns || !(chip->pdata->patterns))
607 return;
608
609 if (mode == PATTERN_OFF) {
32a2f747 610 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
011af7bc
KM		 611 usleep_range(1000, 2000);
612 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
613 } else {
614 ptn = lp5521_get_pattern(chip, mode);
615 if (!ptn)
616 return;
617
618 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
619 usleep_range(1000, 2000);
620
621 lp5521_clear_program_memory(cl);
622
623 lp5521_write_program_memory(cl, LP5521_REG_R_PROG_MEM,
624 ptn->r, ptn->size_r);
625 lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
626 ptn->g, ptn->size_g);
627 lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
628 ptn->b, ptn->size_b);
629
630 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_RUN);
631 usleep_range(1000, 2000);
32a2f747 632 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
011af7bc
KM		 633 }
634}
635
636static ssize_t store_led_pattern(struct device *dev,
637 struct device_attribute *attr,
638 const char *buf, size_t len)
639{
640 struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
641 unsigned long val;
642 int ret;
643
69b44c16 644 ret = kstrtoul(buf, 16, &val);
011af7bc
KM		 645 if (ret)
646 return ret;
647
648 lp5521_run_led_pattern(val, chip);
649
650 return len;
651}
652
500fe141 653/* led class device attributes */
67d1da79 654static DEVICE_ATTR(led_current, S_IRUGO | S_IWUSR, show_current, store_current);
500fe141
SO		 655static DEVICE_ATTR(max_current, S_IRUGO , show_max_current, NULL);
656
657static struct attribute *lp5521_led_attributes[] = {
658 &dev_attr_led_current.attr,
659 &dev_attr_max_current.attr,
660 NULL,
661};
662
663static struct attribute_group lp5521_led_attribute_group = {
664 .attrs = lp5521_led_attributes
665};
666
667/* device attributes */
67d1da79 668static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR,
500fe141 669 show_engine1_mode, store_engine1_mode);
67d1da79 670static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR,
500fe141 671 show_engine2_mode, store_engine2_mode);
67d1da79 672static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR,
500fe141 673 show_engine3_mode, store_engine3_mode);
67d1da79
VK		 674static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
675static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
676static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
500fe141 677static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL);
011af7bc 678static DEVICE_ATTR(led_pattern, S_IWUSR, NULL, store_led_pattern);
500fe141
SO		 679
680static struct attribute *lp5521_attributes[] = {
681 &dev_attr_engine1_mode.attr,
682 &dev_attr_engine2_mode.attr,
683 &dev_attr_engine3_mode.attr,
684 &dev_attr_selftest.attr,
500fe141 685 &dev_attr_engine1_load.attr,
500fe141 686 &dev_attr_engine2_load.attr,
500fe141 687 &dev_attr_engine3_load.attr,
011af7bc 688 &dev_attr_led_pattern.attr,
500fe141
SO		 689 NULL
690};
691
692static const struct attribute_group lp5521_group = {
693 .attrs = lp5521_attributes,
694};
695
500fe141
SO		 696static int lp5521_register_sysfs(struct i2c_client *client)
697{
698 struct device *dev = &client->dev;
699 return sysfs_create_group(&dev->kobj, &lp5521_group);
700}
701
702static void lp5521_unregister_sysfs(struct i2c_client *client)
703{
704 struct lp5521_chip *chip = i2c_get_clientdata(client);
705 struct device *dev = &client->dev;
706 int i;
707
708 sysfs_remove_group(&dev->kobj, &lp5521_group);
709
500fe141
SO		 710 for (i = 0; i < chip->num_leds; i++)
711 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
712 &lp5521_led_attribute_group);
713}
714
f6c64c6f 715static void lp5521_deinit_device(struct lp5521_chip *chip);
944f7b1d
MWK		 716static int lp5521_init_device(struct lp5521_chip *chip)
717{
944f7b1d
MWK		 718 struct i2c_client *client = chip->client;
719 int ret;
944f7b1d 720
944f7b1d 721 ret = lp5521_detect(client);
f6c64c6f 722 if (ret) {
944f7b1d 723 dev_err(&client->dev, "Chip not found\n");
f6c64c6f
MWK		 724 goto err;
725 }
726
727 ret = lp5521_configure(client);
728 if (ret < 0) {
729 dev_err(&client->dev, "error configuring chip\n");
730 goto err_config;
731 }
944f7b1d 732
f6c64c6f
MWK		 733 return 0;
734
735err_config:
736 lp5521_deinit_device(chip);
737err:
944f7b1d
MWK		 738 return ret;
739}
740
1a991485
MWK		 741static void lp5521_deinit_device(struct lp5521_chip *chip)
742{
743 struct lp5521_platform_data *pdata = chip->pdata;
744
745 if (pdata->enable)
746 pdata->enable(0);
747 if (pdata->release_resources)
748 pdata->release_resources();
749}
750
98ea1ea2 751static int lp5521_init_led(struct lp5521_led *led,
500fe141
SO		 752 struct i2c_client *client,
753 int chan, struct lp5521_platform_data *pdata)
754{
755 struct device *dev = &client->dev;
756 char name[32];
757 int res;
758
759 if (chan >= LP5521_MAX_LEDS)
760 return -EINVAL;
761
762 if (pdata->led_config[chan].led_current == 0)
763 return 0;
764
765 led->led_current = pdata->led_config[chan].led_current;
766 led->max_current = pdata->led_config[chan].max_current;
767 led->chan_nr = pdata->led_config[chan].chan_nr;
768
769 if (led->chan_nr >= LP5521_MAX_LEDS) {
770 dev_err(dev, "Use channel numbers between 0 and %d\n",
771 LP5521_MAX_LEDS - 1);
772 return -EINVAL;
773 }
774
500fe141 775 led->cdev.brightness_set = lp5521_set_brightness;
5ae4e8a7
KM		 776 if (pdata->led_config[chan].name) {
777 led->cdev.name = pdata->led_config[chan].name;
778 } else {
779 snprintf(name, sizeof(name), "%s:channel%d",
780 pdata->label ?: client->name, chan);
781 led->cdev.name = name;
782 }
783
500fe141
SO		 784 res = led_classdev_register(dev, &led->cdev);
785 if (res < 0) {
786 dev_err(dev, "couldn't register led on channel %d\n", chan);
787 return res;
788 }
789
790 res = sysfs_create_group(&led->cdev.dev->kobj,
791 &lp5521_led_attribute_group);
792 if (res < 0) {
793 dev_err(dev, "couldn't register current attribute\n");
794 led_classdev_unregister(&led->cdev);
795 return res;
796 }
797 return 0;
798}
799
f6524808
MWK		 800static int lp5521_register_leds(struct lp5521_chip *chip)
801{
802 struct lp5521_platform_data *pdata = chip->pdata;
803 struct i2c_client *client = chip->client;
804 int i;
805 int led;
806 int ret;
807
808 /* Initialize leds */
809 chip->num_channels = pdata->num_channels;
810 chip->num_leds = 0;
811 led = 0;
812 for (i = 0; i < pdata->num_channels; i++) {
813 /* Do not initialize channels that are not connected */
814 if (pdata->led_config[i].led_current == 0)
815 continue;
816
817 ret = lp5521_init_led(&chip->leds[led], client, i, pdata);
818 if (ret) {
819 dev_err(&client->dev, "error initializing leds\n");
820 return ret;
821 }
822 chip->num_leds++;
823
824 chip->leds[led].id = led;
825 /* Set initial LED current */
826 lp5521_set_led_current(chip, led,
827 chip->leds[led].led_current);
828
829 INIT_WORK(&(chip->leds[led].brightness_work),
830 lp5521_led_brightness_work);
831
832 led++;
833 }
834
835 return 0;
836}
837
1904f83d
MWK		 838static void lp5521_unregister_leds(struct lp5521_chip *chip)
839{
840 int i;
841
842 for (i = 0; i < chip->num_leds; i++) {
843 led_classdev_unregister(&chip->leds[i].cdev);
844 cancel_work_sync(&chip->leds[i].brightness_work);
845 }
846}
847
48068d5d
MWK		 848/* Chip specific configurations */
849static struct lp55xx_device_config lp5521_cfg = {
850 .reset = {
851 .addr = LP5521_REG_RESET,
852 .val = LP5521_RESET,
853 },
854};
855
98ea1ea2 856static int lp5521_probe(struct i2c_client *client,
500fe141
SO		 857 const struct i2c_device_id *id)
858{
6a0c9a47 859 struct lp5521_chip *old_chip = NULL;
1904f83d 860 int ret;
6a0c9a47
MWK		 861 struct lp55xx_chip *chip;
862 struct lp55xx_led *led;
863 struct lp55xx_platform_data *pdata = client->dev.platform_data;
500fe141 864
6a0c9a47 865 if (!pdata) {
500fe141 866 dev_err(&client->dev, "no platform data\n");
e430dc00 867 return -EINVAL;
500fe141
SO		 868 }
869
6a0c9a47
MWK		 870 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
871 if (!chip)
872 return -ENOMEM;
873
874 led = devm_kzalloc(&client->dev,
875 sizeof(*led) * pdata->num_channels, GFP_KERNEL);
876 if (!led)
877 return -ENOMEM;
878
879 chip->cl = client;
880 chip->pdata = pdata;
48068d5d 881 chip->cfg = &lp5521_cfg;
6a0c9a47
MWK		 882
883 mutex_init(&chip->lock);
500fe141 884
6a0c9a47 885 i2c_set_clientdata(client, led);
500fe141 886
945c7007 887 ret = lp5521_init_device(old_chip);
944f7b1d 888 if (ret)
f6c64c6f 889 goto err_init;
500fe141
SO		 890
891 dev_info(&client->dev, "%s programmable led chip found\n", id->name);
892
945c7007 893 ret = lp5521_register_leds(old_chip);
f6524808
MWK		 894 if (ret)
895 goto fail2;
500fe141
SO		 896
897 ret = lp5521_register_sysfs(client);
898 if (ret) {
899 dev_err(&client->dev, "registering sysfs failed\n");
e430dc00 900 goto fail2;
500fe141
SO		 901 }
902 return ret;
e430dc00 903fail2:
945c7007
MWK		 904 lp5521_unregister_leds(old_chip);
905 lp5521_deinit_device(old_chip);
f6c64c6f 906err_init:
500fe141
SO		 907 return ret;
908}
909
678e8a6b 910static int lp5521_remove(struct i2c_client *client)
500fe141 911{
945c7007 912 struct lp5521_chip *old_chip = i2c_get_clientdata(client);
500fe141 913
945c7007 914 lp5521_run_led_pattern(PATTERN_OFF, old_chip);
500fe141
SO		 915 lp5521_unregister_sysfs(client);
916
945c7007 917 lp5521_unregister_leds(old_chip);
500fe141 918
945c7007 919 lp5521_deinit_device(old_chip);
500fe141
SO		 920 return 0;
921}
922
923static const struct i2c_device_id lp5521_id[] = {
924 { "lp5521", 0 }, /* Three channel chip */
925 { }
926};
927MODULE_DEVICE_TABLE(i2c, lp5521_id);
928
929static struct i2c_driver lp5521_driver = {
930 .driver = {
931 .name = "lp5521",
932 },
933 .probe = lp5521_probe,
df07cf81 934 .remove = lp5521_remove,
500fe141
SO		 935 .id_table = lp5521_id,
936};
937
09a0d183 938module_i2c_driver(lp5521_driver);
500fe141
SO		 939
940MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
941MODULE_DESCRIPTION("LP5521 LED engine");
942MODULE_LICENSE("GPL v2");
kernel source for telekom puls (alcatel/mediatek)