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 */ |
fd6dd958 | 104 | bool blinking; |
8465b018 MG |
105 | u8 gdc; |
106 | u8 gfrq; | |
75cb2e1d PM |
107 | }; |
108 | ||
b5a3b44f MB |
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 | ||
5db85093 | 117 | static int pca963x_brightness(struct pca963x_led *led, |
39118499 | 118 | enum led_brightness brightness) |
75cb2e1d | 119 | { |
5db85093 MB |
120 | struct i2c_client *client = led->chip->client; |
121 | struct pca963x_chipdef *chipdef = led->chip->chipdef; | |
39118499 MB |
122 | u8 ledout_addr, ledout, mask, val; |
123 | int shift; | |
5029a2e3 | 124 | int ret; |
75cb2e1d | 125 | |
5db85093 MB |
126 | ledout_addr = chipdef->ledout_base + (led->led_num / 4); |
127 | shift = 2 * (led->led_num % 4); | |
39118499 MB |
128 | mask = 0x3 << shift; |
129 | ledout = i2c_smbus_read_byte_data(client, ledout_addr); | |
130 | ||
5029a2e3 | 131 | switch (brightness) { |
75cb2e1d | 132 | case LED_FULL: |
fd6dd958 BR |
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 | LED_FULL); | |
139 | } else { | |
140 | val = (ledout & ~mask) | (PCA963X_LED_ON << shift); | |
141 | } | |
39118499 | 142 | ret = i2c_smbus_write_byte_data(client, ledout_addr, val); |
75cb2e1d PM |
143 | break; |
144 | case LED_OFF: | |
39118499 MB |
145 | val = ledout & ~mask; |
146 | ret = i2c_smbus_write_byte_data(client, ledout_addr, val); | |
fd6dd958 | 147 | led->blinking = false; |
75cb2e1d PM |
148 | break; |
149 | default: | |
39118499 MB |
150 | ret = i2c_smbus_write_byte_data(client, |
151 | PCA963X_PWM_BASE + | |
5db85093 | 152 | led->led_num, |
39118499 | 153 | brightness); |
5029a2e3 | 154 | if (ret < 0) |
a8c170b0 | 155 | return ret; |
39118499 | 156 | |
fd6dd958 BR |
157 | if (led->blinking) |
158 | val = (ledout & ~mask) | (PCA963X_LED_GRP_PWM << shift); | |
159 | else | |
160 | val = (ledout & ~mask) | (PCA963X_LED_PWM << shift); | |
161 | ||
39118499 | 162 | ret = i2c_smbus_write_byte_data(client, ledout_addr, val); |
75cb2e1d PM |
163 | break; |
164 | } | |
a8c170b0 | 165 | |
5029a2e3 | 166 | return ret; |
75cb2e1d PM |
167 | } |
168 | ||
5db85093 | 169 | static void pca963x_blink(struct pca963x_led *led) |
8465b018 | 170 | { |
5db85093 MB |
171 | struct i2c_client *client = led->chip->client; |
172 | struct pca963x_chipdef *chipdef = led->chip->chipdef; | |
39118499 MB |
173 | u8 ledout_addr, ledout, mask, val, mode2; |
174 | int shift; | |
175 | ||
5db85093 MB |
176 | ledout_addr = chipdef->ledout_base + (led->led_num / 4); |
177 | shift = 2 * (led->led_num % 4); | |
39118499 MB |
178 | mask = 0x3 << shift; |
179 | mode2 = i2c_smbus_read_byte_data(client, PCA963X_MODE2); | |
8465b018 | 180 | |
5db85093 | 181 | i2c_smbus_write_byte_data(client, chipdef->grppwm, led->gdc); |
8465b018 | 182 | |
5db85093 | 183 | i2c_smbus_write_byte_data(client, chipdef->grpfreq, led->gfrq); |
8465b018 | 184 | |
56a1740c | 185 | if (!(mode2 & PCA963X_MODE2_DMBLNK)) |
39118499 MB |
186 | i2c_smbus_write_byte_data(client, PCA963X_MODE2, |
187 | mode2 | PCA963X_MODE2_DMBLNK); | |
8465b018 | 188 | |
5db85093 | 189 | mutex_lock(&led->chip->mutex); |
39118499 MB |
190 | |
191 | ledout = i2c_smbus_read_byte_data(client, 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, ledout_addr, val); | |
195 | } | |
196 | ||
5db85093 | 197 | mutex_unlock(&led->chip->mutex); |
fd6dd958 | 198 | led->blinking = true; |
8465b018 MG |
199 | } |
200 | ||
5db85093 | 201 | static int pca963x_power_state(struct pca963x_led *led) |
a8c170b0 | 202 | { |
5db85093 MB |
203 | struct i2c_client *client = led->chip->client; |
204 | unsigned long *leds_on = &led->chip->leds_on; | |
39118499 | 205 | unsigned long cached_leds = *leds_on; |
a8c170b0 | 206 | |
5db85093 MB |
207 | if (led->led_cdev.brightness) |
208 | set_bit(led->led_num, leds_on); | |
a8c170b0 | 209 | else |
5db85093 | 210 | clear_bit(led->led_num, leds_on); |
a8c170b0 MR |
211 | |
212 | if (!(*leds_on) != !cached_leds) | |
39118499 MB |
213 | return i2c_smbus_write_byte_data(client, PCA963X_MODE1, |
214 | *leds_on ? 0 : BIT(4)); | |
a8c170b0 MR |
215 | |
216 | return 0; | |
217 | } | |
218 | ||
5029a2e3 | 219 | static int pca963x_led_set(struct led_classdev *led_cdev, |
39118499 | 220 | enum led_brightness value) |
75cb2e1d | 221 | { |
5db85093 | 222 | struct pca963x_led *led; |
a8c170b0 | 223 | int ret; |
75cb2e1d | 224 | |
5db85093 | 225 | led = container_of(led_cdev, struct pca963x_led, led_cdev); |
75cb2e1d | 226 | |
5db85093 | 227 | mutex_lock(&led->chip->mutex); |
a8c170b0 | 228 | |
5db85093 | 229 | ret = pca963x_brightness(led, value); |
a8c170b0 MR |
230 | if (ret < 0) |
231 | goto unlock; | |
5db85093 | 232 | ret = pca963x_power_state(led); |
a8c170b0 MR |
233 | |
234 | unlock: | |
5db85093 | 235 | mutex_unlock(&led->chip->mutex); |
a8c170b0 | 236 | return ret; |
75cb2e1d PM |
237 | } |
238 | ||
5db85093 | 239 | static unsigned int pca963x_period_scale(struct pca963x_led *led, |
39118499 | 240 | unsigned int val) |
35c7d301 | 241 | { |
5db85093 | 242 | unsigned int scaling = led->chip->chipdef->scaling; |
35c7d301 MR |
243 | |
244 | return scaling ? DIV_ROUND_CLOSEST(val * scaling, 1000) : val; | |
245 | } | |
246 | ||
56a1740c | 247 | static int pca963x_blink_set(struct led_classdev *led_cdev, |
39118499 | 248 | unsigned long *delay_on, unsigned long *delay_off) |
8465b018 | 249 | { |
8465b018 | 250 | unsigned long time_on, time_off, period; |
5db85093 | 251 | struct pca963x_led *led; |
8465b018 MG |
252 | u8 gdc, gfrq; |
253 | ||
5db85093 | 254 | led = container_of(led_cdev, struct pca963x_led, led_cdev); |
8465b018 MG |
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 | ||
5db85093 | 265 | period = pca963x_period_scale(led, time_on + time_off); |
8465b018 MG |
266 | |
267 | /* If period not supported by hardware, default to someting sane. */ | |
56a1740c RRD |
268 | if ((period < PCA963X_BLINK_PERIOD_MIN) || |
269 | (period > PCA963X_BLINK_PERIOD_MAX)) { | |
8465b018 MG |
270 | time_on = 500; |
271 | time_off = 500; | |
5db85093 | 272 | period = pca963x_period_scale(led, 1000); |
8465b018 MG |
273 | } |
274 | ||
275 | /* | |
276 | * From manual: duty cycle = (GDC / 256) -> | |
277 | * (time_on / period) = (GDC / 256) -> | |
278 | * GDC = ((time_on * 256) / period) | |
279 | */ | |
5db85093 | 280 | gdc = (pca963x_period_scale(led, time_on) * 256) / period; |
8465b018 MG |
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 | ||
5db85093 MB |
289 | led->gdc = gdc; |
290 | led->gfrq = gfrq; | |
8465b018 | 291 | |
5db85093 | 292 | pca963x_blink(led); |
fd6dd958 BR |
293 | led->led_cdev.brightness = LED_FULL; |
294 | pca963x_led_set(led_cdev, LED_FULL); | |
8465b018 MG |
295 | |
296 | *delay_on = time_on; | |
297 | *delay_off = time_off; | |
298 | ||
299 | return 0; | |
300 | } | |
301 | ||
85fc8efe MB |
302 | static int pca963x_register_leds(struct i2c_client *client, |
303 | struct pca963x *chip) | |
81d22878 | 304 | { |
85fc8efe MB |
305 | struct pca963x_chipdef *chipdef = chip->chipdef; |
306 | struct pca963x_led *led = chip->leds; | |
307 | struct device *dev = &client->dev; | |
0b6034d8 | 308 | struct fwnode_handle *child; |
85fc8efe MB |
309 | bool hw_blink; |
310 | s32 mode2; | |
311 | u32 reg; | |
312 | int ret; | |
81d22878 | 313 | |
85fc8efe MB |
314 | if (device_property_read_u32(dev, "nxp,period-scale", |
315 | &chipdef->scaling)) | |
316 | chipdef->scaling = 1000; | |
81d22878 | 317 | |
85fc8efe | 318 | hw_blink = device_property_read_bool(dev, "nxp,hw-blink"); |
81d22878 | 319 | |
85fc8efe MB |
320 | mode2 = i2c_smbus_read_byte_data(client, PCA963X_MODE2); |
321 | if (mode2 < 0) | |
322 | return mode2; | |
81d22878 | 323 | |
85fc8efe MB |
324 | /* default to open-drain unless totem pole (push-pull) is specified */ |
325 | if (device_property_read_bool(dev, "nxp,totem-pole")) | |
326 | mode2 |= PCA963X_MODE2_OUTDRV; | |
327 | else | |
328 | mode2 &= ~PCA963X_MODE2_OUTDRV; | |
0b6034d8 | 329 | |
85fc8efe MB |
330 | /* default to non-inverted output, unless inverted is specified */ |
331 | if (device_property_read_bool(dev, "nxp,inverted-out")) | |
332 | mode2 |= PCA963X_MODE2_INVRT; | |
333 | else | |
334 | mode2 &= ~PCA963X_MODE2_INVRT; | |
0b6034d8 | 335 | |
85fc8efe MB |
336 | ret = i2c_smbus_write_byte_data(client, PCA963X_MODE2, mode2); |
337 | if (ret < 0) | |
338 | return ret; | |
0b6034d8 | 339 | |
85fc8efe | 340 | device_for_each_child_node(dev, child) { |
564ead12 MB |
341 | struct led_init_data init_data = {}; |
342 | char default_label[32]; | |
343 | ||
85fc8efe MB |
344 | ret = fwnode_property_read_u32(child, "reg", ®); |
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 | } | |
81d22878 | 351 | |
85fc8efe MB |
352 | led->led_num = reg; |
353 | led->chip = chip; | |
85fc8efe MB |
354 | led->led_cdev.brightness_set_blocking = pca963x_led_set; |
355 | if (hw_blink) | |
356 | led->led_cdev.blink_set = pca963x_blink_set; | |
4d163215 | 357 | led->blinking = false; |
8465b018 | 358 | |
564ead12 MB |
359 | init_data.fwnode = child; |
360 | /* for backwards compatibility */ | |
361 | init_data.devicename = "pca963x"; | |
362 | snprintf(default_label, sizeof(default_label), "%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(dev, &led->led_cdev, | |
367 | &init_data); | |
85fc8efe MB |
368 | if (ret) { |
369 | dev_err(dev, "Failed to register LED for node %pfw\n", | |
370 | child); | |
371 | goto err; | |
372 | } | |
35c7d301 | 373 | |
85fc8efe MB |
374 | ++led; |
375 | } | |
bb29b9cc | 376 | |
85fc8efe MB |
377 | return 0; |
378 | err: | |
379 | fwnode_handle_put(child); | |
380 | return ret; | |
81d22878 TL |
381 | } |
382 | ||
56a1740c | 383 | static const struct of_device_id of_pca963x_match[] = { |
af67384f RRD |
384 | { .compatible = "nxp,pca9632", }, |
385 | { .compatible = "nxp,pca9633", }, | |
386 | { .compatible = "nxp,pca9634", }, | |
3dfedb9d | 387 | { .compatible = "nxp,pca9635", }, |
81d22878 TL |
388 | {}, |
389 | }; | |
4d59ed85 | 390 | MODULE_DEVICE_TABLE(of, of_pca963x_match); |
81d22878 | 391 | |
2c6aaf88 | 392 | static int pca963x_probe(struct i2c_client *client) |
75cb2e1d | 393 | { |
2c6aaf88 | 394 | const struct i2c_device_id *id = i2c_client_get_device_id(client); |
39118499 | 395 | struct device *dev = &client->dev; |
fc0b1eca | 396 | struct pca963x_chipdef *chipdef; |
fc0b1eca | 397 | struct pca963x *chip; |
85fc8efe | 398 | int i, count; |
75cb2e1d | 399 | |
fc0b1eca | 400 | chipdef = &pca963x_chipdefs[id->driver_data]; |
75cb2e1d | 401 | |
85fc8efe MB |
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); | |
af67384f | 406 | return -EINVAL; |
75cb2e1d PM |
407 | } |
408 | ||
85fc8efe | 409 | chip = devm_kzalloc(dev, struct_size(chip, leds, count), GFP_KERNEL); |
fc0b1eca | 410 | if (!chip) |
a7d0e988 | 411 | return -ENOMEM; |
75cb2e1d | 412 | |
fc0b1eca | 413 | i2c_set_clientdata(client, chip); |
a7d0e988 | 414 | |
fc0b1eca MB |
415 | mutex_init(&chip->mutex); |
416 | chip->chipdef = chipdef; | |
417 | chip->client = client; | |
a7d0e988 RRD |
418 | |
419 | /* Turn off LEDs by default*/ | |
fc0b1eca MB |
420 | for (i = 0; i < chipdef->n_leds / 4; i++) |
421 | i2c_smbus_write_byte_data(client, chipdef->ledout_base + i, 0x00); | |
75cb2e1d | 422 | |
a8c170b0 MR |
423 | /* Disable LED all-call address, and power down initially */ |
424 | i2c_smbus_write_byte_data(client, PCA963X_MODE1, BIT(4)); | |
75cb2e1d | 425 | |
85fc8efe | 426 | return pca963x_register_leds(client, chip); |
75cb2e1d PM |
427 | } |
428 | ||
56a1740c | 429 | static struct i2c_driver pca963x_driver = { |
75cb2e1d | 430 | .driver = { |
56a1740c | 431 | .name = "leds-pca963x", |
0b6034d8 | 432 | .of_match_table = of_pca963x_match, |
75cb2e1d | 433 | }, |
2c6aaf88 | 434 | .probe_new = pca963x_probe, |
56a1740c | 435 | .id_table = pca963x_id, |
75cb2e1d PM |
436 | }; |
437 | ||
56a1740c | 438 | module_i2c_driver(pca963x_driver); |
75cb2e1d PM |
439 | |
440 | MODULE_AUTHOR("Peter Meerwald <p.meerwald@bct-electronic.com>"); | |
56a1740c | 441 | MODULE_DESCRIPTION("PCA963X LED driver"); |
75cb2e1d | 442 | MODULE_LICENSE("GPL v2"); |