1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright 2011 bct electronic GmbH |
4 | * Copyright 2013 Qtechnology/AS |
5 | * |
6 | * Author: Peter Meerwald <p.meerwald@bct-electronic.com> |
7 | * Author: Ricardo Ribalda <ribalda@kernel.org> |
8 | * |
9 | * Based on leds-pca955x.c |
10 | * |
11 | * LED driver for the PCA9633 I2C LED driver (7-bit slave address 0x62) |
12 | * LED driver for the PCA9634/5 I2C LED driver (7-bit slave address set by hw.) |
13 | * |
14 | * Note that hardware blinking violates the leds infrastructure driver |
15 | * interface since the hardware only supports blinking all LEDs with the |
16 | * same delay_on/delay_off rates. That is, only the LEDs that are set to |
17 | * blink will actually blink but all LEDs that are set to blink will blink |
18 | * in identical fashion. The delay_on/delay_off values of the last LED |
19 | * that is set to blink will be used for all of the blinking LEDs. |
20 | * Hardware blinking is disabled by default but can be enabled by setting |
21 | * the 'blink_type' member in the platform_data struct to 'PCA963X_HW_BLINK' |
22 | * or by adding the 'nxp,hw-blink' property to the DTS. |
23 | */ |
24 | |
25 | #include <linux/module.h> |
26 | #include <linux/delay.h> |
27 | #include <linux/string.h> |
28 | #include <linux/ctype.h> |
29 | #include <linux/leds.h> |
30 | #include <linux/err.h> |
31 | #include <linux/i2c.h> |
32 | #include <linux/property.h> |
33 | #include <linux/slab.h> |
34 | #include <linux/of.h> |
35 | |
36 | /* LED select registers determine the source that drives LED outputs */ |
37 | #define PCA963X_LED_OFF 0x0 /* LED driver off */ |
38 | #define PCA963X_LED_ON 0x1 /* LED driver on */ |
39 | #define PCA963X_LED_PWM 0x2 /* Controlled through PWM */ |
40 | #define PCA963X_LED_GRP_PWM 0x3 /* Controlled through PWM/GRPPWM */ |
41 | |
42 | #define PCA963X_MODE2_OUTDRV 0x04 /* Open-drain or totem pole */ |
43 | #define PCA963X_MODE2_INVRT 0x10 /* Normal or inverted direction */ |
44 | #define PCA963X_MODE2_DMBLNK 0x20 /* Enable blinking */ |
45 | |
46 | #define PCA963X_MODE1 0x00 |
47 | #define PCA963X_MODE2 0x01 |
48 | #define PCA963X_PWM_BASE 0x02 |
49 | |
50 | enum pca963x_type { |
51 | pca9633, |
52 | pca9634, |
53 | pca9635, |
54 | }; |
55 | |
56 | struct pca963x_chipdef { |
57 | u8 grppwm; |
58 | u8 grpfreq; |
59 | u8 ledout_base; |
60 | int n_leds; |
61 | unsigned int scaling; |
62 | }; |
63 | |
64 | static struct pca963x_chipdef pca963x_chipdefs[] = { |
65 | [pca9633] = { |
66 | .grppwm = 0x6, |
67 | .grpfreq = 0x7, |
68 | .ledout_base = 0x8, |
69 | .n_leds = 4, |
70 | }, |
71 | [pca9634] = { |
72 | .grppwm = 0xa, |
73 | .grpfreq = 0xb, |
74 | .ledout_base = 0xc, |
75 | .n_leds = 8, |
76 | }, |
77 | [pca9635] = { |
78 | .grppwm = 0x12, |
79 | .grpfreq = 0x13, |
80 | .ledout_base = 0x14, |
81 | .n_leds = 16, |
82 | }, |
83 | }; |
84 | |
85 | /* Total blink period in milliseconds */ |
86 | #define PCA963X_BLINK_PERIOD_MIN 42 |
87 | #define PCA963X_BLINK_PERIOD_MAX 10667 |
88 | |
89 | static const struct i2c_device_id pca963x_id[] = { |
90 | { "pca9632" , pca9633 }, |
91 | { "pca9633" , pca9633 }, |
92 | { "pca9634" , pca9634 }, |
93 | { "pca9635" , pca9635 }, |
94 | { } |
95 | }; |
96 | MODULE_DEVICE_TABLE(i2c, pca963x_id); |
97 | |
98 | struct pca963x; |
99 | |
100 | struct pca963x_led { |
101 | struct pca963x *chip; |
102 | struct led_classdev led_cdev; |
103 | int led_num; /* 0 .. 15 potentially */ |
104 | bool blinking; |
105 | u8 gdc; |
106 | u8 gfrq; |
107 | }; |
108 | |
109 | struct pca963x { |
110 | struct pca963x_chipdef *chipdef; |
111 | struct mutex mutex; |
112 | struct i2c_client *client; |
113 | unsigned long leds_on; |
114 | struct pca963x_led leds[]; |
115 | }; |
116 | |
117 | static int pca963x_brightness(struct pca963x_led *led, |
118 | enum led_brightness brightness) |
119 | { |
120 | struct i2c_client *client = led->chip->client; |
121 | struct pca963x_chipdef *chipdef = led->chip->chipdef; |
122 | u8 ledout_addr, ledout, mask, val; |
123 | int shift; |
124 | int ret; |
125 | |
126 | ledout_addr = chipdef->ledout_base + (led->led_num / 4); |
127 | shift = 2 * (led->led_num % 4); |
128 | mask = 0x3 << shift; |
129 | ledout = i2c_smbus_read_byte_data(client, command: ledout_addr); |
130 | |
131 | switch (brightness) { |
132 | case LED_FULL: |
133 | if (led->blinking) { |
134 | val = (ledout & ~mask) | (PCA963X_LED_GRP_PWM << shift); |
135 | ret = i2c_smbus_write_byte_data(client, |
136 | PCA963X_PWM_BASE + |
137 | led->led_num, |
138 | value: LED_FULL); |
139 | } else { |
140 | val = (ledout & ~mask) | (PCA963X_LED_ON << shift); |
141 | } |
142 | ret = i2c_smbus_write_byte_data(client, command: ledout_addr, value: val); |
143 | break; |
144 | case LED_OFF: |
145 | val = ledout & ~mask; |
146 | ret = i2c_smbus_write_byte_data(client, command: ledout_addr, value: val); |
147 | led->blinking = false; |
148 | break; |
149 | default: |
150 | ret = i2c_smbus_write_byte_data(client, |
151 | PCA963X_PWM_BASE + |
152 | led->led_num, |
153 | value: brightness); |
154 | if (ret < 0) |
155 | return ret; |
156 | |
157 | if (led->blinking) |
158 | val = (ledout & ~mask) | (PCA963X_LED_GRP_PWM << shift); |
159 | else |
160 | val = (ledout & ~mask) | (PCA963X_LED_PWM << shift); |
161 | |
162 | ret = i2c_smbus_write_byte_data(client, command: ledout_addr, value: val); |
163 | break; |
164 | } |
165 | |
166 | return ret; |
167 | } |
168 | |
169 | static void pca963x_blink(struct pca963x_led *led) |
170 | { |
171 | struct i2c_client *client = led->chip->client; |
172 | struct pca963x_chipdef *chipdef = led->chip->chipdef; |
173 | u8 ledout_addr, ledout, mask, val, mode2; |
174 | int shift; |
175 | |
176 | ledout_addr = chipdef->ledout_base + (led->led_num / 4); |
177 | shift = 2 * (led->led_num % 4); |
178 | mask = 0x3 << shift; |
179 | mode2 = i2c_smbus_read_byte_data(client, PCA963X_MODE2); |
180 | |
181 | i2c_smbus_write_byte_data(client, command: chipdef->grppwm, value: led->gdc); |
182 | |
183 | i2c_smbus_write_byte_data(client, command: chipdef->grpfreq, value: led->gfrq); |
184 | |
185 | if (!(mode2 & PCA963X_MODE2_DMBLNK)) |
186 | i2c_smbus_write_byte_data(client, PCA963X_MODE2, |
187 | value: mode2 | PCA963X_MODE2_DMBLNK); |
188 | |
189 | mutex_lock(&led->chip->mutex); |
190 | |
191 | ledout = i2c_smbus_read_byte_data(client, command: ledout_addr); |
192 | if ((ledout & mask) != (PCA963X_LED_GRP_PWM << shift)) { |
193 | val = (ledout & ~mask) | (PCA963X_LED_GRP_PWM << shift); |
194 | i2c_smbus_write_byte_data(client, command: ledout_addr, value: val); |
195 | } |
196 | |
197 | mutex_unlock(lock: &led->chip->mutex); |
198 | led->blinking = true; |
199 | } |
200 | |
201 | static int pca963x_power_state(struct pca963x_led *led) |
202 | { |
203 | struct i2c_client *client = led->chip->client; |
204 | unsigned long *leds_on = &led->chip->leds_on; |
205 | unsigned long cached_leds = *leds_on; |
206 | |
207 | if (led->led_cdev.brightness) |
208 | set_bit(nr: led->led_num, addr: leds_on); |
209 | else |
210 | clear_bit(nr: led->led_num, addr: leds_on); |
211 | |
212 | if (!(*leds_on) != !cached_leds) |
213 | return i2c_smbus_write_byte_data(client, PCA963X_MODE1, |
214 | value: *leds_on ? 0 : BIT(4)); |
215 | |
216 | return 0; |
217 | } |
218 | |
219 | static int pca963x_led_set(struct led_classdev *led_cdev, |
220 | enum led_brightness value) |
221 | { |
222 | struct pca963x_led *led; |
223 | int ret; |
224 | |
225 | led = container_of(led_cdev, struct pca963x_led, led_cdev); |
226 | |
227 | mutex_lock(&led->chip->mutex); |
228 | |
229 | ret = pca963x_brightness(led, brightness: value); |
230 | if (ret < 0) |
231 | goto unlock; |
232 | ret = pca963x_power_state(led); |
233 | |
234 | unlock: |
235 | mutex_unlock(lock: &led->chip->mutex); |
236 | return ret; |
237 | } |
238 | |
239 | static unsigned int pca963x_period_scale(struct pca963x_led *led, |
240 | unsigned int val) |
241 | { |
242 | unsigned int scaling = led->chip->chipdef->scaling; |
243 | |
244 | return scaling ? DIV_ROUND_CLOSEST(val * scaling, 1000) : val; |
245 | } |
246 | |
247 | static int pca963x_blink_set(struct led_classdev *led_cdev, |
248 | unsigned long *delay_on, unsigned long *delay_off) |
249 | { |
250 | unsigned long time_on, time_off, period; |
251 | struct pca963x_led *led; |
252 | u8 gdc, gfrq; |
253 | |
254 | led = container_of(led_cdev, struct pca963x_led, led_cdev); |
255 | |
256 | time_on = *delay_on; |
257 | time_off = *delay_off; |
258 | |
259 | /* If both zero, pick reasonable defaults of 500ms each */ |
260 | if (!time_on && !time_off) { |
261 | time_on = 500; |
262 | time_off = 500; |
263 | } |
264 | |
265 | period = pca963x_period_scale(led, val: time_on + time_off); |
266 | |
267 | /* If period not supported by hardware, default to someting sane. */ |
268 | if ((period < PCA963X_BLINK_PERIOD_MIN) || |
269 | (period > PCA963X_BLINK_PERIOD_MAX)) { |
270 | time_on = 500; |
271 | time_off = 500; |
272 | period = pca963x_period_scale(led, val: 1000); |
273 | } |
274 | |
275 | /* |
276 | * From manual: duty cycle = (GDC / 256) -> |
277 | * (time_on / period) = (GDC / 256) -> |
278 | * GDC = ((time_on * 256) / period) |
279 | */ |
280 | gdc = (pca963x_period_scale(led, val: time_on) * 256) / period; |
281 | |
282 | /* |
283 | * From manual: period = ((GFRQ + 1) / 24) in seconds. |
284 | * So, period (in ms) = (((GFRQ + 1) / 24) * 1000) -> |
285 | * GFRQ = ((period * 24 / 1000) - 1) |
286 | */ |
287 | gfrq = (period * 24 / 1000) - 1; |
288 | |
289 | led->gdc = gdc; |
290 | led->gfrq = gfrq; |
291 | |
292 | pca963x_blink(led); |
293 | led->led_cdev.brightness = LED_FULL; |
294 | pca963x_led_set(led_cdev, value: LED_FULL); |
295 | |
296 | *delay_on = time_on; |
297 | *delay_off = time_off; |
298 | |
299 | return 0; |
300 | } |
301 | |
302 | static int pca963x_register_leds(struct i2c_client *client, |
303 | struct pca963x *chip) |
304 | { |
305 | struct pca963x_chipdef *chipdef = chip->chipdef; |
306 | struct pca963x_led *led = chip->leds; |
307 | struct device *dev = &client->dev; |
308 | struct fwnode_handle *child; |
309 | bool hw_blink; |
310 | s32 mode2; |
311 | u32 reg; |
312 | int ret; |
313 | |
314 | if (device_property_read_u32(dev, propname: "nxp,period-scale" , |
315 | val: &chipdef->scaling)) |
316 | chipdef->scaling = 1000; |
317 | |
318 | hw_blink = device_property_read_bool(dev, propname: "nxp,hw-blink" ); |
319 | |
320 | mode2 = i2c_smbus_read_byte_data(client, PCA963X_MODE2); |
321 | if (mode2 < 0) |
322 | return mode2; |
323 | |
324 | /* default to open-drain unless totem pole (push-pull) is specified */ |
325 | if (device_property_read_bool(dev, propname: "nxp,totem-pole" )) |
326 | mode2 |= PCA963X_MODE2_OUTDRV; |
327 | else |
328 | mode2 &= ~PCA963X_MODE2_OUTDRV; |
329 | |
330 | /* default to non-inverted output, unless inverted is specified */ |
331 | if (device_property_read_bool(dev, propname: "nxp,inverted-out" )) |
332 | mode2 |= PCA963X_MODE2_INVRT; |
333 | else |
334 | mode2 &= ~PCA963X_MODE2_INVRT; |
335 | |
336 | ret = i2c_smbus_write_byte_data(client, PCA963X_MODE2, value: mode2); |
337 | if (ret < 0) |
338 | return ret; |
339 | |
340 | device_for_each_child_node(dev, child) { |
341 | struct led_init_data init_data = {}; |
342 | char default_label[32]; |
343 | |
344 | ret = fwnode_property_read_u32(fwnode: child, propname: "reg" , val: ®); |
345 | if (ret || reg >= chipdef->n_leds) { |
346 | dev_err(dev, "Invalid 'reg' property for node %pfw\n" , |
347 | child); |
348 | ret = -EINVAL; |
349 | goto err; |
350 | } |
351 | |
352 | led->led_num = reg; |
353 | led->chip = chip; |
354 | led->led_cdev.brightness_set_blocking = pca963x_led_set; |
355 | if (hw_blink) |
356 | led->led_cdev.blink_set = pca963x_blink_set; |
357 | led->blinking = false; |
358 | |
359 | init_data.fwnode = child; |
360 | /* for backwards compatibility */ |
361 | init_data.devicename = "pca963x" ; |
362 | snprintf(buf: default_label, size: sizeof(default_label), fmt: "%d:%.2x:%u" , |
363 | client->adapter->nr, client->addr, reg); |
364 | init_data.default_label = default_label; |
365 | |
366 | ret = devm_led_classdev_register_ext(parent: dev, led_cdev: &led->led_cdev, |
367 | init_data: &init_data); |
368 | if (ret) { |
369 | dev_err(dev, "Failed to register LED for node %pfw\n" , |
370 | child); |
371 | goto err; |
372 | } |
373 | |
374 | ++led; |
375 | } |
376 | |
377 | return 0; |
378 | err: |
379 | fwnode_handle_put(fwnode: child); |
380 | return ret; |
381 | } |
382 | |
383 | static const struct of_device_id of_pca963x_match[] = { |
384 | { .compatible = "nxp,pca9632" , }, |
385 | { .compatible = "nxp,pca9633" , }, |
386 | { .compatible = "nxp,pca9634" , }, |
387 | { .compatible = "nxp,pca9635" , }, |
388 | {}, |
389 | }; |
390 | MODULE_DEVICE_TABLE(of, of_pca963x_match); |
391 | |
392 | static int pca963x_probe(struct i2c_client *client) |
393 | { |
394 | const struct i2c_device_id *id = i2c_client_get_device_id(client); |
395 | struct device *dev = &client->dev; |
396 | struct pca963x_chipdef *chipdef; |
397 | struct pca963x *chip; |
398 | int i, count; |
399 | |
400 | chipdef = &pca963x_chipdefs[id->driver_data]; |
401 | |
402 | count = device_get_child_node_count(dev); |
403 | if (!count || count > chipdef->n_leds) { |
404 | dev_err(dev, "Node %pfw must define between 1 and %d LEDs\n" , |
405 | dev_fwnode(dev), chipdef->n_leds); |
406 | return -EINVAL; |
407 | } |
408 | |
409 | chip = devm_kzalloc(dev, struct_size(chip, leds, count), GFP_KERNEL); |
410 | if (!chip) |
411 | return -ENOMEM; |
412 | |
413 | i2c_set_clientdata(client, data: chip); |
414 | |
415 | mutex_init(&chip->mutex); |
416 | chip->chipdef = chipdef; |
417 | chip->client = client; |
418 | |
419 | /* Turn off LEDs by default*/ |
420 | for (i = 0; i < chipdef->n_leds / 4; i++) |
421 | i2c_smbus_write_byte_data(client, command: chipdef->ledout_base + i, value: 0x00); |
422 | |
423 | /* Disable LED all-call address, and power down initially */ |
424 | i2c_smbus_write_byte_data(client, PCA963X_MODE1, BIT(4)); |
425 | |
426 | return pca963x_register_leds(client, chip); |
427 | } |
428 | |
429 | static struct i2c_driver pca963x_driver = { |
430 | .driver = { |
431 | .name = "leds-pca963x" , |
432 | .of_match_table = of_pca963x_match, |
433 | }, |
434 | .probe = pca963x_probe, |
435 | .id_table = pca963x_id, |
436 | }; |
437 | |
438 | module_i2c_driver(pca963x_driver); |
439 | |
440 | MODULE_AUTHOR("Peter Meerwald <p.meerwald@bct-electronic.com>" ); |
441 | MODULE_DESCRIPTION("PCA963X LED driver" ); |
442 | MODULE_LICENSE("GPL v2" ); |
443 | |