1
2
3
4
5
6
7
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
38#define LEDOUT_OFF 0x0
39#define LEDOUT_ON 0x1
40#define LEDOUT_DIM 0x2
41#define LEDOUT_BLINK 0x3
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", ®);
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
