?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix noaddr, connect and listen
[cor.git] / drivers / leds / leds-lm3532.c
blob0507c6575c0896853b47ba735c2fef332141b600
1 // SPDX-License-Identifier: GPL-2.0
2 // TI LM3532 LED driver
3 // Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
4
5 #include <linux/i2c.h>
6 #include <linux/leds.h>
7 #include <linux/slab.h>
8 #include <linux/regmap.h>
9 #include <linux/types.h>
10 #include <linux/regulator/consumer.h>
11 #include <linux/module.h>
12 #include <uapi/linux/uleds.h>
13 #include <linux/gpio/consumer.h>
14
15 #define LM3532_NAME "lm3532-led"
16 #define LM3532_BL_MODE_MANUAL 0x00
17 #define LM3532_BL_MODE_ALS 0x01
18
19 #define LM3532_REG_OUTPUT_CFG 0x10
20 #define LM3532_REG_STARTSHUT_RAMP 0x11
21 #define LM3532_REG_RT_RAMP 0x12
22 #define LM3532_REG_PWM_A_CFG 0x13
23 #define LM3532_REG_PWM_B_CFG 0x14
24 #define LM3532_REG_PWM_C_CFG 0x15
25 #define LM3532_REG_ZONE_CFG_A 0x16
26 #define LM3532_REG_CTRL_A_FS_CURR 0x17
27 #define LM3532_REG_ZONE_CFG_B 0x18
28 #define LM3532_REG_CTRL_B_FS_CURR 0x19
29 #define LM3532_REG_ZONE_CFG_C 0x1a
30 #define LM3532_REG_CTRL_C_FS_CURR 0x1b
31 #define LM3532_REG_ENABLE 0x1d
32 #define LM3532_ALS_CONFIG 0x23
33 #define LM3532_REG_ZN_0_HI 0x60
34 #define LM3532_REG_ZN_0_LO 0x61
35 #define LM3532_REG_ZN_1_HI 0x62
36 #define LM3532_REG_ZN_1_LO 0x63
37 #define LM3532_REG_ZN_2_HI 0x64
38 #define LM3532_REG_ZN_2_LO 0x65
39 #define LM3532_REG_ZN_3_HI 0x66
40 #define LM3532_REG_ZN_3_LO 0x67
41 #define LM3532_REG_ZONE_TRGT_A 0x70
42 #define LM3532_REG_ZONE_TRGT_B 0x75
43 #define LM3532_REG_ZONE_TRGT_C 0x7a
44 #define LM3532_REG_MAX 0x7e
45
46 /* Control Enable */
47 #define LM3532_CTRL_A_ENABLE BIT(0)
48 #define LM3532_CTRL_B_ENABLE BIT(1)
49 #define LM3532_CTRL_C_ENABLE BIT(2)
50
51 /* PWM Zone Control */
52 #define LM3532_PWM_ZONE_MASK 0x7c
53 #define LM3532_PWM_ZONE_0_EN BIT(2)
54 #define LM3532_PWM_ZONE_1_EN BIT(3)
55 #define LM3532_PWM_ZONE_2_EN BIT(4)
56 #define LM3532_PWM_ZONE_3_EN BIT(5)
57 #define LM3532_PWM_ZONE_4_EN BIT(6)
58
59 /* Brightness Configuration */
60 #define LM3532_I2C_CTRL BIT(0)
61 #define LM3532_ALS_CTRL 0
62 #define LM3532_LINEAR_MAP BIT(1)
63 #define LM3532_ZONE_MASK (BIT(2) | BIT(3) | BIT(4))
64 #define LM3532_ZONE_0 0
65 #define LM3532_ZONE_1 BIT(2)
66 #define LM3532_ZONE_2 BIT(3)
67 #define LM3532_ZONE_3 (BIT(2) | BIT(3))
68 #define LM3532_ZONE_4 BIT(4)
69
70 #define LM3532_ENABLE_ALS BIT(3)
71 #define LM3532_ALS_SEL_SHIFT 6
72
73 /* Zone Boundary Register */
74 #define LM3532_ALS_WINDOW_mV 2000
75 #define LM3532_ALS_ZB_MAX 4
76 #define LM3532_ALS_OFFSET_mV 2
77
78 #define LM3532_CONTROL_A 0
79 #define LM3532_CONTROL_B 1
80 #define LM3532_CONTROL_C 2
81 #define LM3532_MAX_CONTROL_BANKS 3
82 #define LM3532_MAX_LED_STRINGS 3
83
84 #define LM3532_OUTPUT_CFG_MASK 0x3
85 #define LM3532_BRT_VAL_ADJUST 8
86 #define LM3532_RAMP_DOWN_SHIFT 3
87
88 #define LM3532_NUM_RAMP_VALS 8
89 #define LM3532_NUM_AVG_VALS 8
90 #define LM3532_NUM_IMP_VALS 32
91
92 #define LM3532_FS_CURR_MIN 5000
93 #define LM3532_FS_CURR_MAX 29800
94 #define LM3532_FS_CURR_STEP 800
95
96 /*
97 * struct lm3532_als_data
98 * @config - value of ALS configuration register
99 * @als1_imp_sel - value of ALS1 resistor select register
100 * @als2_imp_sel - value of ALS2 resistor select register
101 * @als_avrg_time - ALS averaging time
102 * @als_input_mode - ALS input mode for brightness control
103 * @als_vmin - Minimum ALS voltage
104 * @als_vmax - Maximum ALS voltage
105 * @zone_lo - values of ALS lo ZB(Zone Boundary) registers
106 * @zone_hi - values of ALS hi ZB(Zone Boundary) registers
107 */
108 struct lm3532_als_data {
109 u8 config;
110 u8 als1_imp_sel;
111 u8 als2_imp_sel;
112 u8 als_avrg_time;
113 u8 als_input_mode;
114 u32 als_vmin;
115 u32 als_vmax;
116 u8 zones_lo[LM3532_ALS_ZB_MAX];
117 u8 zones_hi[LM3532_ALS_ZB_MAX];
118 };
119
120 /**
121 * struct lm3532_led
122 * @led_dev: led class device
123 * @priv - Pointer the device data structure
124 * @control_bank - Control bank the LED is associated to
125 * @mode - Mode of the LED string
126 * @ctrl_brt_pointer - Zone target register that controls the sink
127 * @num_leds - Number of LED strings are supported in this array
128 * @full_scale_current - The full-scale current setting for the current sink.
129 * @led_strings - The LED strings supported in this array
130 * @enabled - Enabled status
131 * @label - LED label
132 */
133 struct lm3532_led {
134 struct led_classdev led_dev;
135 struct lm3532_data *priv;
136
137 int control_bank;
138 int mode;
139 int ctrl_brt_pointer;
140 int num_leds;
141 int full_scale_current;
142 int enabled:1;
143 u32 led_strings[LM3532_MAX_CONTROL_BANKS];
144 char label[LED_MAX_NAME_SIZE];
145 };
146
147 /**
148 * struct lm3532_data
149 * @enable_gpio - Hardware enable gpio
150 * @regulator: regulator
151 * @client: i2c client
152 * @regmap - Devices register map
153 * @dev - Pointer to the devices device struct
154 * @lock - Lock for reading/writing the device
155 * @als_data - Pointer to the als data struct
156 * @runtime_ramp_up - Runtime ramp up setting
157 * @runtime_ramp_down - Runtime ramp down setting
158 * @leds - Array of LED strings
159 */
160 struct lm3532_data {
161 struct gpio_desc *enable_gpio;
162 struct regulator *regulator;
163 struct i2c_client *client;
164 struct regmap *regmap;
165 struct device *dev;
166 struct mutex lock;
167
168 struct lm3532_als_data *als_data;
169
170 u32 runtime_ramp_up;
171 u32 runtime_ramp_down;
172
173 struct lm3532_led leds[];
174 };
175
176 static const struct reg_default lm3532_reg_defs[] = {
177 {LM3532_REG_OUTPUT_CFG, 0xe4},
178 {LM3532_REG_STARTSHUT_RAMP, 0xc0},
179 {LM3532_REG_RT_RAMP, 0xc0},
180 {LM3532_REG_PWM_A_CFG, 0x82},
181 {LM3532_REG_PWM_B_CFG, 0x82},
182 {LM3532_REG_PWM_C_CFG, 0x82},
183 {LM3532_REG_ZONE_CFG_A, 0xf1},
184 {LM3532_REG_CTRL_A_FS_CURR, 0xf3},
185 {LM3532_REG_ZONE_CFG_B, 0xf1},
186 {LM3532_REG_CTRL_B_FS_CURR, 0xf3},
187 {LM3532_REG_ZONE_CFG_C, 0xf1},
188 {LM3532_REG_CTRL_C_FS_CURR, 0xf3},
189 {LM3532_REG_ENABLE, 0xf8},
190 {LM3532_ALS_CONFIG, 0x44},
191 {LM3532_REG_ZN_0_HI, 0x35},
192 {LM3532_REG_ZN_0_LO, 0x33},
193 {LM3532_REG_ZN_1_HI, 0x6a},
194 {LM3532_REG_ZN_1_LO, 0x66},
195 {LM3532_REG_ZN_2_HI, 0xa1},
196 {LM3532_REG_ZN_2_LO, 0x99},
197 {LM3532_REG_ZN_3_HI, 0xdc},
198 {LM3532_REG_ZN_3_LO, 0xcc},
199 };
200
201 static const struct regmap_config lm3532_regmap_config = {
202 .reg_bits = 8,
203 .val_bits = 8,
204
205 .max_register = LM3532_REG_MAX,
206 .reg_defaults = lm3532_reg_defs,
207 .num_reg_defaults = ARRAY_SIZE(lm3532_reg_defs),
208 .cache_type = REGCACHE_FLAT,
209 };
210
211 static const int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330,
212 92500, 7400, 6170, 5290,
213 4630, 4110, 3700, 3360,
214 3080, 2850, 2640, 2440,
215 2310, 2180, 2060, 1950,
216 1850, 1760, 1680, 1610,
217 1540, 1480, 1420, 1370,
218 1320, 1280, 1230, 1190};
219 static int lm3532_get_als_imp_index(int als_imped)
220 {
221 int i;
222
223 if (als_imped > als_imp_table[1])
224 return 0;
225
226 if (als_imped < als_imp_table[LM3532_NUM_IMP_VALS - 1])
227 return LM3532_NUM_IMP_VALS - 1;
228
229 for (i = 1; i < LM3532_NUM_IMP_VALS; i++) {
230 if (als_imped == als_imp_table[i])
231 return i;
232
233 /* Find an approximate index by looking up the table */
234 if (als_imped < als_imp_table[i - 1] &&
235 als_imped > als_imp_table[i]) {
236 if (als_imped - als_imp_table[i - 1] <
237 als_imp_table[i] - als_imped)
238 return i + 1;
239 else
240 return i;
241 }
242 }
243
244 return -EINVAL;
245 }
246
247 static int lm3532_get_index(const int table[], int size, int value)
248 {
249 int i;
250
251 for (i = 1; i < size; i++) {
252 if (value == table[i])
253 return i;
254
255 /* Find an approximate index by looking up the table */
256 if (value > table[i - 1] &&
257 value < table[i]) {
258 if (value - table[i - 1] < table[i] - value)
259 return i - 1;
260 else
261 return i;
262 }
263 }
264
265 return -EINVAL;
266 }
267
268 static const int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680,
269 1433360, 286720, 573440,
270 1146880, 2293760};
271 static int lm3532_get_als_avg_index(int avg_time)
272 {
273 if (avg_time <= als_avrg_table[0])
274 return 0;
275
276 if (avg_time > als_avrg_table[LM3532_NUM_AVG_VALS - 1])
277 return LM3532_NUM_AVG_VALS - 1;
278
279 return lm3532_get_index(&als_avrg_table[0], LM3532_NUM_AVG_VALS,
280 avg_time);
281 }
282
283 static const int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192,
284 16384, 32768, 65536};
285 static int lm3532_get_ramp_index(int ramp_time)
286 {
287 if (ramp_time <= ramp_table[0])
288 return 0;
289
290 if (ramp_time > ramp_table[LM3532_NUM_RAMP_VALS - 1])
291 return LM3532_NUM_RAMP_VALS - 1;
292
293 return lm3532_get_index(&ramp_table[0], LM3532_NUM_RAMP_VALS,
294 ramp_time);
295 }
296
297 /* Caller must take care of locking */
298 static int lm3532_led_enable(struct lm3532_led *led_data)
299 {
300 int ctrl_en_val = BIT(led_data->control_bank);
301 int ret;
302
303 if (led_data->enabled)
304 return 0;
305
306 ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
307 ctrl_en_val, ctrl_en_val);
308 if (ret) {
309 dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
310 return ret;
311 }
312
313 ret = regulator_enable(led_data->priv->regulator);
314 if (ret < 0)
315 return ret;
316
317 led_data->enabled = 1;
318
319 return 0;
320 }
321
322 /* Caller must take care of locking */
323 static int lm3532_led_disable(struct lm3532_led *led_data)
324 {
325 int ctrl_en_val = BIT(led_data->control_bank);
326 int ret;
327
328 if (!led_data->enabled)
329 return 0;
330
331 ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
332 ctrl_en_val, 0);
333 if (ret) {
334 dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
335 return ret;
336 }
337
338 ret = regulator_disable(led_data->priv->regulator);
339 if (ret < 0)
340 return ret;
341
342 led_data->enabled = 0;
343
344 return 0;
345 }
346
347 static int lm3532_brightness_set(struct led_classdev *led_cdev,
348 enum led_brightness brt_val)
349 {
350 struct lm3532_led *led =
351 container_of(led_cdev, struct lm3532_led, led_dev);
352 u8 brightness_reg;
353 int ret;
354
355 mutex_lock(&led->priv->lock);
356
357 if (led->mode == LM3532_ALS_CTRL) {
358 if (brt_val > LED_OFF)
359 ret = lm3532_led_enable(led);
360 else
361 ret = lm3532_led_disable(led);
362
363 goto unlock;
364 }
365
366 if (brt_val == LED_OFF) {
367 ret = lm3532_led_disable(led);
368 goto unlock;
369 }
370
371 ret = lm3532_led_enable(led);
372 if (ret)
373 goto unlock;
374
375 brightness_reg = LM3532_REG_ZONE_TRGT_A + led->control_bank * 5 +
376 (led->ctrl_brt_pointer >> 2);
377
378 ret = regmap_write(led->priv->regmap, brightness_reg, brt_val);
379
380 unlock:
381 mutex_unlock(&led->priv->lock);
382 return ret;
383 }
384
385 static int lm3532_init_registers(struct lm3532_led *led)
386 {
387 struct lm3532_data *drvdata = led->priv;
388 unsigned int runtime_ramp_val;
389 unsigned int output_cfg_val = 0;
390 unsigned int output_cfg_shift = 0;
391 unsigned int output_cfg_mask = 0;
392 unsigned int brightness_config_reg;
393 unsigned int brightness_config_val;
394 int fs_current_reg;
395 int fs_current_val;
396 int ret, i;
397
398 if (drvdata->enable_gpio)
399 gpiod_direction_output(drvdata->enable_gpio, 1);
400
401 brightness_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2;
402 /*
403 * This could be hard coded to the default value but the control
404 * brightness register may have changed during boot.
405 */
406 ret = regmap_read(drvdata->regmap, brightness_config_reg,
407 &led->ctrl_brt_pointer);
408 if (ret)
409 return ret;
410
411 led->ctrl_brt_pointer &= LM3532_ZONE_MASK;
412 brightness_config_val = led->ctrl_brt_pointer | led->mode;
413 ret = regmap_write(drvdata->regmap, brightness_config_reg,
414 brightness_config_val);
415 if (ret)
416 return ret;
417
418 if (led->full_scale_current) {
419 fs_current_reg = LM3532_REG_CTRL_A_FS_CURR + led->control_bank * 2;
420 fs_current_val = (led->full_scale_current - LM3532_FS_CURR_MIN) /
421 LM3532_FS_CURR_STEP;
422
423 ret = regmap_write(drvdata->regmap, fs_current_reg,
424 fs_current_val);
425 if (ret)
426 return ret;
427 }
428
429 for (i = 0; i < led->num_leds; i++) {
430 output_cfg_shift = led->led_strings[i] * 2;
431 output_cfg_val |= (led->control_bank << output_cfg_shift);
432 output_cfg_mask |= LM3532_OUTPUT_CFG_MASK << output_cfg_shift;
433 }
434
435 ret = regmap_update_bits(drvdata->regmap, LM3532_REG_OUTPUT_CFG,
436 output_cfg_mask, output_cfg_val);
437 if (ret)
438 return ret;
439
440 runtime_ramp_val = drvdata->runtime_ramp_up |
441 (drvdata->runtime_ramp_down << LM3532_RAMP_DOWN_SHIFT);
442
443 return regmap_write(drvdata->regmap, LM3532_REG_RT_RAMP,
444 runtime_ramp_val);
445 }
446
447 static int lm3532_als_configure(struct lm3532_data *priv,
448 struct lm3532_led *led)
449 {
450 struct lm3532_als_data *als = priv->als_data;
451 u32 als_vmin, als_vmax, als_vstep;
452 int zone_reg = LM3532_REG_ZN_0_HI;
453 int ret;
454 int i;
455
456 als_vmin = als->als_vmin;
457 als_vmax = als->als_vmax;
458
459 als_vstep = (als_vmax - als_vmin) / ((LM3532_ALS_ZB_MAX + 1) * 2);
460
461 for (i = 0; i < LM3532_ALS_ZB_MAX; i++) {
462 als->zones_lo[i] = ((als_vmin + als_vstep + (i * als_vstep)) *
463 LED_FULL) / 1000;
464 als->zones_hi[i] = ((als_vmin + LM3532_ALS_OFFSET_mV +
465 als_vstep + (i * als_vstep)) * LED_FULL) / 1000;
466
467 zone_reg = LM3532_REG_ZN_0_HI + i * 2;
468 ret = regmap_write(priv->regmap, zone_reg, als->zones_lo[i]);
469 if (ret)
470 return ret;
471
472 zone_reg += 1;
473 ret = regmap_write(priv->regmap, zone_reg, als->zones_hi[i]);
474 if (ret)
475 return ret;
476 }
477
478 als->config = (als->als_avrg_time | (LM3532_ENABLE_ALS) |
479 (als->als_input_mode << LM3532_ALS_SEL_SHIFT));
480
481 return regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config);
482 }
483
484 static int lm3532_parse_als(struct lm3532_data *priv)
485 {
486 struct lm3532_als_data *als;
487 int als_avg_time;
488 int als_impedance;
489 int ret;
490
491 als = devm_kzalloc(priv->dev, sizeof(*als), GFP_KERNEL);
492 if (als == NULL)
493 return -ENOMEM;
494
495 ret = device_property_read_u32(&priv->client->dev, "ti,als-vmin",
496 &als->als_vmin);
497 if (ret)
498 als->als_vmin = 0;
499
500 ret = device_property_read_u32(&priv->client->dev, "ti,als-vmax",
501 &als->als_vmax);
502 if (ret)
503 als->als_vmax = LM3532_ALS_WINDOW_mV;
504
505 if (als->als_vmax > LM3532_ALS_WINDOW_mV) {
506 ret = -EINVAL;
507 return ret;
508 }
509
510 ret = device_property_read_u32(&priv->client->dev, "ti,als1-imp-sel",
511 &als_impedance);
512 if (ret)
513 als->als1_imp_sel = 0;
514 else
515 als->als1_imp_sel = lm3532_get_als_imp_index(als_impedance);
516
517 ret = device_property_read_u32(&priv->client->dev, "ti,als2-imp-sel",
518 &als_impedance);
519 if (ret)
520 als->als2_imp_sel = 0;
521 else
522 als->als2_imp_sel = lm3532_get_als_imp_index(als_impedance);
523
524 ret = device_property_read_u32(&priv->client->dev, "ti,als-avrg-time-us",
525 &als_avg_time);
526 if (ret)
527 als->als_avrg_time = 0;
528 else
529 als->als_avrg_time = lm3532_get_als_avg_index(als_avg_time);
530
531 ret = device_property_read_u8(&priv->client->dev, "ti,als-input-mode",
532 &als->als_input_mode);
533 if (ret)
534 als->als_input_mode = 0;
535
536 if (als->als_input_mode > LM3532_BL_MODE_ALS) {
537 ret = -EINVAL;
538 return ret;
539 }
540
541 priv->als_data = als;
542
543 return ret;
544 }
545
546 static int lm3532_parse_node(struct lm3532_data *priv)
547 {
548 struct fwnode_handle *child = NULL;
549 struct lm3532_led *led;
550 const char *name;
551 int control_bank;
552 u32 ramp_time;
553 size_t i = 0;
554 int ret;
555
556 priv->enable_gpio = devm_gpiod_get_optional(&priv->client->dev,
557 "enable", GPIOD_OUT_LOW);
558 if (IS_ERR(priv->enable_gpio))
559 priv->enable_gpio = NULL;
560
561 priv->regulator = devm_regulator_get(&priv->client->dev, "vin");
562 if (IS_ERR(priv->regulator))
563 priv->regulator = NULL;
564
565 ret = device_property_read_u32(&priv->client->dev, "ramp-up-us",
566 &ramp_time);
567 if (ret)
568 dev_info(&priv->client->dev, "ramp-up-ms property missing\n");
569 else
570 priv->runtime_ramp_up = lm3532_get_ramp_index(ramp_time);
571
572 ret = device_property_read_u32(&priv->client->dev, "ramp-down-us",
573 &ramp_time);
574 if (ret)
575 dev_info(&priv->client->dev, "ramp-down-ms property missing\n");
576 else
577 priv->runtime_ramp_down = lm3532_get_ramp_index(ramp_time);
578
579 device_for_each_child_node(priv->dev, child) {
580 led = &priv->leds[i];
581
582 ret = fwnode_property_read_u32(child, "reg", &control_bank);
583 if (ret) {
584 dev_err(&priv->client->dev, "reg property missing\n");
585 fwnode_handle_put(child);
586 goto child_out;
587 }
588
589 if (control_bank > LM3532_CONTROL_C) {
590 dev_err(&priv->client->dev, "Control bank invalid\n");
591 continue;
592 }
593
594 led->control_bank = control_bank;
595
596 ret = fwnode_property_read_u32(child, "ti,led-mode",
597 &led->mode);
598 if (ret) {
599 dev_err(&priv->client->dev, "ti,led-mode property missing\n");
600 fwnode_handle_put(child);
601 goto child_out;
602 }
603
604 if (fwnode_property_present(child, "led-max-microamp") &&
605 fwnode_property_read_u32(child, "led-max-microamp",
606 &led->full_scale_current))
607 dev_err(&priv->client->dev,
608 "Failed getting led-max-microamp\n");
609 else
610 led->full_scale_current = min(led->full_scale_current,
611 LM3532_FS_CURR_MAX);
612
613 if (led->mode == LM3532_BL_MODE_ALS) {
614 led->mode = LM3532_ALS_CTRL;
615 ret = lm3532_parse_als(priv);
616 if (ret)
617 dev_err(&priv->client->dev, "Failed to parse als\n");
618 else
619 lm3532_als_configure(priv, led);
620 } else {
621 led->mode = LM3532_I2C_CTRL;
622 }
623
624 led->num_leds = fwnode_property_count_u32(child, "led-sources");
625 if (led->num_leds > LM3532_MAX_LED_STRINGS) {
626 dev_err(&priv->client->dev, "To many LED string defined\n");
627 continue;
628 }
629
630 ret = fwnode_property_read_u32_array(child, "led-sources",
631 led->led_strings,
632 led->num_leds);
633 if (ret) {
634 dev_err(&priv->client->dev, "led-sources property missing\n");
635 fwnode_handle_put(child);
636 goto child_out;
637 }
638
639 fwnode_property_read_string(child, "linux,default-trigger",
640 &led->led_dev.default_trigger);
641
642 ret = fwnode_property_read_string(child, "label", &name);
643 if (ret)
644 snprintf(led->label, sizeof(led->label),
645 "%s::", priv->client->name);
646 else
647 snprintf(led->label, sizeof(led->label),
648 "%s:%s", priv->client->name, name);
649
650 led->priv = priv;
651 led->led_dev.name = led->label;
652 led->led_dev.brightness_set_blocking = lm3532_brightness_set;
653
654 ret = devm_led_classdev_register(priv->dev, &led->led_dev);
655 if (ret) {
656 dev_err(&priv->client->dev, "led register err: %d\n",
657 ret);
658 fwnode_handle_put(child);
659 goto child_out;
660 }
661
662 ret = lm3532_init_registers(led);
663 if (ret) {
664 dev_err(&priv->client->dev, "register init err: %d\n",
665 ret);
666 fwnode_handle_put(child);
667 goto child_out;
668 }
669
670 i++;
671 }
672
673 child_out:
674 return ret;
675 }
676
677 static int lm3532_probe(struct i2c_client *client,
678 const struct i2c_device_id *id)
679 {
680 struct lm3532_data *drvdata;
681 int ret = 0;
682 int count;
683
684 count = device_get_child_node_count(&client->dev);
685 if (!count) {
686 dev_err(&client->dev, "LEDs are not defined in device tree!");
687 return -ENODEV;
688 }
689
690 drvdata = devm_kzalloc(&client->dev, struct_size(drvdata, leds, count),
691 GFP_KERNEL);
692 if (drvdata == NULL)
693 return -ENOMEM;
694
695 drvdata->client = client;
696 drvdata->dev = &client->dev;
697
698 drvdata->regmap = devm_regmap_init_i2c(client, &lm3532_regmap_config);
699 if (IS_ERR(drvdata->regmap)) {
700 ret = PTR_ERR(drvdata->regmap);
701 dev_err(&client->dev, "Failed to allocate register map: %d\n",
702 ret);
703 return ret;
704 }
705
706 mutex_init(&drvdata->lock);
707 i2c_set_clientdata(client, drvdata);
708
709 ret = lm3532_parse_node(drvdata);
710 if (ret) {
711 dev_err(&client->dev, "Failed to parse node\n");
712 return ret;
713 }
714
715 return ret;
716 }
717
718 static int lm3532_remove(struct i2c_client *client)
719 {
720 struct lm3532_data *drvdata = i2c_get_clientdata(client);
721
722 mutex_destroy(&drvdata->lock);
723
724 if (drvdata->enable_gpio)
725 gpiod_direction_output(drvdata->enable_gpio, 0);
726
727 return 0;
728 }
729
730 static const struct of_device_id of_lm3532_leds_match[] = {
731 { .compatible = "ti,lm3532", },
732 {},
733 };
734 MODULE_DEVICE_TABLE(of, of_lm3532_leds_match);
735
736 static const struct i2c_device_id lm3532_id[] = {
737 {LM3532_NAME, 0},
738 {}
739 };
740 MODULE_DEVICE_TABLE(i2c, lm3532_id);
741
742 static struct i2c_driver lm3532_i2c_driver = {
743 .probe = lm3532_probe,
744 .remove = lm3532_remove,
745 .id_table = lm3532_id,
746 .driver = {
747 .name = LM3532_NAME,
748 .of_match_table = of_lm3532_leds_match,
749 },
750 };
751 module_i2c_driver(lm3532_i2c_driver);
752
753 MODULE_DESCRIPTION("Back Light driver for LM3532");
754 MODULE_LICENSE("GPL v2");
755 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
connection oriented routing