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

/*
 * Copyright 2014 Belkin Inc.
 * Copyright 2015 Andrew Lunn <andrew@lunn.ch>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 */

#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/regmap.h>
#include <linux/slab.h>

#define TLC591XX_MAX_LEDS	16

#define TLC591XX_REG_MODE1	0x00
#define MODE1_RESPON_ADDR_MASK	0xF0
#define MODE1_NORMAL_MODE	(0 << 4)
#define MODE1_SPEED_MODE	(1 << 4)

#define TLC591XX_REG_MODE2	0x01
#define MODE2_DIM		(0 << 5)
#define MODE2_BLINK		(1 << 5)
#define MODE2_OCH_STOP		(0 << 3)
#define MODE2_OCH_ACK		(1 << 3)

#define TLC591XX_REG_PWM(x)	(0x02 + (x))

#define TLC591XX_REG_GRPPWM	0x12
#define TLC591XX_REG_GRPFREQ	0x13

/* LED Driver Output State, determine the source that drives LED outputs */
#define LEDOUT_OFF		0x0	/* Output LOW */
#define LEDOUT_ON		0x1	/* Output HI-Z */
#define LEDOUT_DIM		0x2	/* Dimming */
#define LEDOUT_BLINK		0x3	/* Blinking */
#define LEDOUT_MASK		0x3

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

struct tlc591xx_led {
	bool active;
	unsigned int led_no;
	struct led_classdev ldev;
	struct tlc591xx_priv *priv;
};

struct tlc591xx_priv {
	struct tlc591xx_led leds[TLC591XX_MAX_LEDS];
	struct regmap *regmap;
	unsigned int reg_ledout_offset;
};

struct tlc591xx {
	unsigned int max_leds;
	unsigned int reg_ledout_offset;
};

static const struct tlc591xx tlc59116 = {
	.max_leds = 16,
	.reg_ledout_offset = 0x14,
};

static const struct tlc591xx tlc59108 = {
	.max_leds = 8,
	.reg_ledout_offset = 0x0c,
};

static int
tlc591xx_set_mode(struct regmap *regmap, u8 mode)
{
	int err;
	u8 val;

	err = regmap_write(regmap, TLC591XX_REG_MODE1, MODE1_NORMAL_MODE);
	if (err)
		return err;

	val = MODE2_OCH_STOP | mode;

	return regmap_write(regmap, TLC591XX_REG_MODE2, val);
}

static int
tlc591xx_set_ledout(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
		    u8 val)
{
	unsigned int i = (led->led_no % 4) * 2;
	unsigned int mask = LEDOUT_MASK << i;
	unsigned int addr = priv->reg_ledout_offset + (led->led_no >> 2);

	val = val << i;

	return regmap_update_bits(priv->regmap, addr, mask, val);
}

static int
tlc591xx_set_pwm(struct tlc591xx_priv *priv, struct tlc591xx_led *led,
		 u8 brightness)
{
	u8 pwm = TLC591XX_REG_PWM(led->led_no);

	return regmap_write(priv->regmap, pwm, brightness);
}

static int
tlc591xx_brightness_set(struct led_classdev *led_cdev,
			enum led_brightness brightness)
{
	struct tlc591xx_led *led = ldev_to_led(led_cdev);
	struct tlc591xx_priv *priv = led->priv;
	int err;

	switch (brightness) {
	case 0:
		err = tlc591xx_set_ledout(priv, led, LEDOUT_OFF);
		break;
	case LED_FULL:
		err = tlc591xx_set_ledout(priv, led, LEDOUT_ON);
		break;
	default:
		err = tlc591xx_set_ledout(priv, led, LEDOUT_DIM);
		if (!err)
			err = tlc591xx_set_pwm(priv, led, brightness);
	}

	return err;
}

static void
tlc591xx_destroy_devices(struct tlc591xx_priv *priv, unsigned int j)
{
	int i = j;

	while (--i >= 0) {
		if (priv->leds[i].active)
			led_classdev_unregister(&priv->leds[i].ldev);
	}
}

static int
tlc591xx_configure(struct device *dev,
		   struct tlc591xx_priv *priv,
		   const struct tlc591xx *tlc591xx)
{
	unsigned int i;
	int err = 0;

	tlc591xx_set_mode(priv->regmap, MODE2_DIM);
	for (i = 0; i < TLC591XX_MAX_LEDS; i++) {
		struct tlc591xx_led *led = &priv->leds[i];

		if (!led->active)
			continue;

		led->priv = priv;
		led->led_no = i;
		led->ldev.brightness_set_blocking = tlc591xx_brightness_set;
		led->ldev.max_brightness = LED_FULL;
		err = led_classdev_register(dev, &led->ldev);
		if (err < 0) {
			dev_err(dev, "couldn't register LED %s\n",
				led->ldev.name);
			goto exit;
		}
	}

	return 0;

exit:
	tlc591xx_destroy_devices(priv, i);
	return err;
}

static const struct regmap_config tlc591xx_regmap = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = 0x1e,
};

static const struct of_device_id of_tlc591xx_leds_match[] = {
	{ .compatible = "ti,tlc59116",
	  .data = &tlc59116 },
	{ .compatible = "ti,tlc59108",
	  .data = &tlc59108 },
	{},
};
MODULE_DEVICE_TABLE(of, of_tlc591xx_leds_match);

static int
tlc591xx_probe(struct i2c_client *client,
	       const struct i2c_device_id *id)
{
	struct device_node *np = client->dev.of_node, *child;
	struct device *dev = &client->dev;
	const struct of_device_id *match;
	const struct tlc591xx *tlc591xx;
	struct tlc591xx_priv *priv;
	int err, count, reg;

	match = of_match_device(of_tlc591xx_leds_match, dev);
	if (!match)
		return -ENODEV;

	tlc591xx = match->data;
	if (!np)
		return -ENODEV;

	count = of_get_child_count(np);
	if (!count || count > tlc591xx->max_leds)
		return -EINVAL;

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

	priv->regmap = devm_regmap_init_i2c(client, &tlc591xx_regmap);
	if (IS_ERR(priv->regmap)) {
		err = PTR_ERR(priv->regmap);
		dev_err(dev, "Failed to allocate register map: %d\n", err);
		return err;
	}
	priv->reg_ledout_offset = tlc591xx->reg_ledout_offset;

	i2c_set_clientdata(client, priv);

	for_each_child_of_node(np, child) {
		err = of_property_read_u32(child, "reg", &reg);
		if (err)
			return err;
		if (reg < 0 || reg >= tlc591xx->max_leds)
			return -EINVAL;
		if (priv->leds[reg].active)
			return -EINVAL;
		priv->leds[reg].active = true;
		priv->leds[reg].ldev.name =
			of_get_property(child, "label", NULL) ? : child->name;
		priv->leds[reg].ldev.default_trigger =
			of_get_property(child, "linux,default-trigger", NULL);
	}
	return tlc591xx_configure(dev, priv, tlc591xx);
}

static int
tlc591xx_remove(struct i2c_client *client)
{
	struct tlc591xx_priv *priv = i2c_get_clientdata(client);

	tlc591xx_destroy_devices(priv, TLC591XX_MAX_LEDS);

	return 0;
}

static const struct i2c_device_id tlc591xx_id[] = {
	{ "tlc59116" },
	{ "tlc59108" },
	{},
};
MODULE_DEVICE_TABLE(i2c, tlc591xx_id);

static struct i2c_driver tlc591xx_driver = {
	.driver = {
		.name = "tlc591xx",
		.of_match_table = of_match_ptr(of_tlc591xx_leds_match),
	},
	.probe = tlc591xx_probe,
	.remove = tlc591xx_remove,
	.id_table = tlc591xx_id,
};

module_i2c_driver(tlc591xx_driver);

MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("TLC591XX LED driver");
Commit	Line	Data
e370d010 AL	1	/*
	2	* Copyright 2014 Belkin Inc.
	3	* Copyright 2015 Andrew Lunn <andrew@lunn.ch>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; version 2 of the License.
	8	*/
	9
	10	#include <linux/i2c.h>
	11	#include <linux/leds.h>
	12	#include <linux/module.h>
	13	#include <linux/of.h>
	14	#include <linux/of_device.h>
	15	#include <linux/regmap.h>
	16	#include <linux/slab.h>
e370d010 AL	17
	18	#define TLC591XX_MAX_LEDS 16
	19
	20	#define TLC591XX_REG_MODE1 0x00
	21	#define MODE1_RESPON_ADDR_MASK 0xF0
	22	#define MODE1_NORMAL_MODE (0 << 4)
	23	#define MODE1_SPEED_MODE (1 << 4)
	24
	25	#define TLC591XX_REG_MODE2 0x01
	26	#define MODE2_DIM (0 << 5)
	27	#define MODE2_BLINK (1 << 5)
	28	#define MODE2_OCH_STOP (0 << 3)
	29	#define MODE2_OCH_ACK (1 << 3)
	30
	31	#define TLC591XX_REG_PWM(x) (0x02 + (x))
	32
	33	#define TLC591XX_REG_GRPPWM 0x12
	34	#define TLC591XX_REG_GRPFREQ 0x13
	35
	36	/* LED Driver Output State, determine the source that drives LED outputs */
	37	#define LEDOUT_OFF 0x0 /* Output LOW */
	38	#define LEDOUT_ON 0x1 /* Output HI-Z */
	39	#define LEDOUT_DIM 0x2 /* Dimming */
	40	#define LEDOUT_BLINK 0x3 /* Blinking */
	41	#define LEDOUT_MASK 0x3
	42
	43	#define ldev_to_led(c) container_of(c, struct tlc591xx_led, ldev)
e370d010 AL	44
	45	struct tlc591xx_led {
	46	bool active;
	47	unsigned int led_no;
	48	struct led_classdev ldev;
e370d010 AL	49	struct tlc591xx_priv *priv;
	50	};
	51
	52	struct tlc591xx_priv {
	53	struct tlc591xx_led leds[TLC591XX_MAX_LEDS];
	54	struct regmap *regmap;
	55	unsigned int reg_ledout_offset;
	56	};
	57
	58	struct tlc591xx {
	59	unsigned int max_leds;
	60	unsigned int reg_ledout_offset;
	61	};
	62
	63	static const struct tlc591xx tlc59116 = {
	64	.max_leds = 16,
	65	.reg_ledout_offset = 0x14,
	66	};
	67
	68	static const struct tlc591xx tlc59108 = {
	69	.max_leds = 8,
	70	.reg_ledout_offset = 0x0c,
	71	};
	72
	73	static int
	74	tlc591xx_set_mode(struct regmap *regmap, u8 mode)
	75	{
	76	int err;
	77	u8 val;
	78
	79	err = regmap_write(regmap, TLC591XX_REG_MODE1, MODE1_NORMAL_MODE);
	80	if (err)
	81	return err;
	82
	83	val = MODE2_OCH_STOP \| mode;
	84
	85	return regmap_write(regmap, TLC591XX_REG_MODE2, val);
	86	}
	87
	88	static int
	89	tlc591xx_set_ledout(struct tlc591xx_priv priv, struct tlc591xx_led led,
	90	u8 val)
	91	{
	92	unsigned int i = (led->led_no % 4) * 2;
	93	unsigned int mask = LEDOUT_MASK << i;
	94	unsigned int addr = priv->reg_ledout_offset + (led->led_no >> 2);
	95
	96	val = val << i;
	97
	98	return regmap_update_bits(priv->regmap, addr, mask, val);
	99	}
	100
	101	static int
	102	tlc591xx_set_pwm(struct tlc591xx_priv priv, struct tlc591xx_led led,
	103	u8 brightness)
	104	{
	105	u8 pwm = TLC591XX_REG_PWM(led->led_no);
	106
	107	return regmap_write(priv->regmap, pwm, brightness);
	108	}
	109
d890389f AL	110	static int
	111	tlc591xx_brightness_set(struct led_classdev *led_cdev,
	112	enum led_brightness brightness)
e370d010	113	{
d890389f	114	struct tlc591xx_led *led = ldev_to_led(led_cdev);
e370d010	115	struct tlc591xx_priv *priv = led->priv;
e370d010 AL	116	int err;
	117
	118	switch (brightness) {
	119	case 0:
	120	err = tlc591xx_set_ledout(priv, led, LEDOUT_OFF);
	121	break;
	122	case LED_FULL:
	123	err = tlc591xx_set_ledout(priv, led, LEDOUT_ON);
	124	break;
	125	default:
	126	err = tlc591xx_set_ledout(priv, led, LEDOUT_DIM);
	127	if (!err)
	128	err = tlc591xx_set_pwm(priv, led, brightness);
	129	}
	130
d890389f	131	return err;
e370d010 AL	132	}
	133
	134	static void
	135	tlc591xx_destroy_devices(struct tlc591xx_priv *priv, unsigned int j)
	136	{
	137	int i = j;
	138
	139	while (--i >= 0) {
d890389f	140	if (priv->leds[i].active)
e370d010	141	led_classdev_unregister(&priv->leds[i].ldev);
e370d010 AL	142	}
	143	}
	144
	145	static int
	146	tlc591xx_configure(struct device *dev,
	147	struct tlc591xx_priv *priv,
	148	const struct tlc591xx *tlc591xx)
	149	{
	150	unsigned int i;
	151	int err = 0;
	152
	153	tlc591xx_set_mode(priv->regmap, MODE2_DIM);
	154	for (i = 0; i < TLC591XX_MAX_LEDS; i++) {
	155	struct tlc591xx_led *led = &priv->leds[i];
	156
	157	if (!led->active)
	158	continue;
	159
	160	led->priv = priv;
	161	led->led_no = i;
d890389f	162	led->ldev.brightness_set_blocking = tlc591xx_brightness_set;
e370d010	163	led->ldev.max_brightness = LED_FULL;
e370d010 AL	164	err = led_classdev_register(dev, &led->ldev);
	165	if (err < 0) {
	166	dev_err(dev, "couldn't register LED %s\n",
	167	led->ldev.name);
	168	goto exit;
	169	}
	170	}
	171
	172	return 0;
	173
	174	exit:
	175	tlc591xx_destroy_devices(priv, i);
	176	return err;
	177	}
	178
	179	static const struct regmap_config tlc591xx_regmap = {
	180	.reg_bits = 8,
	181	.val_bits = 8,
	182	.max_register = 0x1e,
	183	};
	184
	185	static const struct of_device_id of_tlc591xx_leds_match[] = {
	186	{ .compatible = "ti,tlc59116",
	187	.data = &tlc59116 },
	188	{ .compatible = "ti,tlc59108",
	189	.data = &tlc59108 },
	190	{},
	191	};
	192	MODULE_DEVICE_TABLE(of, of_tlc591xx_leds_match);
	193
	194	static int
	195	tlc591xx_probe(struct i2c_client *client,
	196	const struct i2c_device_id *id)
	197	{
	198	struct device_node np = client->dev.of_node, child;
	199	struct device *dev = &client->dev;
	200	const struct of_device_id *match;
	201	const struct tlc591xx *tlc591xx;
	202	struct tlc591xx_priv *priv;
	203	int err, count, reg;
	204
	205	match = of_match_device(of_tlc591xx_leds_match, dev);
	206	if (!match)
	207	return -ENODEV;
	208
	209	tlc591xx = match->data;
	210	if (!np)
	211	return -ENODEV;
	212
	213	count = of_get_child_count(np);
	214	if (!count \|\| count > tlc591xx->max_leds)
	215	return -EINVAL;
	216
e370d010 AL	217	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	218	if (!priv)
	219	return -ENOMEM;
	220
	221	priv->regmap = devm_regmap_init_i2c(client, &tlc591xx_regmap);
	222	if (IS_ERR(priv->regmap)) {
	223	err = PTR_ERR(priv->regmap);
	224	dev_err(dev, "Failed to allocate register map: %d\n", err);
	225	return err;
	226	}
	227	priv->reg_ledout_offset = tlc591xx->reg_ledout_offset;
	228
	229	i2c_set_clientdata(client, priv);
	230
	231	for_each_child_of_node(np, child) {
	232	err = of_property_read_u32(child, "reg", &reg);
	233	if (err)
	234	return err;
	235	if (reg < 0 \|\| reg >= tlc591xx->max_leds)
	236	return -EINVAL;
	237	if (priv->leds[reg].active)
	238	return -EINVAL;
	239	priv->leds[reg].active = true;
	240	priv->leds[reg].ldev.name =
	241	of_get_property(child, "label", NULL) ? : child->name;
	242	priv->leds[reg].ldev.default_trigger =
	243	of_get_property(child, "linux,default-trigger", NULL);
	244	}
	245	return tlc591xx_configure(dev, priv, tlc591xx);
	246	}
	247
	248	static int
	249	tlc591xx_remove(struct i2c_client *client)
	250	{
	251	struct tlc591xx_priv *priv = i2c_get_clientdata(client);
	252
	253	tlc591xx_destroy_devices(priv, TLC591XX_MAX_LEDS);
	254
	255	return 0;
	256	}
	257
	258	static const struct i2c_device_id tlc591xx_id[] = {
	259	{ "tlc59116" },
	260	{ "tlc59108" },
	261	{},
	262	};
	263	MODULE_DEVICE_TABLE(i2c, tlc591xx_id);
	264
	265	static struct i2c_driver tlc591xx_driver = {
	266	.driver = {
	267	.name = "tlc591xx",
	268	.of_match_table = of_match_ptr(of_tlc591xx_leds_match),
	269	},
	270	.probe = tlc591xx_probe,
	271	.remove = tlc591xx_remove,
	272	.id_table = tlc591xx_id,
	273	};
	274
	275	module_i2c_driver(tlc591xx_driver);
	276
	277	MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>");
	278	MODULE_LICENSE("GPL");
	279	MODULE_DESCRIPTION("TLC591XX LED driver");