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
47 struct 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
55 struct tlc591xx_priv {
56 struct tlc591xx_led leds[TLC591XX_MAX_LEDS];
57 struct regmap *regmap;
58 unsigned int reg_ledout_offset;
59 };
60
61 struct tlc591xx {
62 unsigned int max_leds;
63 unsigned int reg_ledout_offset;
64 };
65
66 static const struct tlc591xx tlc59116 = {
67 .max_leds = 16,
68 .reg_ledout_offset = 0x14,
69 };
70
71 static const struct tlc591xx tlc59108 = {
72 .max_leds = 8,
73 .reg_ledout_offset = 0x0c,
74 };
75
76 static int
tlc591xx_set_mode(struct regmap * regmap,u8 mode)77 tlc591xx_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
91 static int
tlc591xx_set_ledout(struct tlc591xx_priv * priv,struct tlc591xx_led * led,u8 val)92 tlc591xx_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
104 static int
tlc591xx_set_pwm(struct tlc591xx_priv * priv,struct tlc591xx_led * led,u8 brightness)105 tlc591xx_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
113 static void
tlc591xx_led_work(struct work_struct * work)114 tlc591xx_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
138 static void
tlc591xx_brightness_set(struct led_classdev * led_cdev,enum led_brightness brightness)139 tlc591xx_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
148 static void
tlc591xx_destroy_devices(struct tlc591xx_priv * priv,unsigned int j)149 tlc591xx_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
161 static int
tlc591xx_configure(struct device * dev,struct tlc591xx_priv * priv,const struct tlc591xx * tlc591xx)162 tlc591xx_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
191 exit:
192 tlc591xx_destroy_devices(priv, i);
193 return err;
194 }
195
196 static const struct regmap_config tlc591xx_regmap = {
197 .reg_bits = 8,
198 .val_bits = 8,
199 .max_register = 0x1e,
200 };
201
202 static 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 };
209 MODULE_DEVICE_TABLE(of, of_tlc591xx_leds_match);
210
211 static int
tlc591xx_probe(struct i2c_client * client,const struct i2c_device_id * id)212 tlc591xx_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", ®);
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
265 static int
tlc591xx_remove(struct i2c_client * client)266 tlc591xx_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
275 static const struct i2c_device_id tlc591xx_id[] = {
276 { "tlc59116" },
277 { "tlc59108" },
278 {},
279 };
280 MODULE_DEVICE_TABLE(i2c, tlc591xx_id);
281
282 static 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
292 module_i2c_driver(tlc591xx_driver);
293
294 MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>");
295 MODULE_LICENSE("GPL");
296 MODULE_DESCRIPTION("TLC591XX LED driver");
297