xref: /openbmc/linux/drivers/leds/leds-pca963x.c (revision 55eb9a6c)
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 	u8 gdc;
105 	u8 gfrq;
106 };
107 
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 
116 static int pca963x_brightness(struct pca963x_led *led,
117 			      enum led_brightness brightness)
118 {
119 	struct i2c_client *client = led->chip->client;
120 	struct pca963x_chipdef *chipdef = led->chip->chipdef;
121 	u8 ledout_addr, ledout, mask, val;
122 	int shift;
123 	int ret;
124 
125 	ledout_addr = chipdef->ledout_base + (led->led_num / 4);
126 	shift = 2 * (led->led_num % 4);
127 	mask = 0x3 << shift;
128 	ledout = i2c_smbus_read_byte_data(client, ledout_addr);
129 
130 	switch (brightness) {
131 	case LED_FULL:
132 		val = (ledout & ~mask) | (PCA963X_LED_ON << shift);
133 		ret = i2c_smbus_write_byte_data(client, ledout_addr, val);
134 		break;
135 	case LED_OFF:
136 		val = ledout & ~mask;
137 		ret = i2c_smbus_write_byte_data(client, ledout_addr, val);
138 		break;
139 	default:
140 		ret = i2c_smbus_write_byte_data(client,
141 						PCA963X_PWM_BASE +
142 						led->led_num,
143 						brightness);
144 		if (ret < 0)
145 			return ret;
146 
147 		val = (ledout & ~mask) | (PCA963X_LED_PWM << shift);
148 		ret = i2c_smbus_write_byte_data(client, ledout_addr, val);
149 		break;
150 	}
151 
152 	return ret;
153 }
154 
155 static void pca963x_blink(struct pca963x_led *led)
156 {
157 	struct i2c_client *client = led->chip->client;
158 	struct pca963x_chipdef *chipdef = led->chip->chipdef;
159 	u8 ledout_addr, ledout, mask, val, mode2;
160 	int shift;
161 
162 	ledout_addr = chipdef->ledout_base + (led->led_num / 4);
163 	shift = 2 * (led->led_num % 4);
164 	mask = 0x3 << shift;
165 	mode2 = i2c_smbus_read_byte_data(client, PCA963X_MODE2);
166 
167 	i2c_smbus_write_byte_data(client, chipdef->grppwm, led->gdc);
168 
169 	i2c_smbus_write_byte_data(client, chipdef->grpfreq, led->gfrq);
170 
171 	if (!(mode2 & PCA963X_MODE2_DMBLNK))
172 		i2c_smbus_write_byte_data(client, PCA963X_MODE2,
173 					  mode2 | PCA963X_MODE2_DMBLNK);
174 
175 	mutex_lock(&led->chip->mutex);
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 
183 	mutex_unlock(&led->chip->mutex);
184 }
185 
186 static int pca963x_power_state(struct pca963x_led *led)
187 {
188 	struct i2c_client *client = led->chip->client;
189 	unsigned long *leds_on = &led->chip->leds_on;
190 	unsigned long cached_leds = *leds_on;
191 
192 	if (led->led_cdev.brightness)
193 		set_bit(led->led_num, leds_on);
194 	else
195 		clear_bit(led->led_num, leds_on);
196 
197 	if (!(*leds_on) != !cached_leds)
198 		return i2c_smbus_write_byte_data(client, PCA963X_MODE1,
199 						 *leds_on ? 0 : BIT(4));
200 
201 	return 0;
202 }
203 
204 static int pca963x_led_set(struct led_classdev *led_cdev,
205 			   enum led_brightness value)
206 {
207 	struct pca963x_led *led;
208 	int ret;
209 
210 	led = container_of(led_cdev, struct pca963x_led, led_cdev);
211 
212 	mutex_lock(&led->chip->mutex);
213 
214 	ret = pca963x_brightness(led, value);
215 	if (ret < 0)
216 		goto unlock;
217 	ret = pca963x_power_state(led);
218 
219 unlock:
220 	mutex_unlock(&led->chip->mutex);
221 	return ret;
222 }
223 
224 static unsigned int pca963x_period_scale(struct pca963x_led *led,
225 					 unsigned int val)
226 {
227 	unsigned int scaling = led->chip->chipdef->scaling;
228 
229 	return scaling ? DIV_ROUND_CLOSEST(val * scaling, 1000) : val;
230 }
231 
232 static int pca963x_blink_set(struct led_classdev *led_cdev,
233 			     unsigned long *delay_on, unsigned long *delay_off)
234 {
235 	unsigned long time_on, time_off, period;
236 	struct pca963x_led *led;
237 	u8 gdc, gfrq;
238 
239 	led = container_of(led_cdev, struct pca963x_led, led_cdev);
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 
250 	period = pca963x_period_scale(led, time_on + time_off);
251 
252 	/* If period not supported by hardware, default to someting sane. */
253 	if ((period < PCA963X_BLINK_PERIOD_MIN) ||
254 	    (period > PCA963X_BLINK_PERIOD_MAX)) {
255 		time_on = 500;
256 		time_off = 500;
257 		period = pca963x_period_scale(led, 1000);
258 	}
259 
260 	/*
261 	 * From manual: duty cycle = (GDC / 256) ->
262 	 *	(time_on / period) = (GDC / 256) ->
263 	 *		GDC = ((time_on * 256) / period)
264 	 */
265 	gdc = (pca963x_period_scale(led, time_on) * 256) / period;
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 
274 	led->gdc = gdc;
275 	led->gfrq = gfrq;
276 
277 	pca963x_blink(led);
278 
279 	*delay_on = time_on;
280 	*delay_off = time_off;
281 
282 	return 0;
283 }
284 
285 static int pca963x_register_leds(struct i2c_client *client,
286 				 struct pca963x *chip)
287 {
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;
292 	bool hw_blink;
293 	s32 mode2;
294 	u32 reg;
295 	int ret;
296 
297 	if (device_property_read_u32(dev, "nxp,period-scale",
298 				     &chipdef->scaling))
299 		chipdef->scaling = 1000;
300 
301 	hw_blink = device_property_read_bool(dev, "nxp,hw-blink");
302 
303 	mode2 = i2c_smbus_read_byte_data(client, PCA963X_MODE2);
304 	if (mode2 < 0)
305 		return mode2;
306 
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;
312 
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;
318 
319 	ret = i2c_smbus_write_byte_data(client, PCA963X_MODE2, mode2);
320 	if (ret < 0)
321 		return ret;
322 
323 	device_for_each_child_node(dev, child) {
324 		struct led_init_data init_data = {};
325 		char default_label[32];
326 
327 		ret = fwnode_property_read_u32(child, "reg", &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 		}
334 
335 		led->led_num = reg;
336 		led->chip = chip;
337 		led->led_cdev.brightness_set_blocking = pca963x_led_set;
338 		if (hw_blink)
339 			led->led_cdev.blink_set = pca963x_blink_set;
340 
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);
350 		if (ret) {
351 			dev_err(dev, "Failed to register LED for node %pfw\n",
352 				child);
353 			goto err;
354 		}
355 
356 		++led;
357 	}
358 
359 	return 0;
360 err:
361 	fwnode_handle_put(child);
362 	return ret;
363 }
364 
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", },
370 	{},
371 };
372 MODULE_DEVICE_TABLE(of, of_pca963x_match);
373 
374 static int pca963x_probe(struct i2c_client *client,
375 			 const struct i2c_device_id *id)
376 {
377 	struct device *dev = &client->dev;
378 	struct pca963x_chipdef *chipdef;
379 	struct pca963x *chip;
380 	int i, count;
381 
382 	chipdef = &pca963x_chipdefs[id->driver_data];
383 
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);
388 		return -EINVAL;
389 	}
390 
391 	chip = devm_kzalloc(dev, struct_size(chip, leds, count), GFP_KERNEL);
392 	if (!chip)
393 		return -ENOMEM;
394 
395 	i2c_set_clientdata(client, chip);
396 
397 	mutex_init(&chip->mutex);
398 	chip->chipdef = chipdef;
399 	chip->client = client;
400 
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);
404 
405 	/* Disable LED all-call address, and power down initially */
406 	i2c_smbus_write_byte_data(client, PCA963X_MODE1, BIT(4));
407 
408 	return pca963x_register_leds(client, chip);
409 }
410 
411 static struct i2c_driver pca963x_driver = {
412 	.driver = {
413 		.name	= "leds-pca963x",
414 		.of_match_table = of_pca963x_match,
415 	},
416 	.probe	= pca963x_probe,
417 	.id_table = pca963x_id,
418 };
419 
420 module_i2c_driver(pca963x_driver);
421 
422 MODULE_AUTHOR("Peter Meerwald <p.meerwald@bct-electronic.com>");
423 MODULE_DESCRIPTION("PCA963X LED driver");
424 MODULE_LICENSE("GPL v2");
425