projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
leds-lp55xx: provide common LED current setting
[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
a96bfa13
MWK		 137static void lp5521_set_led_current(struct lp55xx_led *led, u8 led_current)
138{
139 led->led_current = led_current;
140 lp55xx_write(led->chip, LP5521_REG_LED_CURRENT_BASE + led->chan_nr,
141 led_current);
142}
143
9fdb18b6
SO		 144static inline struct lp5521_led *cdev_to_led(struct led_classdev *cdev)
145{
146 return container_of(cdev, struct lp5521_led, cdev);
147}
148
149static inline struct lp5521_chip *engine_to_lp5521(struct lp5521_engine *engine)
150{
151 return container_of(engine, struct lp5521_chip,
152 engines[engine->id - 1]);
153}
154
155static inline struct lp5521_chip *led_to_lp5521(struct lp5521_led *led)
156{
157 return container_of(led, struct lp5521_chip,
158 leds[led->id]);
159}
500fe141 160
500fe141
SO		 161static inline int lp5521_write(struct i2c_client *client, u8 reg, u8 value)
162{
163 return i2c_smbus_write_byte_data(client, reg, value);
164}
165
166static int lp5521_read(struct i2c_client *client, u8 reg, u8 *buf)
167{
168 s32 ret;
169
170 ret = i2c_smbus_read_byte_data(client, reg);
171 if (ret < 0)
313e8b50 172 return ret;
500fe141
SO		 173
174 *buf = ret;
175 return 0;
176}
177
178static int lp5521_set_engine_mode(struct lp5521_engine *engine, u8 mode)
179{
180 struct lp5521_chip *chip = engine_to_lp5521(engine);
181 struct i2c_client *client = chip->client;
182 int ret;
183 u8 engine_state;
184
185 /* Only transition between RUN and DIRECT mode are handled here */
186 if (mode == LP5521_CMD_LOAD)
187 return 0;
188
189 if (mode == LP5521_CMD_DISABLED)
190 mode = LP5521_CMD_DIRECT;
191
192 ret = lp5521_read(client, LP5521_REG_OP_MODE, &engine_state);
fa0ea0e1
AL		 193 if (ret < 0)
194 return ret;
500fe141
SO		 195
196 /* set mode only for this engine */
197 engine_state &= ~(engine->engine_mask);
198 mode &= engine->engine_mask;
199 engine_state |= mode;
fa0ea0e1 200 return lp5521_write(client, LP5521_REG_OP_MODE, engine_state);
500fe141
SO		 201}
202
203static int lp5521_load_program(struct lp5521_engine *eng, const u8 *pattern)
204{
205 struct lp5521_chip *chip = engine_to_lp5521(eng);
206 struct i2c_client *client = chip->client;
207 int ret;
208 int addr;
209 u8 mode;
210
211 /* move current engine to direct mode and remember the state */
212 ret = lp5521_set_engine_mode(eng, LP5521_CMD_DIRECT);
5bc9ad77
DC		 213 if (ret)
214 return ret;
215
09c76b0f
SO		 216 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
217 usleep_range(1000, 2000);
5bc9ad77
DC		 218 ret = lp5521_read(client, LP5521_REG_OP_MODE, &mode);
219 if (ret)
220 return ret;
500fe141
SO		 221
222 /* For loading, all the engines to load mode */
223 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
09c76b0f
SO		 224 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
225 usleep_range(1000, 2000);
500fe141 226 lp5521_write(client, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
09c76b0f
SO		 227 /* Mode change requires min 500 us delay. 1 - 2 ms with margin */
228 usleep_range(1000, 2000);
500fe141
SO		 229
230 addr = LP5521_PROG_MEM_BASE + eng->prog_page * LP5521_PROG_MEM_SIZE;
231 i2c_smbus_write_i2c_block_data(client,
232 addr,
233 LP5521_PROG_MEM_SIZE,
234 pattern);
235
5bc9ad77 236 return lp5521_write(client, LP5521_REG_OP_MODE, mode);
500fe141
SO		 237}
238
ffbdccdb 239static int lp5521_post_init_device(struct lp55xx_chip *chip)
500fe141 240{
500fe141 241 int ret;
94482174 242 u8 val;
500fe141 243
94482174
MWK		 244 /*
245 * Make sure that the chip is reset by reading back the r channel
246 * current reg. This is dummy read is required on some platforms -
247 * otherwise further access to the R G B channels in the
248 * LP5521_REG_ENABLE register will not have any effect - strange!
249 */
ffbdccdb 250 ret = lp55xx_read(chip, LP5521_REG_R_CURRENT, &val);
94482174 251 if (ret) {
ffbdccdb 252 dev_err(&chip->cl->dev, "error in resetting chip\n");
94482174
MWK		 253 return ret;
254 }
255 if (val != LP5521_REG_R_CURR_DEFAULT) {
ffbdccdb 256 dev_err(&chip->cl->dev,
94482174
MWK		 257 "unexpected data in register (expected 0x%x got 0x%x)\n",
258 LP5521_REG_R_CURR_DEFAULT, val);
259 ret = -EINVAL;
260 return ret;
261 }
262 usleep_range(10000, 20000);
500fe141 263
500fe141 264 /* Set all PWMs to direct control mode */
ffbdccdb 265 ret = lp55xx_write(chip, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
500fe141 266
ffbdccdb 267 val = chip->pdata->update_config ?
3b49aacd 268 : (LP5521_PWRSAVE_EN | LP5521_CP_MODE_AUTO | LP5521_R_TO_BATT);
ffbdccdb 269 ret = lp55xx_write(chip, LP5521_REG_CONFIG, val);
94482174
MWK		 270 if (ret)
271 return ret;
500fe141
SO		 272
273 /* Initialize all channels PWM to zero -> leds off */
ffbdccdb
MWK		 274 lp55xx_write(chip, LP5521_REG_R_PWM, 0);
275 lp55xx_write(chip, LP5521_REG_G_PWM, 0);
276 lp55xx_write(chip, LP5521_REG_B_PWM, 0);
500fe141
SO		 277
278 /* Set engines are set to run state when OP_MODE enables engines */
ffbdccdb 279 ret = lp55xx_write(chip, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
94482174
MWK		 280 if (ret)
281 return ret;
500fe141 282
94482174
MWK		 283 lp5521_wait_enable_done();
284
285 return 0;
500fe141
SO		 286}
287
288static int lp5521_run_selftest(struct lp5521_chip *chip, char *buf)
289{
290 int ret;
291 u8 status;
292
293 ret = lp5521_read(chip->client, LP5521_REG_STATUS, &status);
294 if (ret < 0)
295 return ret;
296
297 /* Check that ext clock is really in use if requested */
298 if (chip->pdata && chip->pdata->clock_mode == LP5521_CLOCK_EXT)
299 if ((status & LP5521_EXT_CLK_USED) == 0)
300 return -EIO;
301 return 0;
302}
303
500fe141
SO		 304static void lp5521_led_brightness_work(struct work_struct *work)
305{
a6e4679a 306 struct lp55xx_led *led = container_of(work, struct lp55xx_led,
500fe141 307 brightness_work);
a6e4679a 308 struct lp55xx_chip *chip = led->chip;
500fe141
SO		 309
310 mutex_lock(&chip->lock);
a6e4679a 311 lp55xx_write(chip, LP5521_REG_LED_PWM_BASE + led->chan_nr,
500fe141
SO		 312 led->brightness);
313 mutex_unlock(&chip->lock);
314}
315
500fe141
SO		 316/* Set engine mode and create appropriate sysfs attributes, if required. */
317static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
318{
500fe141
SO		 319 int ret = 0;
320
321 /* if in that mode already do nothing, except for run */
322 if (mode == engine->mode && mode != LP5521_CMD_RUN)
323 return 0;
324
325 if (mode == LP5521_CMD_RUN) {
326 ret = lp5521_set_engine_mode(engine, LP5521_CMD_RUN);
327 } else if (mode == LP5521_CMD_LOAD) {
328 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
329 lp5521_set_engine_mode(engine, LP5521_CMD_LOAD);
500fe141
SO		 330 } else if (mode == LP5521_CMD_DISABLED) {
331 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
332 }
333
500fe141
SO		 334 engine->mode = mode;
335
336 return ret;
337}
338
339static int lp5521_do_store_load(struct lp5521_engine *engine,
340 const char *buf, size_t len)
341{
342 struct lp5521_chip *chip = engine_to_lp5521(engine);
343 struct i2c_client *client = chip->client;
344 int ret, nrchars, offset = 0, i = 0;
345 char c[3];
346 unsigned cmd;
347 u8 pattern[LP5521_PROGRAM_LENGTH] = {0};
348
349 while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) {
350 /* separate sscanfs because length is working only for %s */
351 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
2260209c
VK		 352 if (ret != 2)
353 goto fail;
500fe141
SO		 354 ret = sscanf(c, "%2x", &cmd);
355 if (ret != 1)
356 goto fail;
357 pattern[i] = (u8)cmd;
358
359 offset += nrchars;
360 i++;
361 }
362
363 /* Each instruction is 16bit long. Check that length is even */
364 if (i % 2)
365 goto fail;
366
367 mutex_lock(&chip->lock);
d4e7ad03
SO		 368 if (engine->mode == LP5521_CMD_LOAD)
369 ret = lp5521_load_program(engine, pattern);
370 else
371 ret = -EINVAL;
500fe141
SO		 372 mutex_unlock(&chip->lock);
373
374 if (ret) {
375 dev_err(&client->dev, "failed loading pattern\n");
376 return ret;
377 }
378
379 return len;
380fail:
381 dev_err(&client->dev, "wrong pattern format\n");
382 return -EINVAL;
383}
384
385static ssize_t store_engine_load(struct device *dev,
386 struct device_attribute *attr,
387 const char *buf, size_t len, int nr)
388{
389 struct i2c_client *client = to_i2c_client(dev);
390 struct lp5521_chip *chip = i2c_get_clientdata(client);
391 return lp5521_do_store_load(&chip->engines[nr - 1], buf, len);
392}
393
394#define store_load(nr) \
395static ssize_t store_engine##nr##_load(struct device *dev, \
396 struct device_attribute *attr, \
397 const char *buf, size_t len) \
398{ \
399 return store_engine_load(dev, attr, buf, len, nr); \
400}
401store_load(1)
402store_load(2)
403store_load(3)
404
405static ssize_t show_engine_mode(struct device *dev,
406 struct device_attribute *attr,
407 char *buf, int nr)
408{
409 struct i2c_client *client = to_i2c_client(dev);
410 struct lp5521_chip *chip = i2c_get_clientdata(client);
411 switch (chip->engines[nr - 1].mode) {
412 case LP5521_CMD_RUN:
413 return sprintf(buf, "run\n");
414 case LP5521_CMD_LOAD:
415 return sprintf(buf, "load\n");
416 case LP5521_CMD_DISABLED:
417 return sprintf(buf, "disabled\n");
418 default:
419 return sprintf(buf, "disabled\n");
420 }
421}
422
423#define show_mode(nr) \
424static ssize_t show_engine##nr##_mode(struct device *dev, \
425 struct device_attribute *attr, \
426 char *buf) \
427{ \
428 return show_engine_mode(dev, attr, buf, nr); \
429}
430show_mode(1)
431show_mode(2)
432show_mode(3)
433
434static ssize_t store_engine_mode(struct device *dev,
435 struct device_attribute *attr,
436 const char *buf, size_t len, int nr)
437{
438 struct i2c_client *client = to_i2c_client(dev);
439 struct lp5521_chip *chip = i2c_get_clientdata(client);
440 struct lp5521_engine *engine = &chip->engines[nr - 1];
441 mutex_lock(&chip->lock);
442
443 if (!strncmp(buf, "run", 3))
444 lp5521_set_mode(engine, LP5521_CMD_RUN);
445 else if (!strncmp(buf, "load", 4))
446 lp5521_set_mode(engine, LP5521_CMD_LOAD);
447 else if (!strncmp(buf, "disabled", 8))
448 lp5521_set_mode(engine, LP5521_CMD_DISABLED);
449
450 mutex_unlock(&chip->lock);
451 return len;
452}
453
454#define store_mode(nr) \
455static ssize_t store_engine##nr##_mode(struct device *dev, \
456 struct device_attribute *attr, \
457 const char *buf, size_t len) \
458{ \
459 return store_engine_mode(dev, attr, buf, len, nr); \
460}
461store_mode(1)
462store_mode(2)
463store_mode(3)
464
500fe141
SO		 465static ssize_t lp5521_selftest(struct device *dev,
466 struct device_attribute *attr,
467 char *buf)
468{
469 struct i2c_client *client = to_i2c_client(dev);
470 struct lp5521_chip *chip = i2c_get_clientdata(client);
471 int ret;
472
473 mutex_lock(&chip->lock);
474 ret = lp5521_run_selftest(chip, buf);
475 mutex_unlock(&chip->lock);
476 return sprintf(buf, "%s\n", ret ? "FAIL" : "OK");
477}
478
011af7bc
KM		 479static void lp5521_clear_program_memory(struct i2c_client *cl)
480{
481 int i;
482 u8 rgb_mem[] = {
483 LP5521_REG_R_PROG_MEM,
484 LP5521_REG_G_PROG_MEM,
485 LP5521_REG_B_PROG_MEM,
486 };
487
488 for (i = 0; i < ARRAY_SIZE(rgb_mem); i++) {
489 lp5521_write(cl, rgb_mem[i], 0);
490 lp5521_write(cl, rgb_mem[i] + 1, 0);
491 }
492}
493
494static void lp5521_write_program_memory(struct i2c_client *cl,
495 u8 base, u8 *rgb, int size)
496{
497 int i;
498
499 if (!rgb || size <= 0)
500 return;
501
502 for (i = 0; i < size; i++)
503 lp5521_write(cl, base + i, *(rgb + i));
504
505 lp5521_write(cl, base + i, 0);
506 lp5521_write(cl, base + i + 1, 0);
507}
508
509static inline struct lp5521_led_pattern *lp5521_get_pattern
510 (struct lp5521_chip *chip, u8 offset)
511{
512 struct lp5521_led_pattern *ptn;
513 ptn = chip->pdata->patterns + (offset - 1);
514 return ptn;
515}
516
517static void lp5521_run_led_pattern(int mode, struct lp5521_chip *chip)
518{
519 struct lp5521_led_pattern *ptn;
520 struct i2c_client *cl = chip->client;
521 int num_patterns = chip->pdata->num_patterns;
522
523 if (mode > num_patterns || !(chip->pdata->patterns))
524 return;
525
526 if (mode == PATTERN_OFF) {
32a2f747 527 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_DEFAULT);
011af7bc
KM		 528 usleep_range(1000, 2000);
529 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_DIRECT);
530 } else {
531 ptn = lp5521_get_pattern(chip, mode);
532 if (!ptn)
533 return;
534
535 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_LOAD);
536 usleep_range(1000, 2000);
537
538 lp5521_clear_program_memory(cl);
539
540 lp5521_write_program_memory(cl, LP5521_REG_R_PROG_MEM,
541 ptn->r, ptn->size_r);
542 lp5521_write_program_memory(cl, LP5521_REG_G_PROG_MEM,
543 ptn->g, ptn->size_g);
544 lp5521_write_program_memory(cl, LP5521_REG_B_PROG_MEM,
545 ptn->b, ptn->size_b);
546
547 lp5521_write(cl, LP5521_REG_OP_MODE, LP5521_CMD_RUN);
548 usleep_range(1000, 2000);
32a2f747 549 lp5521_write(cl, LP5521_REG_ENABLE, LP5521_ENABLE_RUN_PROGRAM);
011af7bc
KM		 550 }
551}
552
553static ssize_t store_led_pattern(struct device *dev,
554 struct device_attribute *attr,
555 const char *buf, size_t len)
556{
557 struct lp5521_chip *chip = i2c_get_clientdata(to_i2c_client(dev));
558 unsigned long val;
559 int ret;
560
69b44c16 561 ret = kstrtoul(buf, 16, &val);
011af7bc
KM		 562 if (ret)
563 return ret;
564
565 lp5521_run_led_pattern(val, chip);
566
567 return len;
568}
569
500fe141 570static struct attribute_group lp5521_led_attribute_group = {
500fe141
SO		 571};
572
573/* device attributes */
67d1da79 574static DEVICE_ATTR(engine1_mode, S_IRUGO | S_IWUSR,
500fe141 575 show_engine1_mode, store_engine1_mode);
67d1da79 576static DEVICE_ATTR(engine2_mode, S_IRUGO | S_IWUSR,
500fe141 577 show_engine2_mode, store_engine2_mode);
67d1da79 578static DEVICE_ATTR(engine3_mode, S_IRUGO | S_IWUSR,
500fe141 579 show_engine3_mode, store_engine3_mode);
67d1da79
VK		 580static DEVICE_ATTR(engine1_load, S_IWUSR, NULL, store_engine1_load);
581static DEVICE_ATTR(engine2_load, S_IWUSR, NULL, store_engine2_load);
582static DEVICE_ATTR(engine3_load, S_IWUSR, NULL, store_engine3_load);
500fe141 583static DEVICE_ATTR(selftest, S_IRUGO, lp5521_selftest, NULL);
011af7bc 584static DEVICE_ATTR(led_pattern, S_IWUSR, NULL, store_led_pattern);
500fe141
SO		 585
586static struct attribute *lp5521_attributes[] = {
587 &dev_attr_engine1_mode.attr,
588 &dev_attr_engine2_mode.attr,
589 &dev_attr_engine3_mode.attr,
590 &dev_attr_selftest.attr,
500fe141 591 &dev_attr_engine1_load.attr,
500fe141 592 &dev_attr_engine2_load.attr,
500fe141 593 &dev_attr_engine3_load.attr,
011af7bc 594 &dev_attr_led_pattern.attr,
500fe141
SO		 595 NULL
596};
597
598static const struct attribute_group lp5521_group = {
599 .attrs = lp5521_attributes,
600};
601
500fe141
SO		 602static int lp5521_register_sysfs(struct i2c_client *client)
603{
604 struct device *dev = &client->dev;
605 return sysfs_create_group(&dev->kobj, &lp5521_group);
606}
607
608static void lp5521_unregister_sysfs(struct i2c_client *client)
609{
610 struct lp5521_chip *chip = i2c_get_clientdata(client);
611 struct device *dev = &client->dev;
612 int i;
613
614 sysfs_remove_group(&dev->kobj, &lp5521_group);
615
500fe141
SO		 616 for (i = 0; i < chip->num_leds; i++)
617 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
618 &lp5521_led_attribute_group);
619}
620
1904f83d
MWK		 621static void lp5521_unregister_leds(struct lp5521_chip *chip)
622{
623 int i;
624
625 for (i = 0; i < chip->num_leds; i++) {
626 led_classdev_unregister(&chip->leds[i].cdev);
627 cancel_work_sync(&chip->leds[i].brightness_work);
628 }
629}
630
48068d5d
MWK		 631/* Chip specific configurations */
632static struct lp55xx_device_config lp5521_cfg = {
633 .reset = {
634 .addr = LP5521_REG_RESET,
635 .val = LP5521_RESET,
636 },
e3a700d8
MWK		 637 .enable = {
638 .addr = LP5521_REG_ENABLE,
639 .val = LP5521_ENABLE_DEFAULT,
640 },
0e202346 641 .max_channel = LP5521_MAX_LEDS,
ffbdccdb 642 .post_init_device = lp5521_post_init_device,
a6e4679a 643 .brightness_work_fn = lp5521_led_brightness_work,
a96bfa13 644 .set_led_current = lp5521_set_led_current,
48068d5d
MWK		 645};
646
98ea1ea2 647static int lp5521_probe(struct i2c_client *client,
500fe141
SO		 648 const struct i2c_device_id *id)
649{
6a0c9a47 650 struct lp5521_chip *old_chip = NULL;
1904f83d 651 int ret;
6a0c9a47
MWK		 652 struct lp55xx_chip *chip;
653 struct lp55xx_led *led;
654 struct lp55xx_platform_data *pdata = client->dev.platform_data;
500fe141 655
6a0c9a47 656 if (!pdata) {
500fe141 657 dev_err(&client->dev, "no platform data\n");
e430dc00 658 return -EINVAL;
500fe141
SO		 659 }
660
6a0c9a47
MWK		 661 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
662 if (!chip)
663 return -ENOMEM;
664
665 led = devm_kzalloc(&client->dev,
666 sizeof(*led) * pdata->num_channels, GFP_KERNEL);
667 if (!led)
668 return -ENOMEM;
669
670 chip->cl = client;
671 chip->pdata = pdata;
48068d5d 672 chip->cfg = &lp5521_cfg;
6a0c9a47
MWK		 673
674 mutex_init(&chip->lock);
500fe141 675
6a0c9a47 676 i2c_set_clientdata(client, led);
500fe141 677
22ebeb48 678 ret = lp55xx_init_device(chip);
944f7b1d 679 if (ret)
f6c64c6f 680 goto err_init;
500fe141
SO		 681
682 dev_info(&client->dev, "%s programmable led chip found\n", id->name);
683
9e9b3db1 684 ret = lp55xx_register_leds(led, chip);
f6524808 685 if (ret)
9e9b3db1 686 goto err_register_leds;
500fe141
SO		 687
688 ret = lp5521_register_sysfs(client);
689 if (ret) {
690 dev_err(&client->dev, "registering sysfs failed\n");
e430dc00 691 goto fail2;
500fe141
SO		 692 }
693 return ret;
e430dc00 694fail2:
945c7007 695 lp5521_unregister_leds(old_chip);
9e9b3db1 696err_register_leds:
6ce61762 697 lp55xx_deinit_device(chip);
f6c64c6f 698err_init:
500fe141
SO		 699 return ret;
700}
701
678e8a6b 702static int lp5521_remove(struct i2c_client *client)
500fe141 703{
945c7007 704 struct lp5521_chip *old_chip = i2c_get_clientdata(client);
6ce61762
MWK		 705 struct lp55xx_led *led = i2c_get_clientdata(client);
706 struct lp55xx_chip *chip = led->chip;
500fe141 707
945c7007 708 lp5521_run_led_pattern(PATTERN_OFF, old_chip);
500fe141
SO		 709 lp5521_unregister_sysfs(client);
710
945c7007 711 lp5521_unregister_leds(old_chip);
6ce61762 712 lp55xx_deinit_device(chip);
500fe141 713
500fe141
SO		 714 return 0;
715}
716
717static const struct i2c_device_id lp5521_id[] = {
718 { "lp5521", 0 }, /* Three channel chip */
719 { }
720};
721MODULE_DEVICE_TABLE(i2c, lp5521_id);
722
723static struct i2c_driver lp5521_driver = {
724 .driver = {
725 .name = "lp5521",
726 },
727 .probe = lp5521_probe,
df07cf81 728 .remove = lp5521_remove,
500fe141
SO		 729 .id_table = lp5521_id,
730};
731
09a0d183 732module_i2c_driver(lp5521_driver);
500fe141
SO		 733
734MODULE_AUTHOR("Mathias Nyman, Yuri Zaporozhets, Samu Onkalo");
735MODULE_DESCRIPTION("LP5521 LED engine");
736MODULE_LICENSE("GPL v2");
kernel source for telekom puls (alcatel/mediatek)