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