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

/*
 * TI LP8860 4-Channel LED Driver
 *
 * Copyright (C) 2014 Texas Instruments
 *
 * Author: Dan Murphy <dmurphy@ti.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 */

#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/leds.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/slab.h>
#include <uapi/linux/uleds.h>

#define LP8860_DISP_CL1_BRT_MSB		0x00
#define LP8860_DISP_CL1_BRT_LSB		0x01
#define LP8860_DISP_CL1_CURR_MSB	0x02
#define LP8860_DISP_CL1_CURR_LSB	0x03
#define LP8860_CL2_BRT_MSB		0x04
#define LP8860_CL2_BRT_LSB		0x05
#define LP8860_CL2_CURRENT		0x06
#define LP8860_CL3_BRT_MSB		0x07
#define LP8860_CL3_BRT_LSB		0x08
#define LP8860_CL3_CURRENT		0x09
#define LP8860_CL4_BRT_MSB		0x0a
#define LP8860_CL4_BRT_LSB		0x0b
#define LP8860_CL4_CURRENT		0x0c
#define LP8860_CONFIG			0x0d
#define LP8860_STATUS			0x0e
#define LP8860_FAULT			0x0f
#define LP8860_LED_FAULT		0x10
#define LP8860_FAULT_CLEAR		0x11
#define LP8860_ID			0x12
#define LP8860_TEMP_MSB			0x13
#define LP8860_TEMP_LSB			0x14
#define LP8860_DISP_LED_CURR_MSB	0x15
#define LP8860_DISP_LED_CURR_LSB	0x16
#define LP8860_DISP_LED_PWM_MSB		0x17
#define LP8860_DISP_LED_PWM_LSB		0x18
#define LP8860_EEPROM_CNTRL		0x19
#define LP8860_EEPROM_UNLOCK		0x1a

#define LP8860_EEPROM_REG_0		0x60
#define LP8860_EEPROM_REG_1		0x61
#define LP8860_EEPROM_REG_2		0x62
#define LP8860_EEPROM_REG_3		0x63
#define LP8860_EEPROM_REG_4		0x64
#define LP8860_EEPROM_REG_5		0x65
#define LP8860_EEPROM_REG_6		0x66
#define LP8860_EEPROM_REG_7		0x67
#define LP8860_EEPROM_REG_8		0x68
#define LP8860_EEPROM_REG_9		0x69
#define LP8860_EEPROM_REG_10		0x6a
#define LP8860_EEPROM_REG_11		0x6b
#define LP8860_EEPROM_REG_12		0x6c
#define LP8860_EEPROM_REG_13		0x6d
#define LP8860_EEPROM_REG_14		0x6e
#define LP8860_EEPROM_REG_15		0x6f
#define LP8860_EEPROM_REG_16		0x70
#define LP8860_EEPROM_REG_17		0x71
#define LP8860_EEPROM_REG_18		0x72
#define LP8860_EEPROM_REG_19		0x73
#define LP8860_EEPROM_REG_20		0x74
#define LP8860_EEPROM_REG_21		0x75
#define LP8860_EEPROM_REG_22		0x76
#define LP8860_EEPROM_REG_23		0x77
#define LP8860_EEPROM_REG_24		0x78

#define LP8860_LOCK_EEPROM		0x00
#define LP8860_UNLOCK_EEPROM		0x01
#define LP8860_PROGRAM_EEPROM		0x02
#define LP8860_EEPROM_CODE_1		0x08
#define LP8860_EEPROM_CODE_2		0xba
#define LP8860_EEPROM_CODE_3		0xef

#define LP8860_CLEAR_FAULTS		0x01

/**
 * struct lp8860_led -
 * @lock - Lock for reading/writing the device
 * @client - Pointer to the I2C client
 * @led_dev - led class device pointer
 * @regmap - Devices register map
 * @eeprom_regmap - EEPROM register map
 * @enable_gpio - VDDIO/EN gpio to enable communication interface
 * @regulator - LED supply regulator pointer
 * @label - LED label
 */
struct lp8860_led {
	struct mutex lock;
	struct i2c_client *client;
	struct led_classdev led_dev;
	struct regmap *regmap;
	struct regmap *eeprom_regmap;
	struct gpio_desc *enable_gpio;
	struct regulator *regulator;
	char label[LED_MAX_NAME_SIZE];
};

struct lp8860_eeprom_reg {
	uint8_t reg;
	uint8_t value;
};

static struct lp8860_eeprom_reg lp8860_eeprom_disp_regs[] = {
	{ LP8860_EEPROM_REG_0, 0xed },
	{ LP8860_EEPROM_REG_1, 0xdf },
	{ LP8860_EEPROM_REG_2, 0xdc },
	{ LP8860_EEPROM_REG_3, 0xf0 },
	{ LP8860_EEPROM_REG_4, 0xdf },
	{ LP8860_EEPROM_REG_5, 0xe5 },
	{ LP8860_EEPROM_REG_6, 0xf2 },
	{ LP8860_EEPROM_REG_7, 0x77 },
	{ LP8860_EEPROM_REG_8, 0x77 },
	{ LP8860_EEPROM_REG_9, 0x71 },
	{ LP8860_EEPROM_REG_10, 0x3f },
	{ LP8860_EEPROM_REG_11, 0xb7 },
	{ LP8860_EEPROM_REG_12, 0x17 },
	{ LP8860_EEPROM_REG_13, 0xef },
	{ LP8860_EEPROM_REG_14, 0xb0 },
	{ LP8860_EEPROM_REG_15, 0x87 },
	{ LP8860_EEPROM_REG_16, 0xce },
	{ LP8860_EEPROM_REG_17, 0x72 },
	{ LP8860_EEPROM_REG_18, 0xe5 },
	{ LP8860_EEPROM_REG_19, 0xdf },
	{ LP8860_EEPROM_REG_20, 0x35 },
	{ LP8860_EEPROM_REG_21, 0x06 },
	{ LP8860_EEPROM_REG_22, 0xdc },
	{ LP8860_EEPROM_REG_23, 0x88 },
	{ LP8860_EEPROM_REG_24, 0x3E },
};

static int lp8860_unlock_eeprom(struct lp8860_led *led, int lock)
{
	int ret;

	mutex_lock(&led->lock);

	if (lock == LP8860_UNLOCK_EEPROM) {
		ret = regmap_write(led->regmap,
			LP8860_EEPROM_UNLOCK,
			LP8860_EEPROM_CODE_1);
		if (ret) {
			dev_err(&led->client->dev, "EEPROM Unlock failed\n");
			goto out;
		}

		ret = regmap_write(led->regmap,
			LP8860_EEPROM_UNLOCK,
			LP8860_EEPROM_CODE_2);
		if (ret) {
			dev_err(&led->client->dev, "EEPROM Unlock failed\n");
			goto out;
		}
		ret = regmap_write(led->regmap,
			LP8860_EEPROM_UNLOCK,
			LP8860_EEPROM_CODE_3);
		if (ret) {
			dev_err(&led->client->dev, "EEPROM Unlock failed\n");
			goto out;
		}
	} else {
		ret = regmap_write(led->regmap,
			LP8860_EEPROM_UNLOCK,
			LP8860_LOCK_EEPROM);
	}

out:
	mutex_unlock(&led->lock);
	return ret;
}

static int lp8860_fault_check(struct lp8860_led *led)
{
	int ret, fault;
	unsigned int read_buf;

	ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf);
	if (ret)
		goto out;

	fault = read_buf;

	ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf);
	if (ret)
		goto out;

	fault |= read_buf;

	/* Attempt to clear any faults */
	if (fault)
		ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR,
			LP8860_CLEAR_FAULTS);
out:
	return ret;
}

static int lp8860_brightness_set(struct led_classdev *led_cdev,
				enum led_brightness brt_val)
{
	struct lp8860_led *led =
			container_of(led_cdev, struct lp8860_led, led_dev);
	int disp_brightness = brt_val * 255;
	int ret;

	mutex_lock(&led->lock);

	ret = lp8860_fault_check(led);
	if (ret) {
		dev_err(&led->client->dev, "Cannot read/clear faults\n");
		goto out;
	}

	ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB,
			(disp_brightness & 0xff00) >> 8);
	if (ret) {
		dev_err(&led->client->dev, "Cannot write CL1 MSB\n");
		goto out;
	}

	ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB,
			disp_brightness & 0xff);
	if (ret) {
		dev_err(&led->client->dev, "Cannot write CL1 LSB\n");
		goto out;
	}
out:
	mutex_unlock(&led->lock);
	return ret;
}

static int lp8860_init(struct lp8860_led *led)
{
	unsigned int read_buf;
	int ret, i, reg_count;

	if (led->regulator) {
		ret = regulator_enable(led->regulator);
		if (ret) {
			dev_err(&led->client->dev,
				"Failed to enable regulator\n");
			return ret;
		}
	}

	if (led->enable_gpio)
		gpiod_direction_output(led->enable_gpio, 1);

	ret = lp8860_fault_check(led);
	if (ret)
		goto out;

	ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf);
	if (ret)
		goto out;

	ret = lp8860_unlock_eeprom(led, LP8860_UNLOCK_EEPROM);
	if (ret) {
		dev_err(&led->client->dev, "Failed unlocking EEPROM\n");
		goto out;
	}

	reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs) / sizeof(lp8860_eeprom_disp_regs[0]);
	for (i = 0; i < reg_count; i++) {
		ret = regmap_write(led->eeprom_regmap,
				lp8860_eeprom_disp_regs[i].reg,
				lp8860_eeprom_disp_regs[i].value);
		if (ret) {
			dev_err(&led->client->dev, "Failed writing EEPROM\n");
			goto out;
		}
	}

	ret = lp8860_unlock_eeprom(led, LP8860_LOCK_EEPROM);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap,
			LP8860_EEPROM_CNTRL,
			LP8860_PROGRAM_EEPROM);
	if (ret) {
		dev_err(&led->client->dev, "Failed programming EEPROM\n");
		goto out;
	}

	return ret;

out:
	if (ret)
		if (led->enable_gpio)
			gpiod_direction_output(led->enable_gpio, 0);

	if (led->regulator) {
		ret = regulator_disable(led->regulator);
		if (ret)
			dev_err(&led->client->dev,
				"Failed to disable regulator\n");
	}

	return ret;
}

static const struct reg_default lp8860_reg_defs[] = {
	{ LP8860_DISP_CL1_BRT_MSB, 0x00},
	{ LP8860_DISP_CL1_BRT_LSB, 0x00},
	{ LP8860_DISP_CL1_CURR_MSB, 0x00},
	{ LP8860_DISP_CL1_CURR_LSB, 0x00},
	{ LP8860_CL2_BRT_MSB, 0x00},
	{ LP8860_CL2_BRT_LSB, 0x00},
	{ LP8860_CL2_CURRENT, 0x00},
	{ LP8860_CL3_BRT_MSB, 0x00},
	{ LP8860_CL3_BRT_LSB, 0x00},
	{ LP8860_CL3_CURRENT, 0x00},
	{ LP8860_CL4_BRT_MSB, 0x00},
	{ LP8860_CL4_BRT_LSB, 0x00},
	{ LP8860_CL4_CURRENT, 0x00},
	{ LP8860_CONFIG, 0x00},
	{ LP8860_FAULT_CLEAR, 0x00},
	{ LP8860_EEPROM_CNTRL, 0x80},
	{ LP8860_EEPROM_UNLOCK, 0x00},
};

static const struct regmap_config lp8860_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = LP8860_EEPROM_UNLOCK,
	.reg_defaults = lp8860_reg_defs,
	.num_reg_defaults = ARRAY_SIZE(lp8860_reg_defs),
	.cache_type = REGCACHE_NONE,
};

static const struct reg_default lp8860_eeprom_defs[] = {
	{ LP8860_EEPROM_REG_0, 0x00 },
	{ LP8860_EEPROM_REG_1, 0x00 },
	{ LP8860_EEPROM_REG_2, 0x00 },
	{ LP8860_EEPROM_REG_3, 0x00 },
	{ LP8860_EEPROM_REG_4, 0x00 },
	{ LP8860_EEPROM_REG_5, 0x00 },
	{ LP8860_EEPROM_REG_6, 0x00 },
	{ LP8860_EEPROM_REG_7, 0x00 },
	{ LP8860_EEPROM_REG_8, 0x00 },
	{ LP8860_EEPROM_REG_9, 0x00 },
	{ LP8860_EEPROM_REG_10, 0x00 },
	{ LP8860_EEPROM_REG_11, 0x00 },
	{ LP8860_EEPROM_REG_12, 0x00 },
	{ LP8860_EEPROM_REG_13, 0x00 },
	{ LP8860_EEPROM_REG_14, 0x00 },
	{ LP8860_EEPROM_REG_15, 0x00 },
	{ LP8860_EEPROM_REG_16, 0x00 },
	{ LP8860_EEPROM_REG_17, 0x00 },
	{ LP8860_EEPROM_REG_18, 0x00 },
	{ LP8860_EEPROM_REG_19, 0x00 },
	{ LP8860_EEPROM_REG_20, 0x00 },
	{ LP8860_EEPROM_REG_21, 0x00 },
	{ LP8860_EEPROM_REG_22, 0x00 },
	{ LP8860_EEPROM_REG_23, 0x00 },
	{ LP8860_EEPROM_REG_24, 0x00 },
};

static const struct regmap_config lp8860_eeprom_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,

	.max_register = LP8860_EEPROM_REG_24,
	.reg_defaults = lp8860_eeprom_defs,
	.num_reg_defaults = ARRAY_SIZE(lp8860_eeprom_defs),
	.cache_type = REGCACHE_NONE,
};

static int lp8860_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	int ret;
	struct lp8860_led *led;
	struct device_node *np = client->dev.of_node;
	struct device_node *child_node;
	const char *name;

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

	for_each_available_child_of_node(np, child_node) {
		led->led_dev.default_trigger = of_get_property(child_node,
						    "linux,default-trigger",
						    NULL);

		ret = of_property_read_string(child_node, "label", &name);
		if (!ret)
			snprintf(led->label, sizeof(led->label), "%s:%s",
				 id->name, name);
		else
			snprintf(led->label, sizeof(led->label),
				"%s::display_cluster", id->name);
	}

	led->enable_gpio = devm_gpiod_get_optional(&client->dev,
						   "enable", GPIOD_OUT_LOW);
	if (IS_ERR(led->enable_gpio)) {
		ret = PTR_ERR(led->enable_gpio);
		dev_err(&client->dev, "Failed to get enable gpio: %d\n", ret);
		return ret;
	}

	led->regulator = devm_regulator_get(&client->dev, "vled");
	if (IS_ERR(led->regulator))
		led->regulator = NULL;

	led->client = client;
	led->led_dev.name = led->label;
	led->led_dev.brightness_set_blocking = lp8860_brightness_set;

	mutex_init(&led->lock);

	i2c_set_clientdata(client, led);

	led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config);
	if (IS_ERR(led->regmap)) {
		ret = PTR_ERR(led->regmap);
		dev_err(&client->dev, "Failed to allocate register map: %d\n",
			ret);
		return ret;
	}

	led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config);
	if (IS_ERR(led->eeprom_regmap)) {
		ret = PTR_ERR(led->eeprom_regmap);
		dev_err(&client->dev, "Failed to allocate register map: %d\n",
			ret);
		return ret;
	}

	ret = lp8860_init(led);
	if (ret)
		return ret;

	ret = devm_led_classdev_register(&client->dev, &led->led_dev);
	if (ret) {
		dev_err(&client->dev, "led register err: %d\n", ret);
		return ret;
	}

	return 0;
}

static int lp8860_remove(struct i2c_client *client)
{
	struct lp8860_led *led = i2c_get_clientdata(client);
	int ret;

	if (led->enable_gpio)
		gpiod_direction_output(led->enable_gpio, 0);

	if (led->regulator) {
		ret = regulator_disable(led->regulator);
		if (ret)
			dev_err(&led->client->dev,
				"Failed to disable regulator\n");
	}

	mutex_destroy(&led->lock);

	return 0;
}

static const struct i2c_device_id lp8860_id[] = {
	{ "lp8860", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lp8860_id);

static const struct of_device_id of_lp8860_leds_match[] = {
	{ .compatible = "ti,lp8860", },
	{},
};
MODULE_DEVICE_TABLE(of, of_lp8860_leds_match);

static struct i2c_driver lp8860_driver = {
	.driver = {
		.name	= "lp8860",
		.of_match_table = of_lp8860_leds_match,
	},
	.probe		= lp8860_probe,
	.remove		= lp8860_remove,
	.id_table	= lp8860_id,
};
module_i2c_driver(lp8860_driver);

MODULE_DESCRIPTION("Texas Instruments LP8860 LED driver");
MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
7a8685ac DM	1	/*
	2	* TI LP8860 4-Channel LED Driver
	3	*
	4	* Copyright (C) 2014 Texas Instruments
	5	*
	6	* Author: Dan Murphy <dmurphy@ti.com>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* version 2 as published by the Free Software Foundation.
	11	*
	12	*/
	13
	14	#include <linux/i2c.h>
	15	#include <linux/init.h>
	16	#include <linux/leds.h>
	17	#include <linux/regmap.h>
	18	#include <linux/regulator/consumer.h>
	19	#include <linux/module.h>
	20	#include <linux/mutex.h>
	21	#include <linux/of.h>
	22	#include <linux/of_gpio.h>
	23	#include <linux/gpio/consumer.h>
	24	#include <linux/slab.h>
c6b218c9	25	#include <uapi/linux/uleds.h>
7a8685ac DM	26
	27	#define LP8860_DISP_CL1_BRT_MSB 0x00
	28	#define LP8860_DISP_CL1_BRT_LSB 0x01
	29	#define LP8860_DISP_CL1_CURR_MSB 0x02
	30	#define LP8860_DISP_CL1_CURR_LSB 0x03
	31	#define LP8860_CL2_BRT_MSB 0x04
	32	#define LP8860_CL2_BRT_LSB 0x05
	33	#define LP8860_CL2_CURRENT 0x06
	34	#define LP8860_CL3_BRT_MSB 0x07
	35	#define LP8860_CL3_BRT_LSB 0x08
	36	#define LP8860_CL3_CURRENT 0x09
	37	#define LP8860_CL4_BRT_MSB 0x0a
	38	#define LP8860_CL4_BRT_LSB 0x0b
	39	#define LP8860_CL4_CURRENT 0x0c
	40	#define LP8860_CONFIG 0x0d
	41	#define LP8860_STATUS 0x0e
	42	#define LP8860_FAULT 0x0f
	43	#define LP8860_LED_FAULT 0x10
	44	#define LP8860_FAULT_CLEAR 0x11
	45	#define LP8860_ID 0x12
	46	#define LP8860_TEMP_MSB 0x13
	47	#define LP8860_TEMP_LSB 0x14
	48	#define LP8860_DISP_LED_CURR_MSB 0x15
	49	#define LP8860_DISP_LED_CURR_LSB 0x16
	50	#define LP8860_DISP_LED_PWM_MSB 0x17
	51	#define LP8860_DISP_LED_PWM_LSB 0x18
	52	#define LP8860_EEPROM_CNTRL 0x19
	53	#define LP8860_EEPROM_UNLOCK 0x1a
	54
	55	#define LP8860_EEPROM_REG_0 0x60
	56	#define LP8860_EEPROM_REG_1 0x61
	57	#define LP8860_EEPROM_REG_2 0x62
	58	#define LP8860_EEPROM_REG_3 0x63
	59	#define LP8860_EEPROM_REG_4 0x64
	60	#define LP8860_EEPROM_REG_5 0x65
	61	#define LP8860_EEPROM_REG_6 0x66
	62	#define LP8860_EEPROM_REG_7 0x67
	63	#define LP8860_EEPROM_REG_8 0x68
	64	#define LP8860_EEPROM_REG_9 0x69
	65	#define LP8860_EEPROM_REG_10 0x6a
	66	#define LP8860_EEPROM_REG_11 0x6b
	67	#define LP8860_EEPROM_REG_12 0x6c
	68	#define LP8860_EEPROM_REG_13 0x6d
	69	#define LP8860_EEPROM_REG_14 0x6e
	70	#define LP8860_EEPROM_REG_15 0x6f
	71	#define LP8860_EEPROM_REG_16 0x70
	72	#define LP8860_EEPROM_REG_17 0x71
	73	#define LP8860_EEPROM_REG_18 0x72
	74	#define LP8860_EEPROM_REG_19 0x73
	75	#define LP8860_EEPROM_REG_20 0x74
	76	#define LP8860_EEPROM_REG_21 0x75
	77	#define LP8860_EEPROM_REG_22 0x76
	78	#define LP8860_EEPROM_REG_23 0x77
	79	#define LP8860_EEPROM_REG_24 0x78
	80
	81	#define LP8860_LOCK_EEPROM 0x00
	82	#define LP8860_UNLOCK_EEPROM 0x01
	83	#define LP8860_PROGRAM_EEPROM 0x02
	84	#define LP8860_EEPROM_CODE_1 0x08
	85	#define LP8860_EEPROM_CODE_2 0xba
	86	#define LP8860_EEPROM_CODE_3 0xef
	87
	88	#define LP8860_CLEAR_FAULTS 0x01
	89
7a8685ac DM	90	/**
	91	* struct lp8860_led -
	92	* @lock - Lock for reading/writing the device
7a8685ac DM	93	* @client - Pointer to the I2C client
	94	* @led_dev - led class device pointer
	95	* @regmap - Devices register map
	96	* @eeprom_regmap - EEPROM register map
	97	* @enable_gpio - VDDIO/EN gpio to enable communication interface
	98	* @regulator - LED supply regulator pointer
7a8685ac	99	* @label - LED label
8a7a76c8	100	*/
7a8685ac DM	101	struct lp8860_led {
7a8685ac DM	102	struct mutex lock;
7a8685ac DM	103	struct i2c_client *client;
	104	struct led_classdev led_dev;
	105	struct regmap *regmap;
	106	struct regmap *eeprom_regmap;
	107	struct gpio_desc *enable_gpio;
	108	struct regulator *regulator;
c6b218c9	109	char label[LED_MAX_NAME_SIZE];
7a8685ac DM	110	};
	111
	112	struct lp8860_eeprom_reg {
	113	uint8_t reg;
	114	uint8_t value;
	115	};
	116
	117	static struct lp8860_eeprom_reg lp8860_eeprom_disp_regs[] = {
	118	{ LP8860_EEPROM_REG_0, 0xed },
	119	{ LP8860_EEPROM_REG_1, 0xdf },
	120	{ LP8860_EEPROM_REG_2, 0xdc },
	121	{ LP8860_EEPROM_REG_3, 0xf0 },
	122	{ LP8860_EEPROM_REG_4, 0xdf },
	123	{ LP8860_EEPROM_REG_5, 0xe5 },
	124	{ LP8860_EEPROM_REG_6, 0xf2 },
	125	{ LP8860_EEPROM_REG_7, 0x77 },
	126	{ LP8860_EEPROM_REG_8, 0x77 },
	127	{ LP8860_EEPROM_REG_9, 0x71 },
	128	{ LP8860_EEPROM_REG_10, 0x3f },
	129	{ LP8860_EEPROM_REG_11, 0xb7 },
	130	{ LP8860_EEPROM_REG_12, 0x17 },
	131	{ LP8860_EEPROM_REG_13, 0xef },
	132	{ LP8860_EEPROM_REG_14, 0xb0 },
	133	{ LP8860_EEPROM_REG_15, 0x87 },
	134	{ LP8860_EEPROM_REG_16, 0xce },
	135	{ LP8860_EEPROM_REG_17, 0x72 },
	136	{ LP8860_EEPROM_REG_18, 0xe5 },
	137	{ LP8860_EEPROM_REG_19, 0xdf },
	138	{ LP8860_EEPROM_REG_20, 0x35 },
	139	{ LP8860_EEPROM_REG_21, 0x06 },
	140	{ LP8860_EEPROM_REG_22, 0xdc },
	141	{ LP8860_EEPROM_REG_23, 0x88 },
	142	{ LP8860_EEPROM_REG_24, 0x3E },
	143	};
	144
	145	static int lp8860_unlock_eeprom(struct lp8860_led *led, int lock)
	146	{
	147	int ret;
	148
	149	mutex_lock(&led->lock);
	150
	151	if (lock == LP8860_UNLOCK_EEPROM) {
	152	ret = regmap_write(led->regmap,
	153	LP8860_EEPROM_UNLOCK,
	154	LP8860_EEPROM_CODE_1);
	155	if (ret) {
	156	dev_err(&led->client->dev, "EEPROM Unlock failed\n");
	157	goto out;
	158	}
	159
	160	ret = regmap_write(led->regmap,
	161	LP8860_EEPROM_UNLOCK,
	162	LP8860_EEPROM_CODE_2);
	163	if (ret) {
	164	dev_err(&led->client->dev, "EEPROM Unlock failed\n");
	165	goto out;
	166	}
	167	ret = regmap_write(led->regmap,
	168	LP8860_EEPROM_UNLOCK,
	169	LP8860_EEPROM_CODE_3);
	170	if (ret) {
	171	dev_err(&led->client->dev, "EEPROM Unlock failed\n");
	172	goto out;
	173	}
174	} else {
175	ret = regmap_write(led->regmap,
176	LP8860_EEPROM_UNLOCK,
177	LP8860_LOCK_EEPROM);
178	}
179
180	out:
181	mutex_unlock(&led->lock);
182	return ret;
183	}
184
185	static int lp8860_fault_check(struct lp8860_led *led)
186	{
187	int ret, fault;
188	unsigned int read_buf;
189
190	ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf);
191	if (ret)
192	goto out;
193
194	fault = read_buf;
195
196	ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf);
197	if (ret)
198	goto out;
199
200	fault \|= read_buf;
201
202	/* Attempt to clear any faults */
203	if (fault)
204	ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR,
205	LP8860_CLEAR_FAULTS);
206	out:
207	return ret;
208	}
209
7c4b10a2 AL	210	static int lp8860_brightness_set(struct led_classdev *led_cdev,
7c4b10a2 AL	211	enum led_brightness brt_val)
7a8685ac	212	{
7c4b10a2 AL	213	struct lp8860_led *led =
	214	container_of(led_cdev, struct lp8860_led, led_dev);
	215	int disp_brightness = brt_val * 255;
7a8685ac	216	int ret;
7a8685ac DM	217
	218	mutex_lock(&led->lock);
	219
	220	ret = lp8860_fault_check(led);
	221	if (ret) {
	222	dev_err(&led->client->dev, "Cannot read/clear faults\n");
	223	goto out;
	224	}
	225
	226	ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB,
	227	(disp_brightness & 0xff00) >> 8);
	228	if (ret) {
	229	dev_err(&led->client->dev, "Cannot write CL1 MSB\n");
	230	goto out;
	231	}
	232
	233	ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB,
	234	disp_brightness & 0xff);
	235	if (ret) {
	236	dev_err(&led->client->dev, "Cannot write CL1 LSB\n");
	237	goto out;
	238	}
	239	out:
	240	mutex_unlock(&led->lock);
7c4b10a2	241	return ret;
7a8685ac DM	242	}
	243
	244	static int lp8860_init(struct lp8860_led *led)
	245	{
	246	unsigned int read_buf;
	247	int ret, i, reg_count;
	248
b12ef03a DM	249	if (led->regulator) {
	250	ret = regulator_enable(led->regulator);
	251	if (ret) {
	252	dev_err(&led->client->dev,
	253	"Failed to enable regulator\n");
	254	return ret;
	255	}
	256	}
	257
7a8685ac DM	258	if (led->enable_gpio)
	259	gpiod_direction_output(led->enable_gpio, 1);
	260
	261	ret = lp8860_fault_check(led);
	262	if (ret)
	263	goto out;
	264
	265	ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf);
	266	if (ret)
	267	goto out;
	268
	269	ret = lp8860_unlock_eeprom(led, LP8860_UNLOCK_EEPROM);
	270	if (ret) {
	271	dev_err(&led->client->dev, "Failed unlocking EEPROM\n");
	272	goto out;
	273	}
	274
	275	reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs) / sizeof(lp8860_eeprom_disp_regs[0]);
	276	for (i = 0; i < reg_count; i++) {
	277	ret = regmap_write(led->eeprom_regmap,
	278	lp8860_eeprom_disp_regs[i].reg,
	279	lp8860_eeprom_disp_regs[i].value);
	280	if (ret) {
	281	dev_err(&led->client->dev, "Failed writing EEPROM\n");
	282	goto out;
	283	}
	284	}
	285
	286	ret = lp8860_unlock_eeprom(led, LP8860_LOCK_EEPROM);
	287	if (ret)
	288	goto out;
	289
	290	ret = regmap_write(led->regmap,
	291	LP8860_EEPROM_CNTRL,
	292	LP8860_PROGRAM_EEPROM);
b12ef03a	293	if (ret) {
7a8685ac	294	dev_err(&led->client->dev, "Failed programming EEPROM\n");
b12ef03a DM	295	goto out;
	296	}
	297
	298	return ret;
	299
7a8685ac DM	300	out:
	301	if (ret)
	302	if (led->enable_gpio)
	303	gpiod_direction_output(led->enable_gpio, 0);
b12ef03a DM	304
	305	if (led->regulator) {
	306	ret = regulator_disable(led->regulator);
	307	if (ret)
	308	dev_err(&led->client->dev,
	309	"Failed to disable regulator\n");
	310	}
	311
7a8685ac DM	312	return ret;
	313	}
	314
de88e71a	315	static const struct reg_default lp8860_reg_defs[] = {
7a8685ac DM	316	{ LP8860_DISP_CL1_BRT_MSB, 0x00},
	317	{ LP8860_DISP_CL1_BRT_LSB, 0x00},
	318	{ LP8860_DISP_CL1_CURR_MSB, 0x00},
	319	{ LP8860_DISP_CL1_CURR_LSB, 0x00},
	320	{ LP8860_CL2_BRT_MSB, 0x00},
	321	{ LP8860_CL2_BRT_LSB, 0x00},
	322	{ LP8860_CL2_CURRENT, 0x00},
	323	{ LP8860_CL3_BRT_MSB, 0x00},
	324	{ LP8860_CL3_BRT_LSB, 0x00},
	325	{ LP8860_CL3_CURRENT, 0x00},
	326	{ LP8860_CL4_BRT_MSB, 0x00},
	327	{ LP8860_CL4_BRT_LSB, 0x00},
	328	{ LP8860_CL4_CURRENT, 0x00},
	329	{ LP8860_CONFIG, 0x00},
	330	{ LP8860_FAULT_CLEAR, 0x00},
	331	{ LP8860_EEPROM_CNTRL, 0x80},
	332	{ LP8860_EEPROM_UNLOCK, 0x00},
	333	};
	334
	335	static const struct regmap_config lp8860_regmap_config = {
	336	.reg_bits = 8,
	337	.val_bits = 8,
	338
	339	.max_register = LP8860_EEPROM_UNLOCK,
	340	.reg_defaults = lp8860_reg_defs,
	341	.num_reg_defaults = ARRAY_SIZE(lp8860_reg_defs),
	342	.cache_type = REGCACHE_NONE,
	343	};
	344
de88e71a	345	static const struct reg_default lp8860_eeprom_defs[] = {
7a8685ac DM	346	{ LP8860_EEPROM_REG_0, 0x00 },
	347	{ LP8860_EEPROM_REG_1, 0x00 },
	348	{ LP8860_EEPROM_REG_2, 0x00 },
	349	{ LP8860_EEPROM_REG_3, 0x00 },
	350	{ LP8860_EEPROM_REG_4, 0x00 },
	351	{ LP8860_EEPROM_REG_5, 0x00 },
	352	{ LP8860_EEPROM_REG_6, 0x00 },
	353	{ LP8860_EEPROM_REG_7, 0x00 },
	354	{ LP8860_EEPROM_REG_8, 0x00 },
	355	{ LP8860_EEPROM_REG_9, 0x00 },
	356	{ LP8860_EEPROM_REG_10, 0x00 },
	357	{ LP8860_EEPROM_REG_11, 0x00 },
	358	{ LP8860_EEPROM_REG_12, 0x00 },
	359	{ LP8860_EEPROM_REG_13, 0x00 },
	360	{ LP8860_EEPROM_REG_14, 0x00 },
	361	{ LP8860_EEPROM_REG_15, 0x00 },
	362	{ LP8860_EEPROM_REG_16, 0x00 },
	363	{ LP8860_EEPROM_REG_17, 0x00 },
	364	{ LP8860_EEPROM_REG_18, 0x00 },
	365	{ LP8860_EEPROM_REG_19, 0x00 },
	366	{ LP8860_EEPROM_REG_20, 0x00 },
	367	{ LP8860_EEPROM_REG_21, 0x00 },
	368	{ LP8860_EEPROM_REG_22, 0x00 },
	369	{ LP8860_EEPROM_REG_23, 0x00 },
	370	{ LP8860_EEPROM_REG_24, 0x00 },
	371	};
	372
	373	static const struct regmap_config lp8860_eeprom_regmap_config = {
	374	.reg_bits = 8,
	375	.val_bits = 8,
	376
	377	.max_register = LP8860_EEPROM_REG_24,
	378	.reg_defaults = lp8860_eeprom_defs,
	379	.num_reg_defaults = ARRAY_SIZE(lp8860_eeprom_defs),
	380	.cache_type = REGCACHE_NONE,
	381	};
	382
	383	static int lp8860_probe(struct i2c_client *client,
	384	const struct i2c_device_id *id)
	385	{
	386	int ret;
	387	struct lp8860_led *led;
	388	struct device_node *np = client->dev.of_node;
c6b218c9 DM	389	struct device_node *child_node;
c6b218c9 DM	390	const char *name;
7a8685ac DM	391
	392	led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
	393	if (!led)
	394	return -ENOMEM;
	395
c6b218c9	396	for_each_available_child_of_node(np, child_node) {
50aa46c4 DM	397	led->led_dev.default_trigger = of_get_property(child_node,
	398	"linux,default-trigger",
	399	NULL);
	400
c6b218c9 DM	401	ret = of_property_read_string(child_node, "label", &name);
	402	if (!ret)
	403	snprintf(led->label, sizeof(led->label), "%s:%s",
	404	id->name, name);
	405	else
	406	snprintf(led->label, sizeof(led->label),
	407	"%s::display_cluster", id->name);
7a8685ac DM	408	}
7a8685ac DM	409
eb2294c3 UKK	410	led->enable_gpio = devm_gpiod_get_optional(&client->dev,
	411	"enable", GPIOD_OUT_LOW);
	412	if (IS_ERR(led->enable_gpio)) {
	413	ret = PTR_ERR(led->enable_gpio);
	414	dev_err(&client->dev, "Failed to get enable gpio: %d\n", ret);
	415	return ret;
	416	}
7a8685ac DM	417
	418	led->regulator = devm_regulator_get(&client->dev, "vled");
	419	if (IS_ERR(led->regulator))
	420	led->regulator = NULL;
	421
	422	led->client = client;
	423	led->led_dev.name = led->label;
7c4b10a2	424	led->led_dev.brightness_set_blocking = lp8860_brightness_set;
7a8685ac DM	425
7a8685ac DM	426	mutex_init(&led->lock);
7a8685ac DM	427
	428	i2c_set_clientdata(client, led);
	429
	430	led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config);
	431	if (IS_ERR(led->regmap)) {
	432	ret = PTR_ERR(led->regmap);
	433	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	434	ret);
	435	return ret;
	436	}
	437
	438	led->eeprom_regmap = devm_regmap_init_i2c(client, &lp8860_eeprom_regmap_config);
	439	if (IS_ERR(led->eeprom_regmap)) {
	440	ret = PTR_ERR(led->eeprom_regmap);
	441	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	442	ret);
	443	return ret;
	444	}
	445
	446	ret = lp8860_init(led);
	447	if (ret)
	448	return ret;
	449
a2169c9b	450	ret = devm_led_classdev_register(&client->dev, &led->led_dev);
7a8685ac DM	451	if (ret) {
	452	dev_err(&client->dev, "led register err: %d\n", ret);
	453	return ret;
	454	}
	455
	456	return 0;
	457	}
	458
	459	static int lp8860_remove(struct i2c_client *client)
	460	{
	461	struct lp8860_led *led = i2c_get_clientdata(client);
	462	int ret;
	463
7a8685ac DM	464	if (led->enable_gpio)
	465	gpiod_direction_output(led->enable_gpio, 0);
	466
	467	if (led->regulator) {
	468	ret = regulator_disable(led->regulator);
	469	if (ret)
	470	dev_err(&led->client->dev,
	471	"Failed to disable regulator\n");
	472	}
	473
a2169c9b DM	474	mutex_destroy(&led->lock);
a2169c9b DM	475
7a8685ac DM	476	return 0;
	477	}
	478
	479	static const struct i2c_device_id lp8860_id[] = {
	480	{ "lp8860", 0 },
	481	{ }
	482	};
	483	MODULE_DEVICE_TABLE(i2c, lp8860_id);
	484
7a8685ac DM	485	static const struct of_device_id of_lp8860_leds_match[] = {
	486	{ .compatible = "ti,lp8860", },
	487	{},
	488	};
	489	MODULE_DEVICE_TABLE(of, of_lp8860_leds_match);
7a8685ac DM	490
	491	static struct i2c_driver lp8860_driver = {
	492	.driver = {
	493	.name = "lp8860",
a2169c9b	494	.of_match_table = of_lp8860_leds_match,
7a8685ac DM	495	},
	496	.probe = lp8860_probe,
	497	.remove = lp8860_remove,
	498	.id_table = lp8860_id,
	499	};
	500	module_i2c_driver(lp8860_driver);
	501
5ee047fb	502	MODULE_DESCRIPTION("Texas Instruments LP8860 LED driver");
7a8685ac	503	MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
a2169c9b	504	MODULE_LICENSE("GPL v2");