1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * lp5523.c - LP5523, LP55231 LED Driver
4 *
5 * Copyright (C) 2010 Nokia Corporation
6 * Copyright (C) 2012 Texas Instruments
7 *
8 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
9 * Milo(Woogyom) Kim <milo.kim@ti.com>
10 */
11
12 #include <linux/cleanup.h>
13 #include <linux/delay.h>
14 #include <linux/firmware.h>
15 #include <linux/i2c.h>
16 #include <linux/leds.h>
17 #include <linux/module.h>
18 #include <linux/mutex.h>
19 #include <linux/of.h>
20 #include <linux/platform_data/leds-lp55xx.h>
21 #include <linux/slab.h>
22
23 #include "leds-lp55xx-common.h"
24
25 /* Memory is used like this:
26 * 0x00 engine 1 program
27 * 0x10 engine 2 program
28 * 0x20 engine 3 program
29 * 0x30 engine 1 muxing info
30 * 0x40 engine 2 muxing info
31 * 0x50 engine 3 muxing info
32 */
33 #define LP5523_PAGES_PER_ENGINE 1
34 #define LP5523_MAX_LEDS 9
35
36 /* Registers */
37 #define LP5523_REG_ENABLE 0x00
38 #define LP5523_REG_OP_MODE 0x01
39 #define LP5523_REG_ENABLE_LEDS_MSB 0x04
40 #define LP5523_REG_ENABLE_LEDS_LSB 0x05
41 #define LP5523_REG_LED_CTRL_BASE 0x06
42 #define LP5523_REG_LED_PWM_BASE 0x16
43 #define LP5523_REG_LED_CURRENT_BASE 0x26
44 #define LP5523_REG_CONFIG 0x36
45
46 #define LP5523_REG_STATUS 0x3A
47 #define LP5523_ENGINE_BUSY BIT(4)
48
49 #define LP5523_REG_RESET 0x3D
50 #define LP5523_REG_LED_TEST_CTRL 0x41
51 #define LP5523_REG_LED_TEST_ADC 0x42
52 #define LP5523_REG_MASTER_FADER_BASE 0x48
53 #define LP5523_REG_CH1_PROG_START 0x4C
54 #define LP5523_REG_CH2_PROG_START 0x4D
55 #define LP5523_REG_CH3_PROG_START 0x4E
56 #define LP5523_REG_PROG_PAGE_SEL 0x4F
57 #define LP5523_REG_PROG_MEM 0x50
58
59 /* Bit description in registers */
60 #define LP5523_ENABLE 0x40
61 #define LP5523_AUTO_INC 0x40
62 #define LP5523_PWR_SAVE 0x20
63 #define LP5523_PWM_PWR_SAVE 0x04
64 #define LP5523_CP_MODE_MASK 0x18
65 #define LP5523_CP_MODE_SHIFT 3
66 #define LP5523_AUTO_CLK 0x02
67 #define LP5523_DEFAULT_CONFIG \
68 (LP5523_AUTO_INC | LP5523_PWR_SAVE | LP5523_AUTO_CLK | LP5523_PWM_PWR_SAVE)
69
70 #define LP5523_EN_LEDTEST 0x80
71 #define LP5523_LEDTEST_DONE 0x80
72 #define LP5523_RESET 0xFF
73 #define LP5523_ADC_SHORTCIRC_LIM 80
74 #define LP5523_EXT_CLK_USED 0x08
75 #define LP5523_ENG_STATUS_MASK 0x07
76
77 static int lp5523_init_program_engine(struct lp55xx_chip *chip);
78
lp5523_post_init_device(struct lp55xx_chip * chip)79 static int lp5523_post_init_device(struct lp55xx_chip *chip)
80 {
81 int ret;
82 int val;
83
84 ret = lp55xx_write(chip, LP5523_REG_ENABLE, LP5523_ENABLE);
85 if (ret)
86 return ret;
87
88 /* Chip startup time is 500 us, 1 - 2 ms gives some margin */
89 usleep_range(1000, 2000);
90
91 val = LP5523_DEFAULT_CONFIG;
92 val |= (chip->pdata->charge_pump_mode << LP5523_CP_MODE_SHIFT) & LP5523_CP_MODE_MASK;
93
94 ret = lp55xx_write(chip, LP5523_REG_CONFIG, val);
95 if (ret)
96 return ret;
97
98 /* turn on all leds */
99 ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_MSB, 0x01);
100 if (ret)
101 return ret;
102
103 ret = lp55xx_write(chip, LP5523_REG_ENABLE_LEDS_LSB, 0xff);
104 if (ret)
105 return ret;
106
107 return lp5523_init_program_engine(chip);
108 }
109
lp5523_run_engine(struct lp55xx_chip * chip,bool start)110 static void lp5523_run_engine(struct lp55xx_chip *chip, bool start)
111 {
112 /* stop engine */
113 if (!start) {
114 lp55xx_stop_engine(chip);
115 lp55xx_turn_off_channels(chip);
116 return;
117 }
118
119 lp55xx_run_engine_common(chip);
120 }
121
lp5523_init_program_engine(struct lp55xx_chip * chip)122 static int lp5523_init_program_engine(struct lp55xx_chip *chip)
123 {
124 int i;
125 int j;
126 int ret;
127 u8 status;
128 /* one pattern per engine setting LED MUX start and stop addresses */
129 static const u8 pattern[][LP55xx_BYTES_PER_PAGE] = {
130 { 0x9c, 0x30, 0x9c, 0xb0, 0x9d, 0x80, 0xd8, 0x00, 0},
131 { 0x9c, 0x40, 0x9c, 0xc0, 0x9d, 0x80, 0xd8, 0x00, 0},
132 { 0x9c, 0x50, 0x9c, 0xd0, 0x9d, 0x80, 0xd8, 0x00, 0},
133 };
134
135 /* hardcode 32 bytes of memory for each engine from program memory */
136 ret = lp55xx_write(chip, LP5523_REG_CH1_PROG_START, 0x00);
137 if (ret)
138 return ret;
139
140 ret = lp55xx_write(chip, LP5523_REG_CH2_PROG_START, 0x10);
141 if (ret)
142 return ret;
143
144 ret = lp55xx_write(chip, LP5523_REG_CH3_PROG_START, 0x20);
145 if (ret)
146 return ret;
147
148 /* write LED MUX address space for each engine */
149 for (i = LP55XX_ENGINE_1; i <= LP55XX_ENGINE_3; i++) {
150 chip->engine_idx = i;
151 lp55xx_load_engine(chip);
152
153 for (j = 0; j < LP55xx_BYTES_PER_PAGE; j++) {
154 ret = lp55xx_write(chip, LP5523_REG_PROG_MEM + j,
155 pattern[i - 1][j]);
156 if (ret)
157 goto out;
158 }
159 }
160
161 lp5523_run_engine(chip, true);
162
163 /* Let the programs run for couple of ms and check the engine status */
164 usleep_range(3000, 6000);
165 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
166 if (ret)
167 goto out;
168 status &= LP5523_ENG_STATUS_MASK;
169
170 if (status != LP5523_ENG_STATUS_MASK) {
171 dev_err(&chip->cl->dev,
172 "could not configure LED engine, status = 0x%.2x\n",
173 status);
174 ret = -1;
175 }
176
177 out:
178 lp55xx_stop_all_engine(chip);
179 return ret;
180 }
181
lp5523_selftest(struct device * dev,struct device_attribute * attr,char * buf)182 static ssize_t lp5523_selftest(struct device *dev,
183 struct device_attribute *attr,
184 char *buf)
185 {
186 struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
187 struct lp55xx_chip *chip = led->chip;
188 struct lp55xx_platform_data *pdata = chip->pdata;
189 int ret, pos = 0;
190 u8 status, adc, vdd, i;
191
192 guard(mutex)(&chip->lock);
193
194 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
195 if (ret < 0)
196 return sysfs_emit(buf, "FAIL\n");
197
198 /* Check that ext clock is really in use if requested */
199 if (pdata->clock_mode == LP55XX_CLOCK_EXT) {
200 if ((status & LP5523_EXT_CLK_USED) == 0)
201 return sysfs_emit(buf, "FAIL\n");
202 }
203
204 /* Measure VDD (i.e. VBAT) first (channel 16 corresponds to VDD) */
205 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL, LP5523_EN_LEDTEST | 16);
206 usleep_range(3000, 6000); /* ADC conversion time is typically 2.7 ms */
207 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
208 if (ret < 0)
209 return sysfs_emit(buf, "FAIL\n");
210
211 if (!(status & LP5523_LEDTEST_DONE))
212 usleep_range(3000, 6000); /* Was not ready. Wait little bit */
213
214 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &vdd);
215 if (ret < 0)
216 return sysfs_emit(buf, "FAIL\n");
217
218 vdd--; /* There may be some fluctuation in measurement */
219
220 for (i = 0; i < pdata->num_channels; i++) {
221 /* Skip disabled channels */
222 if (pdata->led_config[i].led_current == 0)
223 continue;
224
225 /* Set default current */
226 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
227 pdata->led_config[i].led_current);
228
229 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
230 0xff);
231 /* let current stabilize 2 - 4ms before measurements start */
232 usleep_range(2000, 4000);
233 lp55xx_write(chip, LP5523_REG_LED_TEST_CTRL,
234 LP5523_EN_LEDTEST | led->chan_nr);
235 /* ADC conversion time is 2.7 ms typically */
236 usleep_range(3000, 6000);
237 ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
238 if (ret < 0)
239 return sysfs_emit(buf, "FAIL\n");
240
241 if (!(status & LP5523_LEDTEST_DONE))
242 usleep_range(3000, 6000); /* Was not ready. Wait. */
243
244 ret = lp55xx_read(chip, LP5523_REG_LED_TEST_ADC, &adc);
245 if (ret < 0)
246 return sysfs_emit(buf, "FAIL\n");
247
248 if (adc >= vdd || adc < LP5523_ADC_SHORTCIRC_LIM)
249 pos += sysfs_emit_at(buf, pos, "LED %d FAIL\n",
250 led->chan_nr);
251
252 lp55xx_write(chip, LP5523_REG_LED_PWM_BASE + led->chan_nr,
253 0x00);
254
255 /* Restore current */
256 lp55xx_write(chip, LP5523_REG_LED_CURRENT_BASE + led->chan_nr,
257 led->led_current);
258 led++;
259 }
260
261 return pos == 0 ? sysfs_emit(buf, "OK\n") : pos;
262 }
263
264 LP55XX_DEV_ATTR_ENGINE_MODE(1);
265 LP55XX_DEV_ATTR_ENGINE_MODE(2);
266 LP55XX_DEV_ATTR_ENGINE_MODE(3);
267 LP55XX_DEV_ATTR_ENGINE_LEDS(1);
268 LP55XX_DEV_ATTR_ENGINE_LEDS(2);
269 LP55XX_DEV_ATTR_ENGINE_LEDS(3);
270 LP55XX_DEV_ATTR_ENGINE_LOAD(1);
271 LP55XX_DEV_ATTR_ENGINE_LOAD(2);
272 LP55XX_DEV_ATTR_ENGINE_LOAD(3);
273 static LP55XX_DEV_ATTR_RO(selftest, lp5523_selftest);
274 LP55XX_DEV_ATTR_MASTER_FADER(1);
275 LP55XX_DEV_ATTR_MASTER_FADER(2);
276 LP55XX_DEV_ATTR_MASTER_FADER(3);
277 static LP55XX_DEV_ATTR_RW(master_fader_leds, lp55xx_show_master_fader_leds,
278 lp55xx_store_master_fader_leds);
279
280 static struct attribute *lp5523_attributes[] = {
281 &dev_attr_engine1_mode.attr,
282 &dev_attr_engine2_mode.attr,
283 &dev_attr_engine3_mode.attr,
284 &dev_attr_engine1_load.attr,
285 &dev_attr_engine2_load.attr,
286 &dev_attr_engine3_load.attr,
287 &dev_attr_engine1_leds.attr,
288 &dev_attr_engine2_leds.attr,
289 &dev_attr_engine3_leds.attr,
290 &dev_attr_selftest.attr,
291 &dev_attr_master_fader1.attr,
292 &dev_attr_master_fader2.attr,
293 &dev_attr_master_fader3.attr,
294 &dev_attr_master_fader_leds.attr,
295 NULL,
296 };
297
298 static const struct attribute_group lp5523_group = {
299 .attrs = lp5523_attributes,
300 };
301
302 /* Chip specific configurations */
303 static struct lp55xx_device_config lp5523_cfg = {
304 .reg_op_mode = {
305 .addr = LP5523_REG_OP_MODE,
306 },
307 .reg_exec = {
308 .addr = LP5523_REG_ENABLE,
309 },
310 .engine_busy = {
311 .addr = LP5523_REG_STATUS,
312 .mask = LP5523_ENGINE_BUSY,
313 },
314 .reset = {
315 .addr = LP5523_REG_RESET,
316 .val = LP5523_RESET,
317 },
318 .enable = {
319 .addr = LP5523_REG_ENABLE,
320 .val = LP5523_ENABLE,
321 },
322 .prog_mem_base = {
323 .addr = LP5523_REG_PROG_MEM,
324 },
325 .reg_led_pwm_base = {
326 .addr = LP5523_REG_LED_PWM_BASE,
327 },
328 .reg_led_current_base = {
329 .addr = LP5523_REG_LED_CURRENT_BASE,
330 },
331 .reg_master_fader_base = {
332 .addr = LP5523_REG_MASTER_FADER_BASE,
333 },
334 .reg_led_ctrl_base = {
335 .addr = LP5523_REG_LED_CTRL_BASE,
336 },
337 .pages_per_engine = LP5523_PAGES_PER_ENGINE,
338 .max_channel = LP5523_MAX_LEDS,
339 .post_init_device = lp5523_post_init_device,
340 .brightness_fn = lp55xx_led_brightness,
341 .multicolor_brightness_fn = lp55xx_multicolor_brightness,
342 .set_led_current = lp55xx_set_led_current,
343 .firmware_cb = lp55xx_firmware_loaded_cb,
344 .run_engine = lp5523_run_engine,
345 .dev_attr_group = &lp5523_group,
346 };
347
348 static const struct i2c_device_id lp5523_id[] = {
349 { "lp5523", .driver_data = (kernel_ulong_t)&lp5523_cfg, },
350 { "lp55231", .driver_data = (kernel_ulong_t)&lp5523_cfg, },
351 { }
352 };
353
354 MODULE_DEVICE_TABLE(i2c, lp5523_id);
355
356 static const struct of_device_id of_lp5523_leds_match[] = {
357 { .compatible = "national,lp5523", .data = &lp5523_cfg, },
358 { .compatible = "ti,lp55231", .data = &lp5523_cfg, },
359 {},
360 };
361
362 MODULE_DEVICE_TABLE(of, of_lp5523_leds_match);
363
364 static struct i2c_driver lp5523_driver = {
365 .driver = {
366 .name = "lp5523x",
367 .of_match_table = of_lp5523_leds_match,
368 },
369 .probe = lp55xx_probe,
370 .remove = lp55xx_remove,
371 .id_table = lp5523_id,
372 };
373
374 module_i2c_driver(lp5523_driver);
375
376 MODULE_AUTHOR("Mathias Nyman <mathias.nyman@nokia.com>");
377 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
378 MODULE_DESCRIPTION("LP5523 LED engine");
379 MODULE_LICENSE("GPL");
380