1 /*
2  * LP5521/LP5523/LP55231/LP5562 Common Driver
3  *
4  * Copyright 2012 Texas Instruments
5  *
6  * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
7  *
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.
11  *
12  * Derived from leds-lp5521.c, leds-lp5523.c
13  */
14 
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>
25 
26 #include "leds-lp55xx-common.h"
27 
28 /* External clock rate */
29 #define LP55XX_CLK_32K			32768
30 
31 static struct lp55xx_led *cdev_to_lp55xx_led(struct led_classdev *cdev)
32 {
33 	return container_of(cdev, struct lp55xx_led, cdev);
34 }
35 
36 static struct lp55xx_led *dev_to_lp55xx_led(struct device *dev)
37 {
38 	return cdev_to_lp55xx_led(dev_get_drvdata(dev));
39 }
40 
41 static void lp55xx_reset_device(struct lp55xx_chip *chip)
42 {
43 	struct lp55xx_device_config *cfg = chip->cfg;
44 	u8 addr = cfg->reset.addr;
45 	u8 val  = cfg->reset.val;
46 
47 	/* no error checking here because no ACK from the device after reset */
48 	lp55xx_write(chip, addr, val);
49 }
50 
51 static int lp55xx_detect_device(struct lp55xx_chip *chip)
52 {
53 	struct lp55xx_device_config *cfg = chip->cfg;
54 	u8 addr = cfg->enable.addr;
55 	u8 val  = cfg->enable.val;
56 	int ret;
57 
58 	ret = lp55xx_write(chip, addr, val);
59 	if (ret)
60 		return ret;
61 
62 	usleep_range(1000, 2000);
63 
64 	ret = lp55xx_read(chip, addr, &val);
65 	if (ret)
66 		return ret;
67 
68 	if (val != cfg->enable.val)
69 		return -ENODEV;
70 
71 	return 0;
72 }
73 
74 static int lp55xx_post_init_device(struct lp55xx_chip *chip)
75 {
76 	struct lp55xx_device_config *cfg = chip->cfg;
77 
78 	if (!cfg->post_init_device)
79 		return 0;
80 
81 	return cfg->post_init_device(chip);
82 }
83 
84 static ssize_t lp55xx_show_current(struct device *dev,
85 			    struct device_attribute *attr,
86 			    char *buf)
87 {
88 	struct lp55xx_led *led = dev_to_lp55xx_led(dev);
89 
90 	return scnprintf(buf, PAGE_SIZE, "%d\n", led->led_current);
91 }
92 
93 static ssize_t lp55xx_store_current(struct device *dev,
94 			     struct device_attribute *attr,
95 			     const char *buf, size_t len)
96 {
97 	struct lp55xx_led *led = dev_to_lp55xx_led(dev);
98 	struct lp55xx_chip *chip = led->chip;
99 	unsigned long curr;
100 
101 	if (kstrtoul(buf, 0, &curr))
102 		return -EINVAL;
103 
104 	if (curr > led->max_current)
105 		return -EINVAL;
106 
107 	if (!chip->cfg->set_led_current)
108 		return len;
109 
110 	mutex_lock(&chip->lock);
111 	chip->cfg->set_led_current(led, (u8)curr);
112 	mutex_unlock(&chip->lock);
113 
114 	return len;
115 }
116 
117 static ssize_t lp55xx_show_max_current(struct device *dev,
118 			    struct device_attribute *attr,
119 			    char *buf)
120 {
121 	struct lp55xx_led *led = dev_to_lp55xx_led(dev);
122 
123 	return scnprintf(buf, PAGE_SIZE, "%d\n", led->max_current);
124 }
125 
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);
129 
130 static struct attribute *lp55xx_led_attrs[] = {
131 	&dev_attr_led_current.attr,
132 	&dev_attr_max_current.attr,
133 	NULL,
134 };
135 ATTRIBUTE_GROUPS(lp55xx_led);
136 
137 static int lp55xx_set_brightness(struct led_classdev *cdev,
138 			     enum led_brightness brightness)
139 {
140 	struct lp55xx_led *led = cdev_to_lp55xx_led(cdev);
141 	struct lp55xx_device_config *cfg = led->chip->cfg;
142 
143 	led->brightness = (u8)brightness;
144 	return cfg->brightness_fn(led);
145 }
146 
147 static int lp55xx_init_led(struct lp55xx_led *led,
148 			struct lp55xx_chip *chip, int chan)
149 {
150 	struct lp55xx_platform_data *pdata = chip->pdata;
151 	struct lp55xx_device_config *cfg = chip->cfg;
152 	struct device *dev = &chip->cl->dev;
153 	char name[32];
154 	int ret;
155 	int max_channel = cfg->max_channel;
156 
157 	if (chan >= max_channel) {
158 		dev_err(dev, "invalid channel: %d / %d\n", chan, max_channel);
159 		return -EINVAL;
160 	}
161 
162 	if (pdata->led_config[chan].led_current == 0)
163 		return 0;
164 
165 	led->led_current = pdata->led_config[chan].led_current;
166 	led->max_current = pdata->led_config[chan].max_current;
167 	led->chan_nr = pdata->led_config[chan].chan_nr;
168 	led->cdev.default_trigger = pdata->led_config[chan].default_trigger;
169 
170 	if (led->chan_nr >= max_channel) {
171 		dev_err(dev, "Use channel numbers between 0 and %d\n",
172 			max_channel - 1);
173 		return -EINVAL;
174 	}
175 
176 	led->cdev.brightness_set_blocking = lp55xx_set_brightness;
177 	led->cdev.groups = lp55xx_led_groups;
178 
179 	if (pdata->led_config[chan].name) {
180 		led->cdev.name = pdata->led_config[chan].name;
181 	} else {
182 		snprintf(name, sizeof(name), "%s:channel%d",
183 			pdata->label ? : chip->cl->name, chan);
184 		led->cdev.name = name;
185 	}
186 
187 	ret = led_classdev_register(dev, &led->cdev);
188 	if (ret) {
189 		dev_err(dev, "led register err: %d\n", ret);
190 		return ret;
191 	}
192 
193 	return 0;
194 }
195 
196 static void lp55xx_firmware_loaded(const struct firmware *fw, void *context)
197 {
198 	struct lp55xx_chip *chip = context;
199 	struct device *dev = &chip->cl->dev;
200 	enum lp55xx_engine_index idx = chip->engine_idx;
201 
202 	if (!fw) {
203 		dev_err(dev, "firmware request failed\n");
204 		goto out;
205 	}
206 
207 	/* handling firmware data is chip dependent */
208 	mutex_lock(&chip->lock);
209 
210 	chip->engines[idx - 1].mode = LP55XX_ENGINE_LOAD;
211 	chip->fw = fw;
212 	if (chip->cfg->firmware_cb)
213 		chip->cfg->firmware_cb(chip);
214 
215 	mutex_unlock(&chip->lock);
216 
217 out:
218 	/* firmware should be released for other channel use */
219 	release_firmware(chip->fw);
220 }
221 
222 static int lp55xx_request_firmware(struct lp55xx_chip *chip)
223 {
224 	const char *name = chip->cl->name;
225 	struct device *dev = &chip->cl->dev;
226 
227 	return request_firmware_nowait(THIS_MODULE, false, name, dev,
228 				GFP_KERNEL, chip, lp55xx_firmware_loaded);
229 }
230 
231 static ssize_t lp55xx_show_engine_select(struct device *dev,
232 			    struct device_attribute *attr,
233 			    char *buf)
234 {
235 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
236 	struct lp55xx_chip *chip = led->chip;
237 
238 	return sprintf(buf, "%d\n", chip->engine_idx);
239 }
240 
241 static ssize_t lp55xx_store_engine_select(struct device *dev,
242 			     struct device_attribute *attr,
243 			     const char *buf, size_t len)
244 {
245 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
246 	struct lp55xx_chip *chip = led->chip;
247 	unsigned long val;
248 	int ret;
249 
250 	if (kstrtoul(buf, 0, &val))
251 		return -EINVAL;
252 
253 	/* select the engine to be run */
254 
255 	switch (val) {
256 	case LP55XX_ENGINE_1:
257 	case LP55XX_ENGINE_2:
258 	case LP55XX_ENGINE_3:
259 		mutex_lock(&chip->lock);
260 		chip->engine_idx = val;
261 		ret = lp55xx_request_firmware(chip);
262 		mutex_unlock(&chip->lock);
263 		break;
264 	default:
265 		dev_err(dev, "%lu: invalid engine index. (1, 2, 3)\n", val);
266 		return -EINVAL;
267 	}
268 
269 	if (ret) {
270 		dev_err(dev, "request firmware err: %d\n", ret);
271 		return ret;
272 	}
273 
274 	return len;
275 }
276 
277 static inline void lp55xx_run_engine(struct lp55xx_chip *chip, bool start)
278 {
279 	if (chip->cfg->run_engine)
280 		chip->cfg->run_engine(chip, start);
281 }
282 
283 static ssize_t lp55xx_store_engine_run(struct device *dev,
284 			     struct device_attribute *attr,
285 			     const char *buf, size_t len)
286 {
287 	struct lp55xx_led *led = i2c_get_clientdata(to_i2c_client(dev));
288 	struct lp55xx_chip *chip = led->chip;
289 	unsigned long val;
290 
291 	if (kstrtoul(buf, 0, &val))
292 		return -EINVAL;
293 
294 	/* run or stop the selected engine */
295 
296 	if (val <= 0) {
297 		lp55xx_run_engine(chip, false);
298 		return len;
299 	}
300 
301 	mutex_lock(&chip->lock);
302 	lp55xx_run_engine(chip, true);
303 	mutex_unlock(&chip->lock);
304 
305 	return len;
306 }
307 
308 static DEVICE_ATTR(select_engine, S_IRUGO | S_IWUSR,
309 		   lp55xx_show_engine_select, lp55xx_store_engine_select);
310 static DEVICE_ATTR(run_engine, S_IWUSR, NULL, lp55xx_store_engine_run);
311 
312 static struct attribute *lp55xx_engine_attributes[] = {
313 	&dev_attr_select_engine.attr,
314 	&dev_attr_run_engine.attr,
315 	NULL,
316 };
317 
318 static const struct attribute_group lp55xx_engine_attr_group = {
319 	.attrs = lp55xx_engine_attributes,
320 };
321 
322 int lp55xx_write(struct lp55xx_chip *chip, u8 reg, u8 val)
323 {
324 	return i2c_smbus_write_byte_data(chip->cl, reg, val);
325 }
326 EXPORT_SYMBOL_GPL(lp55xx_write);
327 
328 int lp55xx_read(struct lp55xx_chip *chip, u8 reg, u8 *val)
329 {
330 	s32 ret;
331 
332 	ret = i2c_smbus_read_byte_data(chip->cl, reg);
333 	if (ret < 0)
334 		return ret;
335 
336 	*val = ret;
337 	return 0;
338 }
339 EXPORT_SYMBOL_GPL(lp55xx_read);
340 
341 int lp55xx_update_bits(struct lp55xx_chip *chip, u8 reg, u8 mask, u8 val)
342 {
343 	int ret;
344 	u8 tmp;
345 
346 	ret = lp55xx_read(chip, reg, &tmp);
347 	if (ret)
348 		return ret;
349 
350 	tmp &= ~mask;
351 	tmp |= val & mask;
352 
353 	return lp55xx_write(chip, reg, tmp);
354 }
355 EXPORT_SYMBOL_GPL(lp55xx_update_bits);
356 
357 bool lp55xx_is_extclk_used(struct lp55xx_chip *chip)
358 {
359 	struct clk *clk;
360 	int err;
361 
362 	clk = devm_clk_get(&chip->cl->dev, "32k_clk");
363 	if (IS_ERR(clk))
364 		goto use_internal_clk;
365 
366 	err = clk_prepare_enable(clk);
367 	if (err)
368 		goto use_internal_clk;
369 
370 	if (clk_get_rate(clk) != LP55XX_CLK_32K) {
371 		clk_disable_unprepare(clk);
372 		goto use_internal_clk;
373 	}
374 
375 	dev_info(&chip->cl->dev, "%dHz external clock used\n",	LP55XX_CLK_32K);
376 
377 	chip->clk = clk;
378 	return true;
379 
380 use_internal_clk:
381 	dev_info(&chip->cl->dev, "internal clock used\n");
382 	return false;
383 }
384 EXPORT_SYMBOL_GPL(lp55xx_is_extclk_used);
385 
386 int lp55xx_init_device(struct lp55xx_chip *chip)
387 {
388 	struct lp55xx_platform_data *pdata;
389 	struct lp55xx_device_config *cfg;
390 	struct device *dev = &chip->cl->dev;
391 	int ret = 0;
392 
393 	WARN_ON(!chip);
394 
395 	pdata = chip->pdata;
396 	cfg = chip->cfg;
397 
398 	if (!pdata || !cfg)
399 		return -EINVAL;
400 
401 	if (gpio_is_valid(pdata->enable_gpio)) {
402 		ret = devm_gpio_request_one(dev, pdata->enable_gpio,
403 					    GPIOF_DIR_OUT, "lp5523_enable");
404 		if (ret < 0) {
405 			dev_err(dev, "could not acquire enable gpio (err=%d)\n",
406 				ret);
407 			goto err;
408 		}
409 
410 		gpio_set_value(pdata->enable_gpio, 0);
411 		usleep_range(1000, 2000); /* Keep enable down at least 1ms */
412 		gpio_set_value(pdata->enable_gpio, 1);
413 		usleep_range(1000, 2000); /* 500us abs min. */
414 	}
415 
416 	lp55xx_reset_device(chip);
417 
418 	/*
419 	 * Exact value is not available. 10 - 20ms
420 	 * appears to be enough for reset.
421 	 */
422 	usleep_range(10000, 20000);
423 
424 	ret = lp55xx_detect_device(chip);
425 	if (ret) {
426 		dev_err(dev, "device detection err: %d\n", ret);
427 		goto err;
428 	}
429 
430 	/* chip specific initialization */
431 	ret = lp55xx_post_init_device(chip);
432 	if (ret) {
433 		dev_err(dev, "post init device err: %d\n", ret);
434 		goto err_post_init;
435 	}
436 
437 	return 0;
438 
439 err_post_init:
440 	lp55xx_deinit_device(chip);
441 err:
442 	return ret;
443 }
444 EXPORT_SYMBOL_GPL(lp55xx_init_device);
445 
446 void lp55xx_deinit_device(struct lp55xx_chip *chip)
447 {
448 	struct lp55xx_platform_data *pdata = chip->pdata;
449 
450 	if (chip->clk)
451 		clk_disable_unprepare(chip->clk);
452 
453 	if (gpio_is_valid(pdata->enable_gpio))
454 		gpio_set_value(pdata->enable_gpio, 0);
455 }
456 EXPORT_SYMBOL_GPL(lp55xx_deinit_device);
457 
458 int lp55xx_register_leds(struct lp55xx_led *led, struct lp55xx_chip *chip)
459 {
460 	struct lp55xx_platform_data *pdata = chip->pdata;
461 	struct lp55xx_device_config *cfg = chip->cfg;
462 	int num_channels = pdata->num_channels;
463 	struct lp55xx_led *each;
464 	u8 led_current;
465 	int ret;
466 	int i;
467 
468 	if (!cfg->brightness_fn) {
469 		dev_err(&chip->cl->dev, "empty brightness configuration\n");
470 		return -EINVAL;
471 	}
472 
473 	for (i = 0; i < num_channels; i++) {
474 
475 		/* do not initialize channels that are not connected */
476 		if (pdata->led_config[i].led_current == 0)
477 			continue;
478 
479 		led_current = pdata->led_config[i].led_current;
480 		each = led + i;
481 		ret = lp55xx_init_led(each, chip, i);
482 		if (ret)
483 			goto err_init_led;
484 
485 		chip->num_leds++;
486 		each->chip = chip;
487 
488 		/* setting led current at each channel */
489 		if (cfg->set_led_current)
490 			cfg->set_led_current(each, led_current);
491 	}
492 
493 	return 0;
494 
495 err_init_led:
496 	lp55xx_unregister_leds(led, chip);
497 	return ret;
498 }
499 EXPORT_SYMBOL_GPL(lp55xx_register_leds);
500 
501 void lp55xx_unregister_leds(struct lp55xx_led *led, struct lp55xx_chip *chip)
502 {
503 	int i;
504 	struct lp55xx_led *each;
505 
506 	for (i = 0; i < chip->num_leds; i++) {
507 		each = led + i;
508 		led_classdev_unregister(&each->cdev);
509 	}
510 }
511 EXPORT_SYMBOL_GPL(lp55xx_unregister_leds);
512 
513 int lp55xx_register_sysfs(struct lp55xx_chip *chip)
514 {
515 	struct device *dev = &chip->cl->dev;
516 	struct lp55xx_device_config *cfg = chip->cfg;
517 	int ret;
518 
519 	if (!cfg->run_engine || !cfg->firmware_cb)
520 		goto dev_specific_attrs;
521 
522 	ret = sysfs_create_group(&dev->kobj, &lp55xx_engine_attr_group);
523 	if (ret)
524 		return ret;
525 
526 dev_specific_attrs:
527 	return cfg->dev_attr_group ?
528 		sysfs_create_group(&dev->kobj, cfg->dev_attr_group) : 0;
529 }
530 EXPORT_SYMBOL_GPL(lp55xx_register_sysfs);
531 
532 void lp55xx_unregister_sysfs(struct lp55xx_chip *chip)
533 {
534 	struct device *dev = &chip->cl->dev;
535 	struct lp55xx_device_config *cfg = chip->cfg;
536 
537 	if (cfg->dev_attr_group)
538 		sysfs_remove_group(&dev->kobj, cfg->dev_attr_group);
539 
540 	sysfs_remove_group(&dev->kobj, &lp55xx_engine_attr_group);
541 }
542 EXPORT_SYMBOL_GPL(lp55xx_unregister_sysfs);
543 
544 struct lp55xx_platform_data *lp55xx_of_populate_pdata(struct device *dev,
545 						      struct device_node *np)
546 {
547 	struct device_node *child;
548 	struct lp55xx_platform_data *pdata;
549 	struct lp55xx_led_config *cfg;
550 	int num_channels;
551 	int i = 0;
552 
553 	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
554 	if (!pdata)
555 		return ERR_PTR(-ENOMEM);
556 
557 	num_channels = of_get_child_count(np);
558 	if (num_channels == 0) {
559 		dev_err(dev, "no LED channels\n");
560 		return ERR_PTR(-EINVAL);
561 	}
562 
563 	cfg = devm_kcalloc(dev, num_channels, sizeof(*cfg), GFP_KERNEL);
564 	if (!cfg)
565 		return ERR_PTR(-ENOMEM);
566 
567 	pdata->led_config = &cfg[0];
568 	pdata->num_channels = num_channels;
569 
570 	for_each_child_of_node(np, child) {
571 		cfg[i].chan_nr = i;
572 
573 		of_property_read_string(child, "chan-name", &cfg[i].name);
574 		of_property_read_u8(child, "led-cur", &cfg[i].led_current);
575 		of_property_read_u8(child, "max-cur", &cfg[i].max_current);
576 		cfg[i].default_trigger =
577 			of_get_property(child, "linux,default-trigger", NULL);
578 
579 		i++;
580 	}
581 
582 	of_property_read_string(np, "label", &pdata->label);
583 	of_property_read_u8(np, "clock-mode", &pdata->clock_mode);
584 
585 	pdata->enable_gpio = of_get_named_gpio(np, "enable-gpio", 0);
586 
587 	/* LP8501 specific */
588 	of_property_read_u8(np, "pwr-sel", (u8 *)&pdata->pwr_sel);
589 
590 	return pdata;
591 }
592 EXPORT_SYMBOL_GPL(lp55xx_of_populate_pdata);
593 
594 MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
595 MODULE_DESCRIPTION("LP55xx Common Driver");
596 MODULE_LICENSE("GPL");
597