2 * LP5521/LP5523/LP55231/LP5562 Common Driver
4 * Copyright 2012 Texas Instruments
6 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * Derived from leds-lp5521.c, leds-lp5523.c
15 #include <linux/clk.h>
16 #include <linux/delay.h>
17 #include <linux/firmware.h>
18 #include <linux/i2c.h>
19 #include <linux/leds.h>
20 #include <linux/module.h>
21 #include <linux/platform_data/leds-lp55xx.h>
22 #include <linux/slab.h>
23 #include <linux/gpio.h>
24 #include <linux/of_gpio.h>
26 #include "leds-lp55xx-common.h"
28 /* External clock rate */
29 #define LP55XX_CLK_32K 32768
31 static struct lp55xx_led
*cdev_to_lp55xx_led(struct led_classdev
*cdev
)
33 return container_of(cdev
, struct lp55xx_led
, cdev
);
36 static struct lp55xx_led
*dev_to_lp55xx_led(struct device
*dev
)
38 return cdev_to_lp55xx_led(dev_get_drvdata(dev
));
41 static void lp55xx_reset_device(struct lp55xx_chip
*chip
)
43 struct lp55xx_device_config
*cfg
= chip
->cfg
;
44 u8 addr
= cfg
->reset
.addr
;
45 u8 val
= cfg
->reset
.val
;
47 /* no error checking here because no ACK from the device after reset */
48 lp55xx_write(chip
, addr
, val
);
51 static int lp55xx_detect_device(struct lp55xx_chip
*chip
)
53 struct lp55xx_device_config
*cfg
= chip
->cfg
;
54 u8 addr
= cfg
->enable
.addr
;
55 u8 val
= cfg
->enable
.val
;
58 ret
= lp55xx_write(chip
, addr
, val
);
62 usleep_range(1000, 2000);
64 ret
= lp55xx_read(chip
, addr
, &val
);
68 if (val
!= cfg
->enable
.val
)
74 static int lp55xx_post_init_device(struct lp55xx_chip
*chip
)
76 struct lp55xx_device_config
*cfg
= chip
->cfg
;
78 if (!cfg
->post_init_device
)
81 return cfg
->post_init_device(chip
);
84 static ssize_t
lp55xx_show_current(struct device
*dev
,
85 struct device_attribute
*attr
,
88 struct lp55xx_led
*led
= dev_to_lp55xx_led(dev
);
90 return scnprintf(buf
, PAGE_SIZE
, "%d\n", led
->led_current
);
93 static ssize_t
lp55xx_store_current(struct device
*dev
,
94 struct device_attribute
*attr
,
95 const char *buf
, size_t len
)
97 struct lp55xx_led
*led
= dev_to_lp55xx_led(dev
);
98 struct lp55xx_chip
*chip
= led
->chip
;
101 if (kstrtoul(buf
, 0, &curr
))
104 if (curr
> led
->max_current
)
107 if (!chip
->cfg
->set_led_current
)
110 mutex_lock(&chip
->lock
);
111 chip
->cfg
->set_led_current(led
, (u8
)curr
);
112 mutex_unlock(&chip
->lock
);
117 static ssize_t
lp55xx_show_max_current(struct device
*dev
,
118 struct device_attribute
*attr
,
121 struct lp55xx_led
*led
= dev_to_lp55xx_led(dev
);
123 return scnprintf(buf
, PAGE_SIZE
, "%d\n", led
->max_current
);
126 static DEVICE_ATTR(led_current
, S_IRUGO
| S_IWUSR
, lp55xx_show_current
,
127 lp55xx_store_current
);
128 static DEVICE_ATTR(max_current
, S_IRUGO
, lp55xx_show_max_current
, NULL
);
130 static struct attribute
*lp55xx_led_attributes
[] = {
131 &dev_attr_led_current
.attr
,
132 &dev_attr_max_current
.attr
,
136 static struct attribute_group lp55xx_led_attr_group
= {
137 .attrs
= lp55xx_led_attributes
140 static void lp55xx_set_brightness(struct led_classdev
*cdev
,
141 enum led_brightness brightness
)
143 struct lp55xx_led
*led
= cdev_to_lp55xx_led(cdev
);
145 led
->brightness
= (u8
)brightness
;
146 schedule_work(&led
->brightness_work
);
149 static int lp55xx_init_led(struct lp55xx_led
*led
,
150 struct lp55xx_chip
*chip
, int chan
)
152 struct lp55xx_platform_data
*pdata
= chip
->pdata
;
153 struct lp55xx_device_config
*cfg
= chip
->cfg
;
154 struct device
*dev
= &chip
->cl
->dev
;
157 int max_channel
= cfg
->max_channel
;
159 if (chan
>= max_channel
) {
160 dev_err(dev
, "invalid channel: %d / %d\n", chan
, max_channel
);
164 if (pdata
->led_config
[chan
].led_current
== 0)
167 led
->led_current
= pdata
->led_config
[chan
].led_current
;
168 led
->max_current
= pdata
->led_config
[chan
].max_current
;
169 led
->chan_nr
= pdata
->led_config
[chan
].chan_nr
;
170 led
->cdev
.default_trigger
= pdata
->led_config
[chan
].default_trigger
;
172 if (led
->chan_nr
>= max_channel
) {
173 dev_err(dev
, "Use channel numbers between 0 and %d\n",
178 led
->cdev
.brightness_set
= lp55xx_set_brightness
;
180 if (pdata
->led_config
[chan
].name
) {
181 led
->cdev
.name
= pdata
->led_config
[chan
].name
;
183 snprintf(name
, sizeof(name
), "%s:channel%d",
184 pdata
->label
? : chip
->cl
->name
, chan
);
185 led
->cdev
.name
= name
;
189 * register led class device for each channel and
190 * add device attributes
193 ret
= led_classdev_register(dev
, &led
->cdev
);
195 dev_err(dev
, "led register err: %d\n", ret
);
199 ret
= sysfs_create_group(&led
->cdev
.dev
->kobj
, &lp55xx_led_attr_group
);
201 dev_err(dev
, "led sysfs err: %d\n", ret
);
202 led_classdev_unregister(&led
->cdev
);
209 static void lp55xx_firmware_loaded(const struct firmware
*fw
, void *context
)
211 struct lp55xx_chip
*chip
= context
;
212 struct device
*dev
= &chip
->cl
->dev
;
215 dev_err(dev
, "firmware request failed\n");
219 /* handling firmware data is chip dependent */
220 mutex_lock(&chip
->lock
);
223 if (chip
->cfg
->firmware_cb
)
224 chip
->cfg
->firmware_cb(chip
);
226 mutex_unlock(&chip
->lock
);
229 /* firmware should be released for other channel use */
230 release_firmware(chip
->fw
);
233 static int lp55xx_request_firmware(struct lp55xx_chip
*chip
)
235 const char *name
= chip
->cl
->name
;
236 struct device
*dev
= &chip
->cl
->dev
;
238 return request_firmware_nowait(THIS_MODULE
, true, name
, dev
,
239 GFP_KERNEL
, chip
, lp55xx_firmware_loaded
);
242 static ssize_t
lp55xx_show_engine_select(struct device
*dev
,
243 struct device_attribute
*attr
,
246 struct lp55xx_led
*led
= i2c_get_clientdata(to_i2c_client(dev
));
247 struct lp55xx_chip
*chip
= led
->chip
;
249 return sprintf(buf
, "%d\n", chip
->engine_idx
);
252 static ssize_t
lp55xx_store_engine_select(struct device
*dev
,
253 struct device_attribute
*attr
,
254 const char *buf
, size_t len
)
256 struct lp55xx_led
*led
= i2c_get_clientdata(to_i2c_client(dev
));
257 struct lp55xx_chip
*chip
= led
->chip
;
261 if (kstrtoul(buf
, 0, &val
))
264 /* select the engine to be run */
267 case LP55XX_ENGINE_1
:
268 case LP55XX_ENGINE_2
:
269 case LP55XX_ENGINE_3
:
270 mutex_lock(&chip
->lock
);
271 chip
->engine_idx
= val
;
272 ret
= lp55xx_request_firmware(chip
);
273 mutex_unlock(&chip
->lock
);
276 dev_err(dev
, "%lu: invalid engine index. (1, 2, 3)\n", val
);
281 dev_err(dev
, "request firmware err: %d\n", ret
);
288 static inline void lp55xx_run_engine(struct lp55xx_chip
*chip
, bool start
)
290 if (chip
->cfg
->run_engine
)
291 chip
->cfg
->run_engine(chip
, start
);
294 static ssize_t
lp55xx_store_engine_run(struct device
*dev
,
295 struct device_attribute
*attr
,
296 const char *buf
, size_t len
)
298 struct lp55xx_led
*led
= i2c_get_clientdata(to_i2c_client(dev
));
299 struct lp55xx_chip
*chip
= led
->chip
;
302 if (kstrtoul(buf
, 0, &val
))
305 /* run or stop the selected engine */
308 lp55xx_run_engine(chip
, false);
312 mutex_lock(&chip
->lock
);
313 lp55xx_run_engine(chip
, true);
314 mutex_unlock(&chip
->lock
);
319 static DEVICE_ATTR(select_engine
, S_IRUGO
| S_IWUSR
,
320 lp55xx_show_engine_select
, lp55xx_store_engine_select
);
321 static DEVICE_ATTR(run_engine
, S_IWUSR
, NULL
, lp55xx_store_engine_run
);
323 static struct attribute
*lp55xx_engine_attributes
[] = {
324 &dev_attr_select_engine
.attr
,
325 &dev_attr_run_engine
.attr
,
329 static const struct attribute_group lp55xx_engine_attr_group
= {
330 .attrs
= lp55xx_engine_attributes
,
333 int lp55xx_write(struct lp55xx_chip
*chip
, u8 reg
, u8 val
)
335 return i2c_smbus_write_byte_data(chip
->cl
, reg
, val
);
337 EXPORT_SYMBOL_GPL(lp55xx_write
);
339 int lp55xx_read(struct lp55xx_chip
*chip
, u8 reg
, u8
*val
)
343 ret
= i2c_smbus_read_byte_data(chip
->cl
, reg
);
350 EXPORT_SYMBOL_GPL(lp55xx_read
);
352 int lp55xx_update_bits(struct lp55xx_chip
*chip
, u8 reg
, u8 mask
, u8 val
)
357 ret
= lp55xx_read(chip
, reg
, &tmp
);
364 return lp55xx_write(chip
, reg
, tmp
);
366 EXPORT_SYMBOL_GPL(lp55xx_update_bits
);
368 bool lp55xx_is_extclk_used(struct lp55xx_chip
*chip
)
373 clk
= devm_clk_get(&chip
->cl
->dev
, "32k_clk");
375 goto use_internal_clk
;
377 err
= clk_prepare_enable(clk
);
379 goto use_internal_clk
;
381 if (clk_get_rate(clk
) != LP55XX_CLK_32K
) {
382 clk_disable_unprepare(clk
);
383 goto use_internal_clk
;
386 dev_info(&chip
->cl
->dev
, "%dHz external clock used\n", LP55XX_CLK_32K
);
392 dev_info(&chip
->cl
->dev
, "internal clock used\n");
395 EXPORT_SYMBOL_GPL(lp55xx_is_extclk_used
);
397 int lp55xx_init_device(struct lp55xx_chip
*chip
)
399 struct lp55xx_platform_data
*pdata
;
400 struct lp55xx_device_config
*cfg
;
401 struct device
*dev
= &chip
->cl
->dev
;
412 if (gpio_is_valid(pdata
->enable_gpio
)) {
413 ret
= devm_gpio_request_one(dev
, pdata
->enable_gpio
,
414 GPIOF_DIR_OUT
, "lp5523_enable");
416 dev_err(dev
, "could not acquire enable gpio (err=%d)\n",
421 gpio_set_value(pdata
->enable_gpio
, 0);
422 usleep_range(1000, 2000); /* Keep enable down at least 1ms */
423 gpio_set_value(pdata
->enable_gpio
, 1);
424 usleep_range(1000, 2000); /* 500us abs min. */
427 lp55xx_reset_device(chip
);
430 * Exact value is not available. 10 - 20ms
431 * appears to be enough for reset.
433 usleep_range(10000, 20000);
435 ret
= lp55xx_detect_device(chip
);
437 dev_err(dev
, "device detection err: %d\n", ret
);
441 /* chip specific initialization */
442 ret
= lp55xx_post_init_device(chip
);
444 dev_err(dev
, "post init device err: %d\n", ret
);
451 lp55xx_deinit_device(chip
);
455 EXPORT_SYMBOL_GPL(lp55xx_init_device
);
457 void lp55xx_deinit_device(struct lp55xx_chip
*chip
)
459 struct lp55xx_platform_data
*pdata
= chip
->pdata
;
462 clk_disable_unprepare(chip
->clk
);
464 if (gpio_is_valid(pdata
->enable_gpio
))
465 gpio_set_value(pdata
->enable_gpio
, 0);
467 EXPORT_SYMBOL_GPL(lp55xx_deinit_device
);
469 int lp55xx_register_leds(struct lp55xx_led
*led
, struct lp55xx_chip
*chip
)
471 struct lp55xx_platform_data
*pdata
= chip
->pdata
;
472 struct lp55xx_device_config
*cfg
= chip
->cfg
;
473 int num_channels
= pdata
->num_channels
;
474 struct lp55xx_led
*each
;
479 if (!cfg
->brightness_work_fn
) {
480 dev_err(&chip
->cl
->dev
, "empty brightness configuration\n");
484 for (i
= 0; i
< num_channels
; i
++) {
486 /* do not initialize channels that are not connected */
487 if (pdata
->led_config
[i
].led_current
== 0)
490 led_current
= pdata
->led_config
[i
].led_current
;
492 ret
= lp55xx_init_led(each
, chip
, i
);
496 INIT_WORK(&each
->brightness_work
, cfg
->brightness_work_fn
);
501 /* setting led current at each channel */
502 if (cfg
->set_led_current
)
503 cfg
->set_led_current(each
, led_current
);
509 lp55xx_unregister_leds(led
, chip
);
512 EXPORT_SYMBOL_GPL(lp55xx_register_leds
);
514 void lp55xx_unregister_leds(struct lp55xx_led
*led
, struct lp55xx_chip
*chip
)
517 struct lp55xx_led
*each
;
519 for (i
= 0; i
< chip
->num_leds
; i
++) {
521 led_classdev_unregister(&each
->cdev
);
522 flush_work(&each
->brightness_work
);
525 EXPORT_SYMBOL_GPL(lp55xx_unregister_leds
);
527 int lp55xx_register_sysfs(struct lp55xx_chip
*chip
)
529 struct device
*dev
= &chip
->cl
->dev
;
530 struct lp55xx_device_config
*cfg
= chip
->cfg
;
533 if (!cfg
->run_engine
|| !cfg
->firmware_cb
)
534 goto dev_specific_attrs
;
536 ret
= sysfs_create_group(&dev
->kobj
, &lp55xx_engine_attr_group
);
541 return cfg
->dev_attr_group
?
542 sysfs_create_group(&dev
->kobj
, cfg
->dev_attr_group
) : 0;
544 EXPORT_SYMBOL_GPL(lp55xx_register_sysfs
);
546 void lp55xx_unregister_sysfs(struct lp55xx_chip
*chip
)
548 struct device
*dev
= &chip
->cl
->dev
;
549 struct lp55xx_device_config
*cfg
= chip
->cfg
;
551 if (cfg
->dev_attr_group
)
552 sysfs_remove_group(&dev
->kobj
, cfg
->dev_attr_group
);
554 sysfs_remove_group(&dev
->kobj
, &lp55xx_engine_attr_group
);
556 EXPORT_SYMBOL_GPL(lp55xx_unregister_sysfs
);
558 int lp55xx_of_populate_pdata(struct device
*dev
, struct device_node
*np
)
560 struct device_node
*child
;
561 struct lp55xx_platform_data
*pdata
;
562 struct lp55xx_led_config
*cfg
;
566 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
570 num_channels
= of_get_child_count(np
);
571 if (num_channels
== 0) {
572 dev_err(dev
, "no LED channels\n");
576 cfg
= devm_kzalloc(dev
, sizeof(*cfg
) * num_channels
, GFP_KERNEL
);
580 pdata
->led_config
= &cfg
[0];
581 pdata
->num_channels
= num_channels
;
583 for_each_child_of_node(np
, child
) {
586 of_property_read_string(child
, "chan-name", &cfg
[i
].name
);
587 of_property_read_u8(child
, "led-cur", &cfg
[i
].led_current
);
588 of_property_read_u8(child
, "max-cur", &cfg
[i
].max_current
);
589 cfg
[i
].default_trigger
=
590 of_get_property(child
, "linux,default-trigger", NULL
);
595 of_property_read_string(np
, "label", &pdata
->label
);
596 of_property_read_u8(np
, "clock-mode", &pdata
->clock_mode
);
598 pdata
->enable_gpio
= of_get_named_gpio(np
, "enable-gpio", 0);
600 /* LP8501 specific */
601 of_property_read_u8(np
, "pwr-sel", (u8
*)&pdata
->pwr_sel
);
603 dev
->platform_data
= pdata
;
607 EXPORT_SYMBOL_GPL(lp55xx_of_populate_pdata
);
609 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
610 MODULE_DESCRIPTION("LP55xx Common Driver");
611 MODULE_LICENSE("GPL");