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