1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 2011 bct electronic GmbH
4 * Copyright 2013 Qtechnology/AS
6 * Author: Peter Meerwald <p.meerwald@bct-electronic.com>
7 * Author: Ricardo Ribalda <ribalda@kernel.org>
9 * Based on leds-pca955x.c
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.)
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.
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>
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 */
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 */
46 #define PCA963X_MODE1 0x00
47 #define PCA963X_MODE2 0x01
48 #define PCA963X_PWM_BASE 0x02
56 struct pca963x_chipdef
{
64 static struct pca963x_chipdef pca963x_chipdefs
[] = {
85 /* Total blink period in milliseconds */
86 #define PCA963X_BLINK_PERIOD_MIN 42
87 #define PCA963X_BLINK_PERIOD_MAX 10667
89 static const struct i2c_device_id pca963x_id
[] = {
90 { "pca9632", pca9633
},
91 { "pca9633", pca9633
},
92 { "pca9634", pca9634
},
93 { "pca9635", pca9635
},
96 MODULE_DEVICE_TABLE(i2c
, pca963x_id
);
101 struct pca963x
*chip
;
102 struct led_classdev led_cdev
;
103 int led_num
; /* 0 .. 15 potentially */
109 struct pca963x_chipdef
*chipdef
;
111 struct i2c_client
*client
;
112 unsigned long leds_on
;
113 struct pca963x_led leds
[];
116 static int pca963x_brightness(struct pca963x_led
*led
,
117 enum led_brightness brightness
)
119 struct i2c_client
*client
= led
->chip
->client
;
120 struct pca963x_chipdef
*chipdef
= led
->chip
->chipdef
;
121 u8 ledout_addr
, ledout
, mask
, val
;
125 ledout_addr
= chipdef
->ledout_base
+ (led
->led_num
/ 4);
126 shift
= 2 * (led
->led_num
% 4);
128 ledout
= i2c_smbus_read_byte_data(client
, ledout_addr
);
130 switch (brightness
) {
132 val
= (ledout
& ~mask
) | (PCA963X_LED_ON
<< shift
);
133 ret
= i2c_smbus_write_byte_data(client
, ledout_addr
, val
);
136 val
= ledout
& ~mask
;
137 ret
= i2c_smbus_write_byte_data(client
, ledout_addr
, val
);
140 ret
= i2c_smbus_write_byte_data(client
,
147 val
= (ledout
& ~mask
) | (PCA963X_LED_PWM
<< shift
);
148 ret
= i2c_smbus_write_byte_data(client
, ledout_addr
, val
);
155 static void pca963x_blink(struct pca963x_led
*led
)
157 struct i2c_client
*client
= led
->chip
->client
;
158 struct pca963x_chipdef
*chipdef
= led
->chip
->chipdef
;
159 u8 ledout_addr
, ledout
, mask
, val
, mode2
;
162 ledout_addr
= chipdef
->ledout_base
+ (led
->led_num
/ 4);
163 shift
= 2 * (led
->led_num
% 4);
165 mode2
= i2c_smbus_read_byte_data(client
, PCA963X_MODE2
);
167 i2c_smbus_write_byte_data(client
, chipdef
->grppwm
, led
->gdc
);
169 i2c_smbus_write_byte_data(client
, chipdef
->grpfreq
, led
->gfrq
);
171 if (!(mode2
& PCA963X_MODE2_DMBLNK
))
172 i2c_smbus_write_byte_data(client
, PCA963X_MODE2
,
173 mode2
| PCA963X_MODE2_DMBLNK
);
175 mutex_lock(&led
->chip
->mutex
);
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
);
183 mutex_unlock(&led
->chip
->mutex
);
186 static int pca963x_power_state(struct pca963x_led
*led
)
188 struct i2c_client
*client
= led
->chip
->client
;
189 unsigned long *leds_on
= &led
->chip
->leds_on
;
190 unsigned long cached_leds
= *leds_on
;
192 if (led
->led_cdev
.brightness
)
193 set_bit(led
->led_num
, leds_on
);
195 clear_bit(led
->led_num
, leds_on
);
197 if (!(*leds_on
) != !cached_leds
)
198 return i2c_smbus_write_byte_data(client
, PCA963X_MODE1
,
199 *leds_on
? 0 : BIT(4));
204 static int pca963x_led_set(struct led_classdev
*led_cdev
,
205 enum led_brightness value
)
207 struct pca963x_led
*led
;
210 led
= container_of(led_cdev
, struct pca963x_led
, led_cdev
);
212 mutex_lock(&led
->chip
->mutex
);
214 ret
= pca963x_brightness(led
, value
);
217 ret
= pca963x_power_state(led
);
220 mutex_unlock(&led
->chip
->mutex
);
224 static unsigned int pca963x_period_scale(struct pca963x_led
*led
,
227 unsigned int scaling
= led
->chip
->chipdef
->scaling
;
229 return scaling
? DIV_ROUND_CLOSEST(val
* scaling
, 1000) : val
;
232 static int pca963x_blink_set(struct led_classdev
*led_cdev
,
233 unsigned long *delay_on
, unsigned long *delay_off
)
235 unsigned long time_on
, time_off
, period
;
236 struct pca963x_led
*led
;
239 led
= container_of(led_cdev
, struct pca963x_led
, led_cdev
);
242 time_off
= *delay_off
;
244 /* If both zero, pick reasonable defaults of 500ms each */
245 if (!time_on
&& !time_off
) {
250 period
= pca963x_period_scale(led
, time_on
+ time_off
);
252 /* If period not supported by hardware, default to someting sane. */
253 if ((period
< PCA963X_BLINK_PERIOD_MIN
) ||
254 (period
> PCA963X_BLINK_PERIOD_MAX
)) {
257 period
= pca963x_period_scale(led
, 1000);
261 * From manual: duty cycle = (GDC / 256) ->
262 * (time_on / period) = (GDC / 256) ->
263 * GDC = ((time_on * 256) / period)
265 gdc
= (pca963x_period_scale(led
, time_on
) * 256) / period
;
268 * From manual: period = ((GFRQ + 1) / 24) in seconds.
269 * So, period (in ms) = (((GFRQ + 1) / 24) * 1000) ->
270 * GFRQ = ((period * 24 / 1000) - 1)
272 gfrq
= (period
* 24 / 1000) - 1;
280 *delay_off
= time_off
;
285 static int pca963x_register_leds(struct i2c_client
*client
,
286 struct pca963x
*chip
)
288 struct pca963x_chipdef
*chipdef
= chip
->chipdef
;
289 struct pca963x_led
*led
= chip
->leds
;
290 struct device
*dev
= &client
->dev
;
291 struct fwnode_handle
*child
;
297 if (device_property_read_u32(dev
, "nxp,period-scale",
299 chipdef
->scaling
= 1000;
301 hw_blink
= device_property_read_bool(dev
, "nxp,hw-blink");
303 mode2
= i2c_smbus_read_byte_data(client
, PCA963X_MODE2
);
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
;
311 mode2
&= ~PCA963X_MODE2_OUTDRV
;
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
;
317 mode2
&= ~PCA963X_MODE2_INVRT
;
319 ret
= i2c_smbus_write_byte_data(client
, PCA963X_MODE2
, mode2
);
323 device_for_each_child_node(dev
, child
) {
324 struct led_init_data init_data
= {};
325 char default_label
[32];
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",
337 led
->led_cdev
.brightness_set_blocking
= pca963x_led_set
;
339 led
->led_cdev
.blink_set
= pca963x_blink_set
;
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
;
348 ret
= devm_led_classdev_register_ext(dev
, &led
->led_cdev
,
351 dev_err(dev
, "Failed to register LED for node %pfw\n",
361 fwnode_handle_put(child
);
365 static const struct of_device_id of_pca963x_match
[] = {
366 { .compatible
= "nxp,pca9632", },
367 { .compatible
= "nxp,pca9633", },
368 { .compatible
= "nxp,pca9634", },
369 { .compatible
= "nxp,pca9635", },
372 MODULE_DEVICE_TABLE(of
, of_pca963x_match
);
374 static int pca963x_probe(struct i2c_client
*client
,
375 const struct i2c_device_id
*id
)
377 struct device
*dev
= &client
->dev
;
378 struct pca963x_chipdef
*chipdef
;
379 struct pca963x
*chip
;
382 chipdef
= &pca963x_chipdefs
[id
->driver_data
];
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
);
391 chip
= devm_kzalloc(dev
, struct_size(chip
, leds
, count
), GFP_KERNEL
);
395 i2c_set_clientdata(client
, chip
);
397 mutex_init(&chip
->mutex
);
398 chip
->chipdef
= chipdef
;
399 chip
->client
= client
;
401 /* Turn off LEDs by default*/
402 for (i
= 0; i
< chipdef
->n_leds
/ 4; i
++)
403 i2c_smbus_write_byte_data(client
, chipdef
->ledout_base
+ i
, 0x00);
405 /* Disable LED all-call address, and power down initially */
406 i2c_smbus_write_byte_data(client
, PCA963X_MODE1
, BIT(4));
408 return pca963x_register_leds(client
, chip
);
411 static struct i2c_driver pca963x_driver
= {
413 .name
= "leds-pca963x",
414 .of_match_table
= of_pca963x_match
,
416 .probe
= pca963x_probe
,
417 .id_table
= pca963x_id
,
420 module_i2c_driver(pca963x_driver
);
422 MODULE_AUTHOR("Peter Meerwald <p.meerwald@bct-electronic.com>");
423 MODULE_DESCRIPTION("PCA963X LED driver");
424 MODULE_LICENSE("GPL v2");