1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * TI LP8860 4-Channel LED Driver
4 *
5 * Copyright (C) 2014 Texas Instruments
6 *
7 * Author: Dan Murphy <dmurphy@ti.com>
8 */
9
10 #include <linux/i2c.h>
11 #include <linux/init.h>
12 #include <linux/leds.h>
13 #include <linux/regmap.h>
14 #include <linux/regulator/consumer.h>
15 #include <linux/module.h>
16 #include <linux/mutex.h>
17 #include <linux/of.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/slab.h>
20
21 #define LP8860_DISP_CL1_BRT_MSB 0x00
22 #define LP8860_DISP_CL1_BRT_LSB 0x01
23 #define LP8860_DISP_CL1_CURR_MSB 0x02
24 #define LP8860_DISP_CL1_CURR_LSB 0x03
25 #define LP8860_CL2_BRT_MSB 0x04
26 #define LP8860_CL2_BRT_LSB 0x05
27 #define LP8860_CL2_CURRENT 0x06
28 #define LP8860_CL3_BRT_MSB 0x07
29 #define LP8860_CL3_BRT_LSB 0x08
30 #define LP8860_CL3_CURRENT 0x09
31 #define LP8860_CL4_BRT_MSB 0x0a
32 #define LP8860_CL4_BRT_LSB 0x0b
33 #define LP8860_CL4_CURRENT 0x0c
34 #define LP8860_CONFIG 0x0d
35 #define LP8860_STATUS 0x0e
36 #define LP8860_FAULT 0x0f
37 #define LP8860_LED_FAULT 0x10
38 #define LP8860_FAULT_CLEAR 0x11
39 #define LP8860_ID 0x12
40 #define LP8860_TEMP_MSB 0x13
41 #define LP8860_TEMP_LSB 0x14
42 #define LP8860_DISP_LED_CURR_MSB 0x15
43 #define LP8860_DISP_LED_CURR_LSB 0x16
44 #define LP8860_DISP_LED_PWM_MSB 0x17
45 #define LP8860_DISP_LED_PWM_LSB 0x18
46 #define LP8860_EEPROM_CNTRL 0x19
47 #define LP8860_EEPROM_UNLOCK 0x1a
48
49 #define LP8860_EEPROM_REG_0 0x60
50 #define LP8860_EEPROM_REG_1 0x61
51 #define LP8860_EEPROM_REG_2 0x62
52 #define LP8860_EEPROM_REG_3 0x63
53 #define LP8860_EEPROM_REG_4 0x64
54 #define LP8860_EEPROM_REG_5 0x65
55 #define LP8860_EEPROM_REG_6 0x66
56 #define LP8860_EEPROM_REG_7 0x67
57 #define LP8860_EEPROM_REG_8 0x68
58 #define LP8860_EEPROM_REG_9 0x69
59 #define LP8860_EEPROM_REG_10 0x6a
60 #define LP8860_EEPROM_REG_11 0x6b
61 #define LP8860_EEPROM_REG_12 0x6c
62 #define LP8860_EEPROM_REG_13 0x6d
63 #define LP8860_EEPROM_REG_14 0x6e
64 #define LP8860_EEPROM_REG_15 0x6f
65 #define LP8860_EEPROM_REG_16 0x70
66 #define LP8860_EEPROM_REG_17 0x71
67 #define LP8860_EEPROM_REG_18 0x72
68 #define LP8860_EEPROM_REG_19 0x73
69 #define LP8860_EEPROM_REG_20 0x74
70 #define LP8860_EEPROM_REG_21 0x75
71 #define LP8860_EEPROM_REG_22 0x76
72 #define LP8860_EEPROM_REG_23 0x77
73 #define LP8860_EEPROM_REG_24 0x78
74
75 #define LP8860_LOCK_EEPROM 0x00
76 #define LP8860_UNLOCK_EEPROM 0x01
77 #define LP8860_PROGRAM_EEPROM 0x02
78 #define LP8860_EEPROM_CODE_1 0x08
79 #define LP8860_EEPROM_CODE_2 0xba
80 #define LP8860_EEPROM_CODE_3 0xef
81
82 #define LP8860_CLEAR_FAULTS 0x01
83
84 #define LP8860_NAME "lp8860"
85
86 /**
87 * struct lp8860_led
88 * @lock: Lock for reading/writing the device
89 * @client: Pointer to the I2C client
90 * @led_dev: led class device pointer
91 * @regmap: Devices register map
92 * @eeprom_regmap: EEPROM register map
93 */
94 struct lp8860_led {
95 struct mutex lock;
96 struct i2c_client *client;
97 struct led_classdev led_dev;
98 struct regmap *regmap;
99 struct regmap *eeprom_regmap;
100 };
101
102 static const struct reg_sequence lp8860_eeprom_disp_regs[] = {
103 { LP8860_EEPROM_REG_0, 0xed },
104 { LP8860_EEPROM_REG_1, 0xdf },
105 { LP8860_EEPROM_REG_2, 0xdc },
106 { LP8860_EEPROM_REG_3, 0xf0 },
107 { LP8860_EEPROM_REG_4, 0xdf },
108 { LP8860_EEPROM_REG_5, 0xe5 },
109 { LP8860_EEPROM_REG_6, 0xf2 },
110 { LP8860_EEPROM_REG_7, 0x77 },
111 { LP8860_EEPROM_REG_8, 0x77 },
112 { LP8860_EEPROM_REG_9, 0x71 },
113 { LP8860_EEPROM_REG_10, 0x3f },
114 { LP8860_EEPROM_REG_11, 0xb7 },
115 { LP8860_EEPROM_REG_12, 0x17 },
116 { LP8860_EEPROM_REG_13, 0xef },
117 { LP8860_EEPROM_REG_14, 0xb0 },
118 { LP8860_EEPROM_REG_15, 0x87 },
119 { LP8860_EEPROM_REG_16, 0xce },
120 { LP8860_EEPROM_REG_17, 0x72 },
121 { LP8860_EEPROM_REG_18, 0xe5 },
122 { LP8860_EEPROM_REG_19, 0xdf },
123 { LP8860_EEPROM_REG_20, 0x35 },
124 { LP8860_EEPROM_REG_21, 0x06 },
125 { LP8860_EEPROM_REG_22, 0xdc },
126 { LP8860_EEPROM_REG_23, 0x88 },
127 { LP8860_EEPROM_REG_24, 0x3E },
128 };
129
lp8860_unlock_eeprom(struct lp8860_led * led)130 static int lp8860_unlock_eeprom(struct lp8860_led *led)
131 {
132 int ret;
133
134 guard(mutex)(&led->lock);
135
136 ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_1);
137 if (ret) {
138 dev_err(&led->client->dev, "EEPROM Unlock failed\n");
139 return ret;
140 }
141
142 ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_2);
143 if (ret) {
144 dev_err(&led->client->dev, "EEPROM Unlock failed\n");
145 return ret;
146 }
147 ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_EEPROM_CODE_3);
148 if (ret) {
149 dev_err(&led->client->dev, "EEPROM Unlock failed\n");
150 return ret;
151 }
152
153 return ret;
154 }
155
lp8860_fault_check(struct lp8860_led * led)156 static int lp8860_fault_check(struct lp8860_led *led)
157 {
158 int ret, fault;
159 unsigned int read_buf;
160
161 ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf);
162 if (ret)
163 goto out;
164
165 fault = read_buf;
166
167 ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf);
168 if (ret)
169 goto out;
170
171 fault |= read_buf;
172
173 /* Attempt to clear any faults */
174 if (fault)
175 ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR,
176 LP8860_CLEAR_FAULTS);
177 out:
178 return ret;
179 }
180
lp8860_brightness_set(struct led_classdev * led_cdev,enum led_brightness brt_val)181 static int lp8860_brightness_set(struct led_classdev *led_cdev,
182 enum led_brightness brt_val)
183 {
184 struct lp8860_led *led =
185 container_of(led_cdev, struct lp8860_led, led_dev);
186 int disp_brightness = brt_val * 255;
187 int ret;
188
189 guard(mutex)(&led->lock);
190
191 ret = lp8860_fault_check(led);
192 if (ret) {
193 dev_err(&led->client->dev, "Cannot read/clear faults\n");
194 return ret;
195 }
196
197 ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB,
198 (disp_brightness & 0xff00) >> 8);
199 if (ret) {
200 dev_err(&led->client->dev, "Cannot write CL1 MSB\n");
201 return ret;
202 }
203
204 ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB,
205 disp_brightness & 0xff);
206 if (ret) {
207 dev_err(&led->client->dev, "Cannot write CL1 LSB\n");
208 return ret;
209 }
210
211 return 0;
212 }
213
lp8860_init(struct lp8860_led * led)214 static int lp8860_init(struct lp8860_led *led)
215 {
216 unsigned int read_buf;
217 int ret, reg_count;
218
219 ret = lp8860_fault_check(led);
220 if (ret)
221 goto out;
222
223 ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf);
224 if (ret)
225 goto out;
226
227 ret = lp8860_unlock_eeprom(led);
228 if (ret) {
229 dev_err(&led->client->dev, "Failed unlocking EEPROM\n");
230 goto out;
231 }
232
233 reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs);
234 ret = regmap_multi_reg_write(led->eeprom_regmap, lp8860_eeprom_disp_regs, reg_count);
235 if (ret) {
236 dev_err(&led->client->dev, "Failed writing EEPROM\n");
237 goto out;
238 }
239
240 ret = regmap_write(led->regmap, LP8860_EEPROM_UNLOCK, LP8860_LOCK_EEPROM);
241 if (ret)
242 goto out;
243
244 ret = regmap_write(led->regmap,
245 LP8860_EEPROM_CNTRL,
246 LP8860_PROGRAM_EEPROM);
247 if (ret) {
248 dev_err(&led->client->dev, "Failed programming EEPROM\n");
249 goto out;
250 }
251
252 return ret;
253
254 out:
255 return ret;
256 }
257
258 static const struct regmap_config lp8860_regmap_config = {
259 .reg_bits = 8,
260 .val_bits = 8,
261
262 .max_register = LP8860_EEPROM_UNLOCK,
263 };
264
265 static const struct regmap_config lp8860_eeprom_regmap_config = {
266 .reg_bits = 8,
267 .val_bits = 8,
268
269 .max_register = LP8860_EEPROM_REG_24,
270 };
271
lp8860_disable_gpio(void * data)272 static void lp8860_disable_gpio(void *data)
273 {
274 struct gpio_desc *gpio = data;
275
276 gpiod_set_value(gpio, 0);
277 }
278
lp8860_probe(struct i2c_client * client)279 static int lp8860_probe(struct i2c_client *client)
280 {
281 int ret;
282 struct lp8860_led *led;
283 struct device_node *np = dev_of_node(&client->dev);
284 struct device_node *child_node;
285 struct led_init_data init_data = {};
286 struct gpio_desc *enable_gpio;
287
288 led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
289 if (!led)
290 return -ENOMEM;
291
292 child_node = of_get_next_available_child(np, NULL);
293 if (!child_node)
294 return -EINVAL;
295
296 enable_gpio = devm_gpiod_get_optional(&client->dev, "enable", GPIOD_OUT_LOW);
297 if (IS_ERR(enable_gpio))
298 return dev_err_probe(&client->dev, PTR_ERR(enable_gpio),
299 "Failed to get enable GPIO\n");
300 devm_add_action_or_reset(&client->dev, lp8860_disable_gpio, enable_gpio);
301
302 ret = devm_regulator_get_enable_optional(&client->dev, "vled");
303 if (ret && ret != -ENODEV)
304 return dev_err_probe(&client->dev, ret,
305 "Failed to enable vled regulator\n");
306
307 led->client = client;
308 led->led_dev.brightness_set_blocking = lp8860_brightness_set;
309
310 ret = devm_mutex_init(&client->dev, &led->lock);
311 if (ret)
312 return dev_err_probe(&client->dev, ret, "Failed to initialize lock\n");
313
314 led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config);
315 if (IS_ERR(led->regmap)) {
316 ret = PTR_ERR(led->regmap);
317 dev_err(&client->dev, "Failed to allocate register map: %d\n",
318 ret);
319 return ret;
320 }
321
322 led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config);
323 if (IS_ERR(led->eeprom_regmap)) {
324 ret = PTR_ERR(led->eeprom_regmap);
325 dev_err(&client->dev, "Failed to allocate register map: %d\n",
326 ret);
327 return ret;
328 }
329
330 ret = lp8860_init(led);
331 if (ret)
332 return ret;
333
334 init_data.fwnode = of_fwnode_handle(child_node);
335 init_data.devicename = LP8860_NAME;
336 init_data.default_label = ":display_cluster";
337
338 ret = devm_led_classdev_register_ext(&client->dev, &led->led_dev,
339 &init_data);
340 if (ret) {
341 dev_err(&client->dev, "led register err: %d\n", ret);
342 return ret;
343 }
344
345 return 0;
346 }
347
348 static const struct i2c_device_id lp8860_id[] = {
349 { "lp8860" },
350 { }
351 };
352 MODULE_DEVICE_TABLE(i2c, lp8860_id);
353
354 static const struct of_device_id of_lp8860_leds_match[] = {
355 { .compatible = "ti,lp8860", },
356 {},
357 };
358 MODULE_DEVICE_TABLE(of, of_lp8860_leds_match);
359
360 static struct i2c_driver lp8860_driver = {
361 .driver = {
362 .name = "lp8860",
363 .of_match_table = of_lp8860_leds_match,
364 },
365 .probe = lp8860_probe,
366 .id_table = lp8860_id,
367 };
368 module_i2c_driver(lp8860_driver);
369
370 MODULE_DESCRIPTION("Texas Instruments LP8860 LED driver");
371 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
372 MODULE_LICENSE("GPL v2");
373