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