[linux-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>
#include <linux/of_device.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 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;
	u8 pwm[2];
	u8 psc[2];
};

static int pca9532_probe(struct i2c_client *client,
	const struct i2c_device_id *id);
static int 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, 0, 0, value);
		if (err)
			return err;
	}
	if (led->state == PCA9532_PWM0)
		pca9532_setpwm(led->client, 0);
	pca9532_setled(led);
	return err;
}

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;
	int psc;
	int err = 0;

	if (*delay_on == 0 && *delay_off == 0) {
		/* led subsystem ask us for a blink rate */
		*delay_on = 1000;
		*delay_off = 1000;
	}
	if (*delay_on != *delay_off || *delay_on > 1690 || *delay_on < 6)
		return -EINVAL;

	/* Thecus specific: only use PSC/PWM 0 */
	psc = (*delay_on * 152-1)/1000;
	err = pca9532_calcpwm(client, 0, psc, led_cdev->brightness);
	if (err)
		return err;
	if (led->state == PCA9532_PWM0)
		pca9532_setpwm(led->client, 0);
	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[1] = 127;
	else
		data->pwm[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[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 int pca9532_destroy_devices(struct pca9532_data *data, int n_devs)
{
	int i = n_devs;

	if (!data)
		return -EINVAL;

	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

	return 0;
}

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]);
	}

	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:
			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;
	struct device_node *child;
	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[0],
				  ARRAY_SIZE(pdata->pwm));
	of_property_read_u8_array(np, "nxp,psc", &pdata->psc[0],
				  ARRAY_SIZE(pdata->psc));

	for_each_available_child_of_node(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) {
			of_node_put(child);
			break;
		}
	}

	return pdata;
}

static int pca9532_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	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 int pca9532_remove(struct i2c_client *client)
{
	struct pca9532_data *data = i2c_get_clientdata(client);

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