[linux-2.6-block.git] / drivers / leds / leds-pca9532.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * pca9532.c - 16-bit Led dimmer
 *
 * Copyright (C) 2011 Jan Weitzel
 * Copyright (C) 2008 Riku Voipio
 *
 * Datasheet: http://www.nxp.com/documents/data_sheet/PCA9532.pdf
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/leds.h>
#include <linux/input.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include <linux/leds-pca9532.h>
#include <linux/gpio/driver.h>
#include <linux/of.h>

/* m =  num_leds*/
#define PCA9532_REG_INPUT(i)	((i) >> 3)
#define PCA9532_REG_OFFSET(m)	((m) >> 4)
#define PCA9532_REG_PSC(m, i)	(PCA9532_REG_OFFSET(m) + 0x1 + (i) * 2)
#define PCA9532_REG_PWM(m, i)	(PCA9532_REG_OFFSET(m) + 0x2 + (i) * 2)
#define LED_REG(m, led)		(PCA9532_REG_OFFSET(m) + 0x5 + (led >> 2))
#define LED_NUM(led)		(led & 0x3)
#define LED_SHIFT(led)		(LED_NUM(led) * 2)
#define LED_MASK(led)		(0x3 << LED_SHIFT(led))

#define PCA9532_PWM_PERIOD_DIV	152
#define PCA9532_PWM_DUTY_DIV	256

#define ldev_to_led(c)       container_of(c, struct pca9532_led, ldev)

struct pca9532_chip_info {
	u8	num_leds;
};

struct pca9532_data {
	struct i2c_client *client;
	struct pca9532_led leds[16];
	struct mutex update_lock;
	struct input_dev *idev;
	struct work_struct work;
#ifdef CONFIG_LEDS_PCA9532_GPIO
	struct gpio_chip gpio;
#endif
	const struct pca9532_chip_info *chip_info;

#define PCA9532_PWM_ID_0	0
#define PCA9532_PWM_ID_1	1
	u8 pwm[2];
	u8 psc[2];
	bool hw_blink;
};

static int pca9532_probe(struct i2c_client *client);
static void pca9532_remove(struct i2c_client *client);

enum {
	pca9530,
	pca9531,
	pca9532,
	pca9533,
};

static const struct i2c_device_id pca9532_id[] = {
	{ "pca9530", pca9530 },
	{ "pca9531", pca9531 },
	{ "pca9532", pca9532 },
	{ "pca9533", pca9533 },
	{ }
};

MODULE_DEVICE_TABLE(i2c, pca9532_id);

static const struct pca9532_chip_info pca9532_chip_info_tbl[] = {
	[pca9530] = {
		.num_leds = 2,
	},
	[pca9531] = {
		.num_leds = 8,
	},
	[pca9532] = {
		.num_leds = 16,
	},
	[pca9533] = {
		.num_leds = 4,
	},
};

#ifdef CONFIG_OF
static const struct of_device_id of_pca9532_leds_match[] = {
	{ .compatible = "nxp,pca9530", .data = (void *)pca9530 },
	{ .compatible = "nxp,pca9531", .data = (void *)pca9531 },
	{ .compatible = "nxp,pca9532", .data = (void *)pca9532 },
	{ .compatible = "nxp,pca9533", .data = (void *)pca9533 },
	{},
};

MODULE_DEVICE_TABLE(of, of_pca9532_leds_match);
#endif

static struct i2c_driver pca9532_driver = {
	.driver = {
		.name = "leds-pca953x",
		.of_match_table = of_match_ptr(of_pca9532_leds_match),
	},
	.probe = pca9532_probe,
	.remove = pca9532_remove,
	.id_table = pca9532_id,
};

/* We have two pwm/blinkers, but 16 possible leds to drive. Additionally,
 * the clever Thecus people are using one pwm to drive the beeper. So,
 * as a compromise we average one pwm to the values requested by all
 * leds that are not ON/OFF.
 * */
static int pca9532_calcpwm(struct i2c_client *client, int pwm, int blink,
	enum led_brightness value)
{
	int a = 0, b = 0, i = 0;
	struct pca9532_data *data = i2c_get_clientdata(client);
	for (i = 0; i < data->chip_info->num_leds; i++) {
		if (data->leds[i].type == PCA9532_TYPE_LED &&
			data->leds[i].state == PCA9532_PWM0+pwm) {
				a++;
				b += data->leds[i].ldev.brightness;
		}
	}
	if (a == 0) {
		dev_err(&client->dev,
		"fear of division by zero %d/%d, wanted %d\n",
			b, a, value);
		return -EINVAL;
	}
	b = b/a;
	if (b > 0xFF)
		return -EINVAL;
	data->pwm[pwm] = b;
	data->psc[pwm] = blink;
	return 0;
}

static int pca9532_setpwm(struct i2c_client *client, int pwm)
{
	struct pca9532_data *data = i2c_get_clientdata(client);
	u8 maxleds = data->chip_info->num_leds;

	mutex_lock(&data->update_lock);
	i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, pwm),
		data->pwm[pwm]);
	i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, pwm),
		data->psc[pwm]);
	mutex_unlock(&data->update_lock);
	return 0;
}

/* Set LED routing */
static void pca9532_setled(struct pca9532_led *led)
{
	struct i2c_client *client = led->client;
	struct pca9532_data *data = i2c_get_clientdata(client);
	u8 maxleds = data->chip_info->num_leds;
	char reg;

	mutex_lock(&data->update_lock);
	reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
	/* zero led bits */
	reg = reg & ~LED_MASK(led->id);
	/* set the new value */
	reg = reg | (led->state << LED_SHIFT(led->id));
	i2c_smbus_write_byte_data(client, LED_REG(maxleds, led->id), reg);
	mutex_unlock(&data->update_lock);
}

static int pca9532_set_brightness(struct led_classdev *led_cdev,
	enum led_brightness value)
{
	int err = 0;
	struct pca9532_led *led = ldev_to_led(led_cdev);

	if (value == LED_OFF)
		led->state = PCA9532_OFF;
	else if (value == LED_FULL)
		led->state = PCA9532_ON;
	else {
		led->state = PCA9532_PWM0; /* Thecus: hardcode one pwm */
		err = pca9532_calcpwm(led->client, PCA9532_PWM_ID_0, 0, value);
		if (err)
			return err;
	}
	if (led->state == PCA9532_PWM0)
		pca9532_setpwm(led->client, PCA9532_PWM_ID_0);
	pca9532_setled(led);
	return err;
}

static int pca9532_update_hw_blink(struct pca9532_led *led,
				   unsigned long delay_on, unsigned long delay_off)
{
	struct pca9532_data *data = i2c_get_clientdata(led->client);
	unsigned int psc;
	int i;

	/* Look for others LEDs that already use PWM1 */
	for (i = 0; i < data->chip_info->num_leds; i++) {
		struct pca9532_led *other = &data->leds[i];

		if (other == led)
			continue;

		if (other->state == PCA9532_PWM1) {
			if (other->ldev.blink_delay_on != delay_on ||
			    other->ldev.blink_delay_off != delay_off) {
				/* HW can handle only one blink configuration at a time */
				return -EINVAL;
			}
		}
	}

	psc = ((delay_on + delay_off) * PCA9532_PWM_PERIOD_DIV - 1) / 1000;
	if (psc > U8_MAX) {
		/* Blink period too long to be handled by hardware */
		return -EINVAL;
	}

	led->state = PCA9532_PWM1;
	data->psc[PCA9532_PWM_ID_1] = psc;
	data->pwm[PCA9532_PWM_ID_1] = (delay_on * PCA9532_PWM_DUTY_DIV) / (delay_on + delay_off);

	return pca9532_setpwm(data->client, PCA9532_PWM_ID_1);
}

static int pca9532_set_blink(struct led_classdev *led_cdev,
	unsigned long *delay_on, unsigned long *delay_off)
{
	struct pca9532_led *led = ldev_to_led(led_cdev);
	struct i2c_client *client = led->client;
	struct pca9532_data *data = i2c_get_clientdata(client);
	int err;

	if (!data->hw_blink)
		return -EINVAL;

	if (*delay_on == 0 && *delay_off == 0) {
		/* led subsystem ask us for a blink rate */
		*delay_on = 500;
		*delay_off = 500;
	}

	err = pca9532_update_hw_blink(led, *delay_on, *delay_off);
	if (err)
		return err;

	pca9532_setled(led);

	return 0;
}

static int pca9532_event(struct input_dev *dev, unsigned int type,
	unsigned int code, int value)
{
	struct pca9532_data *data = input_get_drvdata(dev);

	if (!(type == EV_SND && (code == SND_BELL || code == SND_TONE)))
		return -1;

	/* XXX: allow different kind of beeps with psc/pwm modifications */
	if (value > 1 && value < 32767)
		data->pwm[PCA9532_PWM_ID_1] = 127;
	else
		data->pwm[PCA9532_PWM_ID_1] = 0;

	schedule_work(&data->work);

	return 0;
}

static void pca9532_input_work(struct work_struct *work)
{
	struct pca9532_data *data =
		container_of(work, struct pca9532_data, work);
	u8 maxleds = data->chip_info->num_leds;

	mutex_lock(&data->update_lock);
	i2c_smbus_write_byte_data(data->client, PCA9532_REG_PWM(maxleds, 1),
		data->pwm[PCA9532_PWM_ID_1]);
	mutex_unlock(&data->update_lock);
}

static enum pca9532_state pca9532_getled(struct pca9532_led *led)
{
	struct i2c_client *client = led->client;
	struct pca9532_data *data = i2c_get_clientdata(client);
	u8 maxleds = data->chip_info->num_leds;
	char reg;
	enum pca9532_state ret;

	mutex_lock(&data->update_lock);
	reg = i2c_smbus_read_byte_data(client, LED_REG(maxleds, led->id));
	ret = (reg & LED_MASK(led->id)) >> LED_SHIFT(led->id);
	mutex_unlock(&data->update_lock);
	return ret;
}

#ifdef CONFIG_LEDS_PCA9532_GPIO
static int pca9532_gpio_request_pin(struct gpio_chip *gc, unsigned offset)
{
	struct pca9532_data *data = gpiochip_get_data(gc);
	struct pca9532_led *led = &data->leds[offset];

	if (led->type == PCA9532_TYPE_GPIO)
		return 0;

	return -EBUSY;
}

static void pca9532_gpio_set_value(struct gpio_chip *gc, unsigned offset, int val)
{
	struct pca9532_data *data = gpiochip_get_data(gc);
	struct pca9532_led *led = &data->leds[offset];

	if (val)
		led->state = PCA9532_ON;
	else
		led->state = PCA9532_OFF;

	pca9532_setled(led);
}

static int pca9532_gpio_get_value(struct gpio_chip *gc, unsigned offset)
{
	struct pca9532_data *data = gpiochip_get_data(gc);
	unsigned char reg;

	reg = i2c_smbus_read_byte_data(data->client, PCA9532_REG_INPUT(offset));

	return !!(reg & (1 << (offset % 8)));
}

static int pca9532_gpio_direction_input(struct gpio_chip *gc, unsigned offset)
{
	/* To use as input ensure pin is not driven */
	pca9532_gpio_set_value(gc, offset, 0);

	return 0;
}

static int pca9532_gpio_direction_output(struct gpio_chip *gc, unsigned offset, int val)
{
	pca9532_gpio_set_value(gc, offset, val);

	return 0;
}
#endif /* CONFIG_LEDS_PCA9532_GPIO */

static void pca9532_destroy_devices(struct pca9532_data *data, int n_devs)
{
	int i = n_devs;

	while (--i >= 0) {
		switch (data->leds[i].type) {
		case PCA9532_TYPE_NONE:
		case PCA9532_TYPE_GPIO:
			break;
		case PCA9532_TYPE_LED:
			led_classdev_unregister(&data->leds[i].ldev);
			break;
		case PCA9532_TYPE_N2100_BEEP:
			if (data->idev != NULL) {
				cancel_work_sync(&data->work);
				data->idev = NULL;
			}
			break;
		}
	}

#ifdef CONFIG_LEDS_PCA9532_GPIO
	if (data->gpio.parent)
		gpiochip_remove(&data->gpio);
#endif
}

static int pca9532_configure(struct i2c_client *client,
	struct pca9532_data *data, struct pca9532_platform_data *pdata)
{
	int i, err = 0;
	int gpios = 0;
	u8 maxleds = data->chip_info->num_leds;

	for (i = 0; i < 2; i++)	{
		data->pwm[i] = pdata->pwm[i];
		data->psc[i] = pdata->psc[i];
		i2c_smbus_write_byte_data(client, PCA9532_REG_PWM(maxleds, i),
			data->pwm[i]);
		i2c_smbus_write_byte_data(client, PCA9532_REG_PSC(maxleds, i),
			data->psc[i]);
	}

	data->hw_blink = true;
	for (i = 0; i < data->chip_info->num_leds; i++) {
		struct pca9532_led *led = &data->leds[i];
		struct pca9532_led *pled = &pdata->leds[i];
		led->client = client;
		led->id = i;
		led->type = pled->type;
		switch (led->type) {
		case PCA9532_TYPE_NONE:
			break;
		case PCA9532_TYPE_GPIO:
			gpios++;
			break;
		case PCA9532_TYPE_LED:
			if (pled->state == PCA9532_KEEP)
				led->state = pca9532_getled(led);
			else
				led->state = pled->state;
			led->name = pled->name;
			led->ldev.name = led->name;
			led->ldev.default_trigger = pled->default_trigger;
			led->ldev.brightness = LED_OFF;
			led->ldev.brightness_set_blocking =
						pca9532_set_brightness;
			led->ldev.blink_set = pca9532_set_blink;
			err = led_classdev_register(&client->dev, &led->ldev);
			if (err < 0) {
				dev_err(&client->dev,
					"couldn't register LED %s\n",
					led->name);
				goto exit;
			}
			pca9532_setled(led);
			break;
		case PCA9532_TYPE_N2100_BEEP:
			/* PWM1 is reserved for beeper so blink will not use hardware */
			data->hw_blink = false;
			BUG_ON(data->idev);
			led->state = PCA9532_PWM1;
			pca9532_setled(led);
			data->idev = devm_input_allocate_device(&client->dev);
			if (data->idev == NULL) {
				err = -ENOMEM;
				goto exit;
			}
			data->idev->name = pled->name;
			data->idev->phys = "i2c/pca9532";
			data->idev->id.bustype = BUS_HOST;
			data->idev->id.vendor = 0x001f;
			data->idev->id.product = 0x0001;
			data->idev->id.version = 0x0100;
			data->idev->evbit[0] = BIT_MASK(EV_SND);
			data->idev->sndbit[0] = BIT_MASK(SND_BELL) |
						BIT_MASK(SND_TONE);
			data->idev->event = pca9532_event;
			input_set_drvdata(data->idev, data);
			INIT_WORK(&data->work, pca9532_input_work);
			err = input_register_device(data->idev);
			if (err) {
				cancel_work_sync(&data->work);
				data->idev = NULL;
				goto exit;
			}
			break;
		}
	}

#ifdef CONFIG_LEDS_PCA9532_GPIO
	if (gpios) {
		data->gpio.label = "gpio-pca9532";
		data->gpio.direction_input = pca9532_gpio_direction_input;
		data->gpio.direction_output = pca9532_gpio_direction_output;
		data->gpio.set = pca9532_gpio_set_value;
		data->gpio.get = pca9532_gpio_get_value;
		data->gpio.request = pca9532_gpio_request_pin;
		data->gpio.can_sleep = 1;
		data->gpio.base = pdata->gpio_base;
		data->gpio.ngpio = data->chip_info->num_leds;
		data->gpio.parent = &client->dev;
		data->gpio.owner = THIS_MODULE;

		err = gpiochip_add_data(&data->gpio, data);
		if (err) {
			/* Use data->gpio.dev as a flag for freeing gpiochip */
			data->gpio.parent = NULL;
			dev_warn(&client->dev, "could not add gpiochip\n");
		} else {
			dev_info(&client->dev, "gpios %i...%i\n",
				data->gpio.base, data->gpio.base +
				data->gpio.ngpio - 1);
		}
	}
#endif

	return 0;

exit:
	pca9532_destroy_devices(data, i);
	return err;
}

static struct pca9532_platform_data *
pca9532_of_populate_pdata(struct device *dev, struct device_node *np)
{
	struct pca9532_platform_data *pdata;
	int devid, maxleds;
	int i = 0;
	const char *state;

	devid = (int)(uintptr_t)of_device_get_match_data(dev);
	maxleds = pca9532_chip_info_tbl[devid].num_leds;

	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata)
		return ERR_PTR(-ENOMEM);

	pdata->gpio_base = -1;

	of_property_read_u8_array(np, "nxp,pwm", &pdata->pwm[PCA9532_PWM_ID_0],
				  ARRAY_SIZE(pdata->pwm));
	of_property_read_u8_array(np, "nxp,psc", &pdata->psc[PCA9532_PWM_ID_0],
				  ARRAY_SIZE(pdata->psc));

	for_each_available_child_of_node_scoped(np, child) {
		if (of_property_read_string(child, "label",
					    &pdata->leds[i].name))
			pdata->leds[i].name = child->name;
		of_property_read_u32(child, "type", &pdata->leds[i].type);
		of_property_read_string(child, "linux,default-trigger",
					&pdata->leds[i].default_trigger);
		if (!of_property_read_string(child, "default-state", &state)) {
			if (!strcmp(state, "on"))
				pdata->leds[i].state = PCA9532_ON;
			else if (!strcmp(state, "keep"))
				pdata->leds[i].state = PCA9532_KEEP;
		}
		if (++i >= maxleds)
			break;
	}

	return pdata;
}

static int pca9532_probe(struct i2c_client *client)
{
	const struct i2c_device_id *id = i2c_client_get_device_id(client);
	int devid;
	struct pca9532_data *data = i2c_get_clientdata(client);
	struct pca9532_platform_data *pca9532_pdata =
			dev_get_platdata(&client->dev);
	struct device_node *np = dev_of_node(&client->dev);

	if (!pca9532_pdata) {
		if (np) {
			pca9532_pdata =
				pca9532_of_populate_pdata(&client->dev, np);
			if (IS_ERR(pca9532_pdata))
				return PTR_ERR(pca9532_pdata);
		} else {
			dev_err(&client->dev, "no platform data\n");
			return -EINVAL;
		}
		devid = (int)(uintptr_t)of_device_get_match_data(&client->dev);
	} else {
		devid = id->driver_data;
	}

	if (!i2c_check_functionality(client->adapter,
		I2C_FUNC_SMBUS_BYTE_DATA))
		return -EIO;

	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->chip_info = &pca9532_chip_info_tbl[devid];

	dev_info(&client->dev, "setting platform data\n");
	i2c_set_clientdata(client, data);
	data->client = client;
	mutex_init(&data->update_lock);

	return pca9532_configure(client, data, pca9532_pdata);
}

static void pca9532_remove(struct i2c_client *client)
{
	struct pca9532_data *data = i2c_get_clientdata(client);

	pca9532_destroy_devices(data, data->chip_info->num_leds);
}

module_i2c_driver(pca9532_driver);

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