leds-pca9532.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * pca9532.c - 16-bit Led dimmer
  4 *
  5 * Copyright (C) 2011 Jan Weitzel
  6 * Copyright (C) 2008 Riku Voipio
  7 *
  8 * Datasheet: http://www.nxp.com/documents/data_sheet/PCA9532.pdf
  9 */
 10
 11#include <linux/module.h>
 12#include <linux/i2c.h>
 13#include <linux/slab.h>
 14#include <linux/leds.h>
 15#include <linux/input.h>
 16#include <linux/mutex.h>
 17#include <linux/workqueue.h>
 18#include <linux/leds-pca9532.h>
 19#include <linux/gpio/driver.h>
 20#include <linux/of.h>
 21
 22/* m =  num_leds*/
 23#define PCA9532_REG_INPUT(i)	((i) >> 3)
 24#define PCA9532_REG_OFFSET(m)	((m) >> 4)
 25#define PCA9532_REG_PSC(m, i)	(PCA9532_REG_OFFSET(m) + 0x1 + (i) * 2)
 26#define PCA9532_REG_PWM(m, i)	(PCA9532_REG_OFFSET(m) + 0x2 + (i) * 2)
 27#define LED_REG(m, led)		(PCA9532_REG_OFFSET(m) + 0x5 + (led >> 2))
 28#define LED_NUM(led)		(led & 0x3)
 29#define LED_SHIFT(led)		(LED_NUM(led) * 2)
 30#define LED_MASK(led)		(0x3 << LED_SHIFT(led))
 31
 32#define PCA9532_PWM_PERIOD_DIV	152
 33#define PCA9532_PWM_DUTY_DIV	256
 34
 35#define ldev_to_led(c)       container_of(c, struct pca9532_led, ldev)
 36
 37struct pca9532_chip_info {
 38	u8	num_leds;
 39};
 40
 41struct pca9532_data {
 42	struct i2c_client *client;
 43	struct pca9532_led leds[16];
 44	struct mutex update_lock;
 45	struct input_dev *idev;
 46	struct work_struct work;
 47#ifdef CONFIG_LEDS_PCA9532_GPIO
 48	struct gpio_chip gpio;
 49#endif
 50	const struct pca9532_chip_info *chip_info;
 51
 52#define PCA9532_PWM_ID_0	0
 53#define PCA9532_PWM_ID_1	1
 54	u8 pwm[2];
 55	u8 psc[2];
 56	bool hw_blink;
 57};
 58
 59static int pca9532_probe(struct i2c_client *client);
 60static void pca9532_remove(struct i2c_client *client);
 61
 62enum {
 63	pca9530,
 64	pca9531,
 65	pca9532,
 66	pca9533,
 67};
 68
 69static const struct i2c_device_id pca9532_id[] = {
 70	{ "pca9530", pca9530 },
 71	{ "pca9531", pca9531 },
 72	{ "pca9532", pca9532 },
 73	{ "pca9533", pca9533 },
 74	{ }
 75};
 76
 77MODULE_DEVICE_TABLE(i2c, pca9532_id);
 78
 79static const struct pca9532_chip_info pca9532_chip_info_tbl[] = {
 80	[pca9530] = {
 81		.num_leds = 2,
 82	},
 83	[pca9531] = {
 84		.num_leds = 8,
 85	},
 86	[pca9532] = {
 87		.num_leds = 16,
 88	},
 89	[pca9533] = {
 90		.num_leds = 4,
 91	},
 92};
 93
 94#ifdef CONFIG_OF
 95static const struct of_device_id of_pca9532_leds_match[] = {
 96	{ .compatible = "nxp,pca9530", .data = (void *)pca9530 },
 97	{ .compatible = "nxp,pca9531", .data = (void *)pca9531 },
 98	{ .compatible = "nxp,pca9532", .data = (void *)pca9532 },
 99	{ .compatible = "nxp,pca9533", .data = (void *)pca9533 },
100	{},
101};
102
103MODULE_DEVICE_TABLE(of, of_pca9532_leds_match);
104#endif
105
106static struct i2c_driver pca9532_driver = {
107	.driver = {
108		.name = "leds-pca953x",
109		.of_match_table = of_match_ptr(of_pca9532_leds_match),
110	},
111	.probe = pca9532_probe,
112	.remove = pca9532_remove,
113	.id_table = pca9532_id,
114};
115
116/* We have two pwm/blinkers, but 16 possible leds to drive. Additionally,
117 * the clever Thecus people are using one pwm to drive the beeper. So,
118 * as a compromise we average one pwm to the values requested by all
119 * leds that are not ON/OFF.
120 * */
121static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,
122	enum led_brightness value)
123{
124	int a = 0, b = 0, i = 0;
125	struct pca9532_data *data = i2c_get_clientdata(client);
126	for (i = 0; i < data->chip_info->num_leds; i++) {
127		if (data->leds[i].type == PCA9532_TYPE_LED &&
128			data->leds[i].state == PCA9532_PWM0+pwm) {
129				a++;
130				b += data->leds[i].ldev.brightness;
131		}
132	}
133	if (a == 0) {
134		dev_err(&client->dev,
135		"fear of division by zero %d/%d, wanted %d\n",
136			b, a, value);
137		return -EINVAL;
138	}
139	b = b/a;
140	if (b > 0xFF)
141		return -EINVAL;
142	data->pwm[pwm] = b;
143	data->psc[pwm] = blink;
144	return 0;
145}
146
147static int pca9532_setpwm(struct i2c_client *client, int pwm)
148{
149	struct pca9532_data *data = i2c_get_clientdata(client);
150	u8 maxleds = data->chip_info->num_leds;
151
152	mutex_lock(&data->update_lock);
153	i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm),
154		data->pwm[pwm]);
155	i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm),
156		data->psc[pwm]);
157	mutex_unlock(&data->update_lock);
158	return 0;
159}
160
161/* Set LED routing */
162static void pca9532_setled(struct pca9532_led *led)
163{
164	struct i2c_client *client = led->client;
165	struct pca9532_data *data = i2c_get_clientdata(client);
166	u8 maxleds = data->chip_info->num_leds;
167	char reg;
168
169	mutex_lock(&data->update_lock);
170	reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
171	/* zero led bits */
172	reg = reg & ~LED_MASK(led->id);
173	/* set the new value */
174	reg = reg | (led->state << LED_SHIFT(led->id));
175	i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg);
176	mutex_unlock(&data->update_lock);
177}
178
179static int pca9532_set_brightness(struct led_classdev *led_cdev,
180	enum led_brightness value)
181{
182	int err = 0;
183	struct pca9532_led *led = ldev_to_led(led_cdev);
184
185	if (value == LED_OFF)
186		led->state = PCA9532_OFF;
187	else if (value == LED_FULL)
188		led->state = PCA9532_ON;
189	else {
190		led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
191		err = pca9532_calcpwm(led->client, PCA9532_PWM_ID_0, 0, value);
192		if (err)
193			return err;
194	}
195	if (led->state == PCA9532_PWM0)
196		pca9532_setpwm(led->client, PCA9532_PWM_ID_0);
197	pca9532_setled(led);
198	return err;
199}
200
201static int pca9532_update_hw_blink(struct pca9532_led *led,
202				   unsigned long delay_on, unsigned long delay_off)
203{
204	struct pca9532_data *data = i2c_get_clientdata(led->client);
205	unsigned int psc;
206	int i;
207
208	/* Look for others LEDs that already use PWM1 */
209	for (i = 0; i < data->chip_info->num_leds; i++) {
210		struct pca9532_led *other = &data->leds[i];
211
212		if (other == led)
213			continue;
214
215		if (other->state == PCA9532_PWM1) {
216			if (other->ldev.blink_delay_on != delay_on ||
217			    other->ldev.blink_delay_off != delay_off) {
218				/* HW can handle only one blink configuration at a time */
219				return -EINVAL;
220			}
221		}
222	}
223
224	psc = ((delay_on + delay_off) * PCA9532_PWM_PERIOD_DIV - 1) / 1000;
225	if (psc > U8_MAX) {
226		/* Blink period too long to be handled by hardware */
227		return -EINVAL;
228	}
229
230	led->state = PCA9532_PWM1;
231	data->psc[PCA9532_PWM_ID_1] = psc;
232	data->pwm[PCA9532_PWM_ID_1] = (delay_on * PCA9532_PWM_DUTY_DIV) / (delay_on + delay_off);
233
234	return pca9532_setpwm(data->client, PCA9532_PWM_ID_1);
235}
236
237static int pca9532_set_blink(struct led_classdev *led_cdev,
238	unsigned long *delay_on, unsigned long *delay_off)
239{
240	struct pca9532_led *led = ldev_to_led(led_cdev);
241	struct i2c_client *client = led->client;
242	struct pca9532_data *data = i2c_get_clientdata(client);
243	int err;
244
245	if (!data->hw_blink)
246		return -EINVAL;
247
248	if (*delay_on == 0 && *delay_off == 0) {
249		/* led subsystem ask us for a blink rate */
250		*delay_on = 500;
251		*delay_off = 500;
252	}
253
254	err = pca9532_update_hw_blink(led, *delay_on, *delay_off);
255	if (err)
256		return err;
257
258	pca9532_setled(led);
259
260	return 0;
261}
262
263static int pca9532_event(struct input_dev *dev, unsigned int type,
264	unsigned int code, int value)
265{
266	struct pca9532_data *data = input_get_drvdata(dev);
267
268	if (!(type == EV_SND && (code == SND_BELL || code == SND_TONE)))
269		return -1;
270
271	/* XXX: allow different kind of beeps with psc/pwm modifications */
272	if (value > 1 && value < 32767)
273		data->pwm[PCA9532_PWM_ID_1] = 127;
274	else
275		data->pwm[PCA9532_PWM_ID_1] = 0;
276
277	schedule_work(&data->work);
278
279	return 0;
280}
281
282static void pca9532_input_work(struct work_struct *work)
283{
284	struct pca9532_data *data =
285		container_of(work, struct pca9532_data, work);
286	u8 maxleds = data->chip_info->num_leds;
287
288	mutex_lock(&data->update_lock);
289	i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(maxleds, 1),
290		data->pwm[PCA9532_PWM_ID_1]);
291	mutex_unlock(&data->update_lock);
292}
293
294static enum pca9532_state pca9532_getled(struct pca9532_led *led)
295{
296	struct i2c_client *client = led->client;
297	struct pca9532_data *data = i2c_get_clientdata(client);
298	u8 maxleds = data->chip_info->num_leds;
299	char reg;
300	enum pca9532_state ret;
301
302	mutex_lock(&data->update_lock);
303	reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
304	ret = (reg & LED_MASK(led->id)) >> LED_SHIFT(led->id);
305	mutex_unlock(&data->update_lock);
306	return ret;
307}
308
309#ifdef CONFIG_LEDS_PCA9532_GPIO
310static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset)
311{
312	struct pca9532_data *data = gpiochip_get_data(gc);
313	struct pca9532_led *led = &data->leds[offset];
314
315	if (led->type == PCA9532_TYPE_GPIO)
316		return 0;
317
318	return -EBUSY;
319}
320
321static int pca9532_gpio_set_value(struct gpio_chip *gc, unsigned int offset,
322				  int val)
323{
324	struct pca9532_data *data = gpiochip_get_data(gc);
325	struct pca9532_led *led = &data->leds[offset];
326
327	if (val)
328		led->state = PCA9532_ON;
329	else
330		led->state = PCA9532_OFF;
331
332	pca9532_setled(led);
333
334	return 0;
335}
336
337static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset)
338{
339	struct pca9532_data *data = gpiochip_get_data(gc);
340	unsigned char reg;
341
342	reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset));
343
344	return !!(reg & (1 << (offset % 8)));
345}
346
347static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
348{
349	/* To use as input ensure pin is not driven */
350	pca9532_gpio_set_value(gc, offset, 0);
351
352	return 0;
353}
354
355static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val)
356{
357	return pca9532_gpio_set_value(gc, offset, val);
358}
359#endif /* CONFIG_LEDS_PCA9532_GPIO */
360
361static void pca9532_destroy_devices(struct pca9532_data *data, int n_devs)
362{
363	int i = n_devs;
364
365	while (--i >= 0) {
366		switch (data->leds[i].type) {
367		case PCA9532_TYPE_NONE:
368		case PCA9532_TYPE_GPIO:
369			break;
370		case PCA9532_TYPE_LED:
371			led_classdev_unregister(&data->leds[i].ldev);
372			break;
373		case PCA9532_TYPE_N2100_BEEP:
374			if (data->idev != NULL) {
375				cancel_work_sync(&data->work);
376				data->idev = NULL;
377			}
378			break;
379		}
380	}
381
382#ifdef CONFIG_LEDS_PCA9532_GPIO
383	if (data->gpio.parent)
384		gpiochip_remove(&data->gpio);
385#endif
386}
387
388static int pca9532_configure(struct i2c_client *client,
389	struct pca9532_data *data, struct pca9532_platform_data *pdata)
390{
391	int i, err = 0;
392	int gpios = 0;
393	u8 maxleds = data->chip_info->num_leds;
394
395	for (i = 0; i < 2; i++)	{
396		data->pwm[i] = pdata->pwm[i];
397		data->psc[i] = pdata->psc[i];
398		i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i),
399			data->pwm[i]);
400		i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i),
401			data->psc[i]);
402	}
403
404	data->hw_blink = true;
405	for (i = 0; i < data->chip_info->num_leds; i++) {
406		struct pca9532_led *led = &data->leds[i];
407		struct pca9532_led *pled = &pdata->leds[i];
408		led->client = client;
409		led->id = i;
410		led->type = pled->type;
411		switch (led->type) {
412		case PCA9532_TYPE_NONE:
413			break;
414		case PCA9532_TYPE_GPIO:
415			gpios++;
416			break;
417		case PCA9532_TYPE_LED:
418			if (pled->state == PCA9532_KEEP)
419				led->state = pca9532_getled(led);
420			else
421				led->state = pled->state;
422			led->name = pled->name;
423			led->ldev.name = led->name;
424			led->ldev.default_trigger = pled->default_trigger;
425			led->ldev.brightness = LED_OFF;
426			led->ldev.brightness_set_blocking =
427						pca9532_set_brightness;
428			led->ldev.blink_set = pca9532_set_blink;
429			err = led_classdev_register(&client->dev, &led->ldev);
430			if (err < 0) {
431				dev_err(&client->dev,
432					"couldn't register LED %s\n",
433					led->name);
434				goto exit;
435			}
436			pca9532_setled(led);
437			break;
438		case PCA9532_TYPE_N2100_BEEP:
439			/* PWM1 is reserved for beeper so blink will not use hardware */
440			data->hw_blink = false;
441			BUG_ON(data->idev);
442			led->state = PCA9532_PWM1;
443			pca9532_setled(led);
444			data->idev = devm_input_allocate_device(&client->dev);
445			if (data->idev == NULL) {
446				err = -ENOMEM;
447				goto exit;
448			}
449			data->idev->name = pled->name;
450			data->idev->phys = "i2c/pca9532";
451			data->idev->id.bustype = BUS_HOST;
452			data->idev->id.vendor = 0x001f;
453			data->idev->id.product = 0x0001;
454			data->idev->id.version = 0x0100;
455			data->idev->evbit[0] = BIT_MASK(EV_SND);
456			data->idev->sndbit[0] = BIT_MASK(SND_BELL) |
457						BIT_MASK(SND_TONE);
458			data->idev->event = pca9532_event;
459			input_set_drvdata(data->idev, data);
460			INIT_WORK(&data->work, pca9532_input_work);
461			err = input_register_device(data->idev);
462			if (err) {
463				cancel_work_sync(&data->work);
464				data->idev = NULL;
465				goto exit;
466			}
467			break;
468		}
469	}
470
471#ifdef CONFIG_LEDS_PCA9532_GPIO
472	if (gpios) {
473		data->gpio.label = "gpio-pca9532";
474		data->gpio.direction_input = pca9532_gpio_direction_input;
475		data->gpio.direction_output = pca9532_gpio_direction_output;
476		data->gpio.set = pca9532_gpio_set_value;
477		data->gpio.get = pca9532_gpio_get_value;
478		data->gpio.request = pca9532_gpio_request_pin;
479		data->gpio.can_sleep = 1;
480		data->gpio.base = pdata->gpio_base;
481		data->gpio.ngpio = data->chip_info->num_leds;
482		data->gpio.parent = &client->dev;
483		data->gpio.owner = THIS_MODULE;
484
485		err = gpiochip_add_data(&data->gpio, data);
486		if (err) {
487			/* Use data->gpio.dev as a flag for freeing gpiochip */
488			data->gpio.parent = NULL;
489			dev_warn(&client->dev, "could not add gpiochip\n");
490		} else {
491			dev_info(&client->dev, "gpios %i...%i\n",
492				data->gpio.base, data->gpio.base +
493				data->gpio.ngpio - 1);
494		}
495	}
496#endif
497
498	return 0;
499
500exit:
501	pca9532_destroy_devices(data, i);
502	return err;
503}
504
505static struct pca9532_platform_data *
506pca9532_of_populate_pdata(struct device *dev, struct device_node *np)
507{
508	struct pca9532_platform_data *pdata;
509	int devid, maxleds;
510	int i = 0;
511	const char *state;
512
513	devid = (int)(uintptr_t)of_device_get_match_data(dev);
514	maxleds = pca9532_chip_info_tbl[devid].num_leds;
515
516	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
517	if (!pdata)
518		return ERR_PTR(-ENOMEM);
519
520	pdata->gpio_base = -1;
521
522	of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[PCA9532_PWM_ID_0],
523				  ARRAY_SIZE(pdata->pwm));
524	of_property_read_u8_array(np, "nxp,psc", &pdata->psc[PCA9532_PWM_ID_0],
525				  ARRAY_SIZE(pdata->psc));
526
527	for_each_available_child_of_node_scoped(np, child) {
528		if (of_property_read_string(child, "label",
529					    &pdata->leds[i].name))
530			pdata->leds[i].name = child->name;
531		of_property_read_u32(child, "type", &pdata->leds[i].type);
532		of_property_read_string(child, "linux,default-trigger",
533					&pdata->leds[i].default_trigger);
534		if (!of_property_read_string(child, "default-state", &state)) {
535			if (!strcmp(state, "on"))
536				pdata->leds[i].state = PCA9532_ON;
537			else if (!strcmp(state, "keep"))
538				pdata->leds[i].state = PCA9532_KEEP;
539		}
540		if (++i >= maxleds)
541			break;
542	}
543
544	return pdata;
545}
546
547static int pca9532_probe(struct i2c_client *client)
548{
549	const struct i2c_device_id *id = i2c_client_get_device_id(client);
550	int devid;
551	struct pca9532_data *data = i2c_get_clientdata(client);
552	struct pca9532_platform_data *pca9532_pdata =
553			dev_get_platdata(&client->dev);
554	struct device_node *np = dev_of_node(&client->dev);
555
556	if (!pca9532_pdata) {
557		if (np) {
558			pca9532_pdata =
559				pca9532_of_populate_pdata(&client->dev, np);
560			if (IS_ERR(pca9532_pdata))
561				return PTR_ERR(pca9532_pdata);
562		} else {
563			dev_err(&client->dev, "no platform data\n");
564			return -EINVAL;
565		}
566		devid = (int)(uintptr_t)of_device_get_match_data(&client->dev);
567	} else {
568		devid = id->driver_data;
569	}
570
571	if (!i2c_check_functionality(client->adapter,
572		I2C_FUNC_SMBUS_BYTE_DATA))
573		return -EIO;
574
575	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
576	if (!data)
577		return -ENOMEM;
578
579	data->chip_info = &pca9532_chip_info_tbl[devid];
580
581	dev_info(&client->dev, "setting platform data\n");
582	i2c_set_clientdata(client, data);
583	data->client = client;
584	mutex_init(&data->update_lock);
585
586	return pca9532_configure(client, data, pca9532_pdata);
587}
588
589static void pca9532_remove(struct i2c_client *client)
590{
591	struct pca9532_data *data = i2c_get_clientdata(client);
592
593	pca9532_destroy_devices(data, data->chip_info->num_leds);
594}
595
596module_i2c_driver(pca9532_driver);
597
598MODULE_AUTHOR("Riku Voipio");
599MODULE_LICENSE("GPL");
600MODULE_DESCRIPTION("PCA 9532 LED dimmer");