1/*
2 * Copyright 2014 Belkin Inc.
3 * Copyright 2015 Andrew Lunn <andrew@lunn.ch>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
8 */
9
10#include <linux/i2c.h>
11#include <linux/leds.h>
12#include <linux/module.h>
13#include <linux/of.h>
14#include <linux/of_device.h>
15#include <linux/regmap.h>
16#include <linux/slab.h>
17#include <linux/workqueue.h>
18
19#define TLC591XX_MAX_LEDS	16
20
21#define TLC591XX_REG_MODE1	0x00
22#define MODE1_RESPON_ADDR_MASK	0xF0
23#define MODE1_NORMAL_MODE	(0 << 4)
24#define MODE1_SPEED_MODE	(1 << 4)
25
26#define TLC591XX_REG_MODE2	0x01
27#define MODE2_DIM		(0 << 5)
28#define MODE2_BLINK		(1 << 5)
29#define MODE2_OCH_STOP		(0 << 3)
30#define MODE2_OCH_ACK		(1 << 3)
31
32#define TLC591XX_REG_PWM(x)	(0x02 + (x))
33
34#define TLC591XX_REG_GRPPWM	0x12
35#define TLC591XX_REG_GRPFREQ	0x13
36
37/* LED Driver Output State, determine the source that drives LED outputs */
38#define LEDOUT_OFF		0x0	/* Output LOW */
39#define LEDOUT_ON		0x1	/* Output HI-Z */
40#define LEDOUT_DIM		0x2	/* Dimming */
41#define LEDOUT_BLINK		0x3	/* Blinking */
42#define LEDOUT_MASK		0x3
43
44#define ldev_to_led(c)		container_of(c, struct tlc591xx_led, ldev)
45#define work_to_led(work)	container_of(work, struct tlc591xx_led, work)
46
47struct tlc591xx_led {
48	bool active;
49	unsigned int led_no;
50	struct led_classdev ldev;
51	struct work_struct work;
52	struct tlc591xx_priv *priv;
53};
54
55struct tlc591xx_priv {
56	struct tlc591xx_led leds[TLC591XX_MAX_LEDS];
57	struct regmap *regmap;
58	unsigned int reg_ledout_offset;
59};
60
61struct tlc591xx {
62	unsigned int max_leds;
63	unsigned int reg_ledout_offset;
64};
65
66static const struct tlc591xx tlc59116 = {
67	.max_leds = 16,
68	.reg_ledout_offset = 0x14,
69};
70
71static const struct tlc591xx tlc59108 = {
72	.max_leds = 8,
73	.reg_ledout_offset = 0x0c,
74};
75
76static int
77tlc591xx_set_mode(struct regmap *regmap, u8 mode)
78{
79	int err;
80	u8 val;
81
82	err = regmap_write(regmap, TLC591XX_REG_MODE1, MODE1_NORMAL_MODE);
83	if (err)
84		return err;
85
86	val = MODE2_OCH_STOP | mode;
87
88	return regmap_write(regmap, TLC591XX_REG_MODE2, val);
89}
90
91static int
92tlc591xx_set_ledout(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
93		    u8 val)
94{
95	unsigned int i = (led->led_no % 4) * 2;
96	unsigned int mask = LEDOUT_MASK << i;
97	unsigned int addr = priv->reg_ledout_offset + (led->led_no >> 2);
98
99	val = val << i;
100
101	return regmap_update_bits(priv->regmap, addr, mask, val);
102}
103
104static int
105tlc591xx_set_pwm(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
106		 u8 brightness)
107{
108	u8 pwm = TLC591XX_REG_PWM(led->led_no);
109
110	return regmap_write(priv->regmap, pwm, brightness);
111}
112
113static void
114tlc591xx_led_work(struct work_struct *work)
115{
116	struct tlc591xx_led *led = work_to_led(work);
117	struct tlc591xx_priv *priv = led->priv;
118	enum led_brightness brightness = led->ldev.brightness;
119	int err;
120
121	switch (brightness) {
122	case 0:
123		err = tlc591xx_set_ledout(priv, led, LEDOUT_OFF);
124		break;
125	case LED_FULL:
126		err = tlc591xx_set_ledout(priv, led, LEDOUT_ON);
127		break;
128	default:
129		err = tlc591xx_set_ledout(priv, led, LEDOUT_DIM);
130		if (!err)
131			err = tlc591xx_set_pwm(priv, led, brightness);
132	}
133
134	if (err)
135		dev_err(led->ldev.dev, "Failed setting brightness\n");
136}
137
138static void
139tlc591xx_brightness_set(struct led_classdev *led_cdev,
140			enum led_brightness brightness)
141{
142	struct tlc591xx_led *led = ldev_to_led(led_cdev);
143
144	led->ldev.brightness = brightness;
145	schedule_work(&led->work);
146}
147
148static void
149tlc591xx_destroy_devices(struct tlc591xx_priv *priv, unsigned int j)
150{
151	int i = j;
152
153	while (--i >= 0) {
154		if (priv->leds[i].active) {
155			led_classdev_unregister(&priv->leds[i].ldev);
156			cancel_work_sync(&priv->leds[i].work);
157		}
158	}
159}
160
161static int
162tlc591xx_configure(struct device *dev,
163		   struct tlc591xx_priv *priv,
164		   const struct tlc591xx *tlc591xx)
165{
166	unsigned int i;
167	int err = 0;
168
169	tlc591xx_set_mode(priv->regmap, MODE2_DIM);
170	for (i = 0; i < TLC591XX_MAX_LEDS; i++) {
171		struct tlc591xx_led *led = &priv->leds[i];
172
173		if (!led->active)
174			continue;
175
176		led->priv = priv;
177		led->led_no = i;
178		led->ldev.brightness_set = tlc591xx_brightness_set;
179		led->ldev.max_brightness = LED_FULL;
180		INIT_WORK(&led->work, tlc591xx_led_work);
181		err = led_classdev_register(dev, &led->ldev);
182		if (err < 0) {
183			dev_err(dev, "couldn't register LED %s\n",
184				led->ldev.name);
185			goto exit;
186		}
187	}
188
189	return 0;
190
191exit:
192	tlc591xx_destroy_devices(priv, i);
193	return err;
194}
195
196static const struct regmap_config tlc591xx_regmap = {
197	.reg_bits = 8,
198	.val_bits = 8,
199	.max_register = 0x1e,
200};
201
202static const struct of_device_id of_tlc591xx_leds_match[] = {
203	{ .compatible = "ti,tlc59116",
204	  .data = &tlc59116 },
205	{ .compatible = "ti,tlc59108",
206	  .data = &tlc59108 },
207	{},
208};
209MODULE_DEVICE_TABLE(of, of_tlc591xx_leds_match);
210
211static int
212tlc591xx_probe(struct i2c_client *client,
213	       const struct i2c_device_id *id)
214{
215	struct device_node *np = client->dev.of_node, *child;
216	struct device *dev = &client->dev;
217	const struct of_device_id *match;
218	const struct tlc591xx *tlc591xx;
219	struct tlc591xx_priv *priv;
220	int err, count, reg;
221
222	match = of_match_device(of_tlc591xx_leds_match, dev);
223	if (!match)
224		return -ENODEV;
225
226	tlc591xx = match->data;
227	if (!np)
228		return -ENODEV;
229
230	count = of_get_child_count(np);
231	if (!count || count > tlc591xx->max_leds)
232		return -EINVAL;
233
234	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
235	if (!priv)
236		return -ENOMEM;
237
238	priv->regmap = devm_regmap_init_i2c(client, &tlc591xx_regmap);
239	if (IS_ERR(priv->regmap)) {
240		err = PTR_ERR(priv->regmap);
241		dev_err(dev, "Failed to allocate register map: %d\n", err);
242		return err;
243	}
244	priv->reg_ledout_offset = tlc591xx->reg_ledout_offset;
245
246	i2c_set_clientdata(client, priv);
247
248	for_each_child_of_node(np, child) {
249		err = of_property_read_u32(child, "reg", &reg);
250		if (err)
251			return err;
252		if (reg < 0 || reg >= tlc591xx->max_leds)
253			return -EINVAL;
254		if (priv->leds[reg].active)
255			return -EINVAL;
256		priv->leds[reg].active = true;
257		priv->leds[reg].ldev.name =
258			of_get_property(child, "label", NULL) ? : child->name;
259		priv->leds[reg].ldev.default_trigger =
260			of_get_property(child, "linux,default-trigger", NULL);
261	}
262	return tlc591xx_configure(dev, priv, tlc591xx);
263}
264
265static int
266tlc591xx_remove(struct i2c_client *client)
267{
268	struct tlc591xx_priv *priv = i2c_get_clientdata(client);
269
270	tlc591xx_destroy_devices(priv, TLC591XX_MAX_LEDS);
271
272	return 0;
273}
274
275static const struct i2c_device_id tlc591xx_id[] = {
276	{ "tlc59116" },
277	{ "tlc59108" },
278	{},
279};
280MODULE_DEVICE_TABLE(i2c, tlc591xx_id);
281
282static struct i2c_driver tlc591xx_driver = {
283	.driver = {
284		.name = "tlc591xx",
285		.of_match_table = of_match_ptr(of_tlc591xx_leds_match),
286	},
287	.probe = tlc591xx_probe,
288	.remove = tlc591xx_remove,
289	.id_table = tlc591xx_id,
290};
291
292module_i2c_driver(tlc591xx_driver);
293
294MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>");
295MODULE_LICENSE("GPL");
296MODULE_DESCRIPTION("TLC591XX LED driver");
297