[mirror_ubuntu-hirsute-kernel.git] / drivers / leds / leds-lm3692x.c

// SPDX-License-Identifier: GPL-2.0
// TI LM3692x LED chip family driver
// Copyright (C) 2017-18 Texas Instruments Incorporated - http://www.ti.com/

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

#define LM36922_MODEL	0
#define LM36923_MODEL	1

#define LM3692X_REV		0x0
#define LM3692X_RESET		0x1
#define LM3692X_EN		0x10
#define LM3692X_BRT_CTRL	0x11
#define LM3692X_PWM_CTRL	0x12
#define LM3692X_BOOST_CTRL	0x13
#define LM3692X_AUTO_FREQ_HI	0x15
#define LM3692X_AUTO_FREQ_LO	0x16
#define LM3692X_BL_ADJ_THRESH	0x17
#define LM3692X_BRT_LSB		0x18
#define LM3692X_BRT_MSB		0x19
#define LM3692X_FAULT_CTRL	0x1e
#define LM3692X_FAULT_FLAGS	0x1f

#define LM3692X_SW_RESET	BIT(0)
#define LM3692X_DEVICE_EN	BIT(0)
#define LM3692X_LED1_EN		BIT(1)
#define LM3692X_LED2_EN		BIT(2)
#define LM36923_LED3_EN		BIT(3)
#define LM3692X_ENABLE_MASK	(LM3692X_DEVICE_EN | LM3692X_LED1_EN | \
				 LM3692X_LED2_EN | LM36923_LED3_EN)

/* Brightness Control Bits */
#define LM3692X_BL_ADJ_POL	BIT(0)
#define LM3692X_RAMP_RATE_125us	0x00
#define LM3692X_RAMP_RATE_250us	BIT(1)
#define LM3692X_RAMP_RATE_500us BIT(2)
#define LM3692X_RAMP_RATE_1ms	(BIT(1) | BIT(2))
#define LM3692X_RAMP_RATE_2ms	BIT(3)
#define LM3692X_RAMP_RATE_4ms	(BIT(3) | BIT(1))
#define LM3692X_RAMP_RATE_8ms	(BIT(2) | BIT(3))
#define LM3692X_RAMP_RATE_16ms	(BIT(1) | BIT(2) | BIT(3))
#define LM3692X_RAMP_EN		BIT(4)
#define LM3692X_BRHT_MODE_REG	0x00
#define LM3692X_BRHT_MODE_PWM	BIT(5)
#define LM3692X_BRHT_MODE_MULTI_RAMP BIT(6)
#define LM3692X_BRHT_MODE_RAMP_MULTI (BIT(5) | BIT(6))
#define LM3692X_MAP_MODE_EXP	BIT(7)

/* PWM Register Bits */
#define LM3692X_PWM_FILTER_100	BIT(0)
#define LM3692X_PWM_FILTER_150	BIT(1)
#define LM3692X_PWM_FILTER_200	(BIT(0) | BIT(1))
#define LM3692X_PWM_HYSTER_1LSB BIT(2)
#define LM3692X_PWM_HYSTER_2LSB	BIT(3)
#define LM3692X_PWM_HYSTER_3LSB (BIT(3) | BIT(2))
#define LM3692X_PWM_HYSTER_4LSB BIT(4)
#define LM3692X_PWM_HYSTER_5LSB (BIT(4) | BIT(2))
#define LM3692X_PWM_HYSTER_6LSB (BIT(4) | BIT(3))
#define LM3692X_PWM_POLARITY	BIT(5)
#define LM3692X_PWM_SAMP_4MHZ	BIT(6)
#define LM3692X_PWM_SAMP_24MHZ	BIT(7)

/* Boost Control Bits */
#define LM3692X_OCP_PROT_1A	BIT(0)
#define LM3692X_OCP_PROT_1_25A	BIT(1)
#define LM3692X_OCP_PROT_1_5A	(BIT(0) | BIT(1))
#define LM3692X_OVP_21V		BIT(2)
#define LM3692X_OVP_25V		BIT(3)
#define LM3692X_OVP_29V		(BIT(2) | BIT(3))
#define LM3692X_MIN_IND_22UH	BIT(4)
#define LM3692X_BOOST_SW_1MHZ	BIT(5)
#define LM3692X_BOOST_SW_NO_SHIFT	BIT(6)

/* Fault Control Bits */
#define LM3692X_FAULT_CTRL_OVP BIT(0)
#define LM3692X_FAULT_CTRL_OCP BIT(1)
#define LM3692X_FAULT_CTRL_TSD BIT(2)
#define LM3692X_FAULT_CTRL_OPEN BIT(3)

/* Fault Flag Bits */
#define LM3692X_FAULT_FLAG_OVP BIT(0)
#define LM3692X_FAULT_FLAG_OCP BIT(1)
#define LM3692X_FAULT_FLAG_TSD BIT(2)
#define LM3692X_FAULT_FLAG_SHRT BIT(3)
#define LM3692X_FAULT_FLAG_OPEN BIT(4)

/**
 * struct lm3692x_led -
 * @lock - Lock for reading/writing the device
 * @client - Pointer to the I2C client
 * @led_dev - LED class device pointer
 * @regmap - Devices register map
 * @enable_gpio - VDDIO/EN gpio to enable communication interface
 * @regulator - LED supply regulator pointer
 * @led_enable - LED sync to be enabled
 * @model_id - Current device model ID enumerated
 */
struct lm3692x_led {
	struct mutex lock;
	struct i2c_client *client;
	struct led_classdev led_dev;
	struct regmap *regmap;
	struct gpio_desc *enable_gpio;
	struct regulator *regulator;
	int led_enable;
	int model_id;

	u8 boost_ctrl;
};

static const struct reg_default lm3692x_reg_defs[] = {
	{LM3692X_EN, 0xf},
	{LM3692X_BRT_CTRL, 0x61},
	{LM3692X_PWM_CTRL, 0x73},
	{LM3692X_BOOST_CTRL, 0x6f},
	{LM3692X_AUTO_FREQ_HI, 0x0},
	{LM3692X_AUTO_FREQ_LO, 0x0},
	{LM3692X_BL_ADJ_THRESH, 0x0},
	{LM3692X_BRT_LSB, 0x7},
	{LM3692X_BRT_MSB, 0xff},
	{LM3692X_FAULT_CTRL, 0x7},
};

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

	.max_register = LM3692X_FAULT_FLAGS,
	.reg_defaults = lm3692x_reg_defs,
	.num_reg_defaults = ARRAY_SIZE(lm3692x_reg_defs),
	.cache_type = REGCACHE_RBTREE,
};

static int lm3692x_fault_check(struct lm3692x_led *led)
{
	int ret;
	unsigned int read_buf;

	ret = regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
	if (ret)
		return ret;

	if (read_buf)
		dev_err(&led->client->dev, "Detected a fault 0x%X\n", read_buf);

	/* The first read may clear the fault.  Check again to see if the fault
	 * still exits and return that value.
	 */
	regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
	if (read_buf)
		dev_err(&led->client->dev, "Second read of fault flags 0x%X\n",
			read_buf);

	return read_buf;
}

static int lm3692x_leds_enable(struct lm3692x_led *led)
{
	int enable_state;
	int ret, reg_ret;

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

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

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

	ret = regmap_write(led->regmap, LM3692X_BRT_CTRL, 0x00);
	if (ret)
		goto out;

	/*
	 * For glitch free operation, the following data should
	 * only be written while LEDx enable bits are 0 and the device enable
	 * bit is set to 1.
	 * per Section 7.5.14 of the data sheet
	 */
	ret = regmap_write(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN);
	if (ret)
		goto out;

	/* Set the brightness to 0 so when enabled the LEDs do not come
	 * on with full brightness.
	 */
	ret = regmap_write(led->regmap, LM3692X_BRT_MSB, 0);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_BRT_LSB, 0);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_PWM_CTRL,
		LM3692X_PWM_FILTER_100 | LM3692X_PWM_SAMP_24MHZ);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_BOOST_CTRL, led->boost_ctrl);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_HI, 0x00);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_LO, 0x00);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_BL_ADJ_THRESH, 0x00);
	if (ret)
		goto out;

	ret = regmap_write(led->regmap, LM3692X_BRT_CTRL,
			LM3692X_BL_ADJ_POL | LM3692X_RAMP_EN);
	if (ret)
		goto out;

	switch (led->led_enable) {
	case 0:
	default:
		if (led->model_id == LM36923_MODEL)
			enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN |
			       LM36923_LED3_EN;
		else
			enable_state = LM3692X_LED1_EN | LM3692X_LED2_EN;

		break;
	case 1:
		enable_state = LM3692X_LED1_EN;
		break;
	case 2:
		enable_state = LM3692X_LED2_EN;
		break;

	case 3:
		if (led->model_id == LM36923_MODEL) {
			enable_state = LM36923_LED3_EN;
			break;
		}

		ret = -EINVAL;
		dev_err(&led->client->dev,
			"LED3 sync not available on this device\n");
		goto out;
	}

	ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_ENABLE_MASK,
				 enable_state | LM3692X_DEVICE_EN);

	return ret;
out:
	dev_err(&led->client->dev, "Fail writing initialization values\n");

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

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

	return ret;
}

static int lm3692x_leds_disable(struct lm3692x_led *led)
{
	int ret;

	ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN, 0);
	if (ret) {
		dev_err(&led->client->dev, "Failed to disable regulator: %d\n",
			ret);
		return 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: %d\n", ret);
	}

	return ret;
}

static int lm3692x_brightness_set(struct led_classdev *led_cdev,
				enum led_brightness brt_val)
{
	struct lm3692x_led *led =
			container_of(led_cdev, struct lm3692x_led, led_dev);
	int ret;
	int led_brightness_lsb = (brt_val >> 5);

	mutex_lock(&led->lock);

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

	ret = regmap_write(led->regmap, LM3692X_BRT_MSB, brt_val);
	if (ret) {
		dev_err(&led->client->dev, "Cannot write MSB: %d\n", ret);
		goto out;
	}

	ret = regmap_write(led->regmap, LM3692X_BRT_LSB, led_brightness_lsb);
	if (ret) {
		dev_err(&led->client->dev, "Cannot write LSB: %d\n", ret);
		goto out;
	}
out:
	mutex_unlock(&led->lock);
	return ret;
}

static enum led_brightness lm3692x_max_brightness(struct lm3692x_led *led,
						  u32 max_cur)
{
	u32 max_code;

	/* see p.12 of LM36922 data sheet for brightness formula */
	max_code = ((max_cur * 1000) - 37806) / 12195;
	if (max_code > 0x7FF)
		max_code = 0x7FF;

	return max_code >> 3;
}

static int lm3692x_probe_dt(struct lm3692x_led *led)
{
	struct fwnode_handle *child = NULL;
	struct led_init_data init_data = {};
	u32 ovp, max_cur;
	int ret;

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

	led->regulator = devm_regulator_get_optional(&led->client->dev, "vled");
	if (IS_ERR(led->regulator)) {
		ret = PTR_ERR(led->regulator);
		if (ret != -ENODEV) {
			if (ret != -EPROBE_DEFER)
				dev_err(&led->client->dev,
					"Failed to get vled regulator: %d\n",
					ret);
			return ret;
		}
		led->regulator = NULL;
	}

	led->boost_ctrl = LM3692X_BOOST_SW_1MHZ |
		LM3692X_BOOST_SW_NO_SHIFT |
		LM3692X_OCP_PROT_1_5A;
	ret = device_property_read_u32(&led->client->dev,
				       "ti,ovp-microvolt", &ovp);
	if (ret) {
		led->boost_ctrl |= LM3692X_OVP_29V;
	} else {
		switch (ovp) {
		case 17000000:
			break;
		case 21000000:
			led->boost_ctrl |= LM3692X_OVP_21V;
			break;
		case 25000000:
			led->boost_ctrl |= LM3692X_OVP_25V;
			break;
		case 29000000:
			led->boost_ctrl |= LM3692X_OVP_29V;
			break;
		default:
			dev_err(&led->client->dev, "Invalid OVP %d\n", ovp);
			return -EINVAL;
		}
	}

	child = device_get_next_child_node(&led->client->dev, child);
	if (!child) {
		dev_err(&led->client->dev, "No LED Child node\n");
		return -ENODEV;
	}

	fwnode_property_read_string(child, "linux,default-trigger",
				    &led->led_dev.default_trigger);

	ret = fwnode_property_read_u32(child, "reg", &led->led_enable);
	if (ret) {
		dev_err(&led->client->dev, "reg DT property missing\n");
		return ret;
	}

	ret = fwnode_property_read_u32(child, "led-max-microamp", &max_cur);
	led->led_dev.max_brightness = ret ? LED_FULL :
		lm3692x_max_brightness(led, max_cur);

	init_data.fwnode = child;
	init_data.devicename = led->client->name;
	init_data.default_label = ":";

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

	return 0;
}

static int lm3692x_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct lm3692x_led *led;
	int ret;

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

	mutex_init(&led->lock);
	led->client = client;
	led->led_dev.brightness_set_blocking = lm3692x_brightness_set;
	led->model_id = id->driver_data;
	i2c_set_clientdata(client, led);

	led->regmap = devm_regmap_init_i2c(client, &lm3692x_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;
	}

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

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

	return 0;
}

static int lm3692x_remove(struct i2c_client *client)
{
	struct lm3692x_led *led = i2c_get_clientdata(client);
	int ret;

	ret = lm3692x_leds_disable(led);
	if (ret)
		return ret;
	mutex_destroy(&led->lock);

	return 0;
}

static const struct i2c_device_id lm3692x_id[] = {
	{ "lm36922", LM36922_MODEL },
	{ "lm36923", LM36923_MODEL },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lm3692x_id);

static const struct of_device_id of_lm3692x_leds_match[] = {
	{ .compatible = "ti,lm36922", },
	{ .compatible = "ti,lm36923", },
	{},
};
MODULE_DEVICE_TABLE(of, of_lm3692x_leds_match);

static struct i2c_driver lm3692x_driver = {
	.driver = {
		.name	= "lm3692x",
		.of_match_table = of_lm3692x_leds_match,
	},
	.probe		= lm3692x_probe,
	.remove		= lm3692x_remove,
	.id_table	= lm3692x_id,
};
module_i2c_driver(lm3692x_driver);

MODULE_DESCRIPTION("Texas Instruments LM3692X LED driver");
MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
43d20ff3 DM	1	// SPDX-License-Identifier: GPL-2.0
	2	// TI LM3692x LED chip family driver
	3	// Copyright (C) 2017-18 Texas Instruments Incorporated - http://www.ti.com/
9699cb6b DM	4
	5	#include <linux/gpio/consumer.h>
	6	#include <linux/i2c.h>
	7	#include <linux/init.h>
	8	#include <linux/leds.h>
df7083b5	9	#include <linux/log2.h>
9699cb6b DM	10	#include <linux/module.h>
	11	#include <linux/mutex.h>
	12	#include <linux/of.h>
	13	#include <linux/of_gpio.h>
	14	#include <linux/regmap.h>
	15	#include <linux/regulator/consumer.h>
	16	#include <linux/slab.h>
9699cb6b	17
07abd432 DM	18	#define LM36922_MODEL 0
	19	#define LM36923_MODEL 1
	20
9699cb6b DM	21	#define LM3692X_REV 0x0
	22	#define LM3692X_RESET 0x1
	23	#define LM3692X_EN 0x10
	24	#define LM3692X_BRT_CTRL 0x11
	25	#define LM3692X_PWM_CTRL 0x12
	26	#define LM3692X_BOOST_CTRL 0x13
	27	#define LM3692X_AUTO_FREQ_HI 0x15
	28	#define LM3692X_AUTO_FREQ_LO 0x16
	29	#define LM3692X_BL_ADJ_THRESH 0x17
	30	#define LM3692X_BRT_LSB 0x18
	31	#define LM3692X_BRT_MSB 0x19
	32	#define LM3692X_FAULT_CTRL 0x1e
	33	#define LM3692X_FAULT_FLAGS 0x1f
	34
	35	#define LM3692X_SW_RESET BIT(0)
	36	#define LM3692X_DEVICE_EN BIT(0)
	37	#define LM3692X_LED1_EN BIT(1)
	38	#define LM3692X_LED2_EN BIT(2)
07abd432 DM	39	#define LM36923_LED3_EN BIT(3)
	40	#define LM3692X_ENABLE_MASK (LM3692X_DEVICE_EN \| LM3692X_LED1_EN \| \
	41	LM3692X_LED2_EN \| LM36923_LED3_EN)
9699cb6b DM	42
	43	/* Brightness Control Bits */
	44	#define LM3692X_BL_ADJ_POL BIT(0)
	45	#define LM3692X_RAMP_RATE_125us 0x00
	46	#define LM3692X_RAMP_RATE_250us BIT(1)
	47	#define LM3692X_RAMP_RATE_500us BIT(2)
	48	#define LM3692X_RAMP_RATE_1ms (BIT(1) \| BIT(2))
	49	#define LM3692X_RAMP_RATE_2ms BIT(3)
	50	#define LM3692X_RAMP_RATE_4ms (BIT(3) \| BIT(1))
	51	#define LM3692X_RAMP_RATE_8ms (BIT(2) \| BIT(3))
	52	#define LM3692X_RAMP_RATE_16ms (BIT(1) \| BIT(2) \| BIT(3))
	53	#define LM3692X_RAMP_EN BIT(4)
	54	#define LM3692X_BRHT_MODE_REG 0x00
	55	#define LM3692X_BRHT_MODE_PWM BIT(5)
	56	#define LM3692X_BRHT_MODE_MULTI_RAMP BIT(6)
	57	#define LM3692X_BRHT_MODE_RAMP_MULTI (BIT(5) \| BIT(6))
	58	#define LM3692X_MAP_MODE_EXP BIT(7)
	59
	60	/* PWM Register Bits */
	61	#define LM3692X_PWM_FILTER_100 BIT(0)
	62	#define LM3692X_PWM_FILTER_150 BIT(1)
	63	#define LM3692X_PWM_FILTER_200 (BIT(0) \| BIT(1))
	64	#define LM3692X_PWM_HYSTER_1LSB BIT(2)
	65	#define LM3692X_PWM_HYSTER_2LSB BIT(3)
	66	#define LM3692X_PWM_HYSTER_3LSB (BIT(3) \| BIT(2))
	67	#define LM3692X_PWM_HYSTER_4LSB BIT(4)
	68	#define LM3692X_PWM_HYSTER_5LSB (BIT(4) \| BIT(2))
	69	#define LM3692X_PWM_HYSTER_6LSB (BIT(4) \| BIT(3))
	70	#define LM3692X_PWM_POLARITY BIT(5)
	71	#define LM3692X_PWM_SAMP_4MHZ BIT(6)
	72	#define LM3692X_PWM_SAMP_24MHZ BIT(7)
	73
	74	/* Boost Control Bits */
	75	#define LM3692X_OCP_PROT_1A BIT(0)
	76	#define LM3692X_OCP_PROT_1_25A BIT(1)
	77	#define LM3692X_OCP_PROT_1_5A (BIT(0) \| BIT(1))
	78	#define LM3692X_OVP_21V BIT(2)
	79	#define LM3692X_OVP_25V BIT(3)
	80	#define LM3692X_OVP_29V (BIT(2) \| BIT(3))
	81	#define LM3692X_MIN_IND_22UH BIT(4)
	82	#define LM3692X_BOOST_SW_1MHZ BIT(5)
	83	#define LM3692X_BOOST_SW_NO_SHIFT BIT(6)
	84
	85	/* Fault Control Bits */
	86	#define LM3692X_FAULT_CTRL_OVP BIT(0)
	87	#define LM3692X_FAULT_CTRL_OCP BIT(1)
	88	#define LM3692X_FAULT_CTRL_TSD BIT(2)
	89	#define LM3692X_FAULT_CTRL_OPEN BIT(3)
	90
	91	/* Fault Flag Bits */
	92	#define LM3692X_FAULT_FLAG_OVP BIT(0)
	93	#define LM3692X_FAULT_FLAG_OCP BIT(1)
	94	#define LM3692X_FAULT_FLAG_TSD BIT(2)
	95	#define LM3692X_FAULT_FLAG_SHRT BIT(3)
	96	#define LM3692X_FAULT_FLAG_OPEN BIT(4)
	97
	98	/**
	99	* struct lm3692x_led -
	100	* @lock - Lock for reading/writing the device
	101	* @client - Pointer to the I2C client
	102	* @led_dev - LED class device pointer
	103	* @regmap - Devices register map
	104	* @enable_gpio - VDDIO/EN gpio to enable communication interface
	105	* @regulator - LED supply regulator pointer
07abd432 DM	106	* @led_enable - LED sync to be enabled
07abd432 DM	107	* @model_id - Current device model ID enumerated
9699cb6b DM	108	*/
	109	struct lm3692x_led {
	110	struct mutex lock;
	111	struct i2c_client *client;
	112	struct led_classdev led_dev;
	113	struct regmap *regmap;
	114	struct gpio_desc *enable_gpio;
	115	struct regulator *regulator;
07abd432 DM	116	int led_enable;
07abd432 DM	117	int model_id;
cffd61a5 GG	118
cffd61a5 GG	119	u8 boost_ctrl;
9699cb6b DM	120	};
	121
	122	static const struct reg_default lm3692x_reg_defs[] = {
	123	{LM3692X_EN, 0xf},
	124	{LM3692X_BRT_CTRL, 0x61},
	125	{LM3692X_PWM_CTRL, 0x73},
	126	{LM3692X_BOOST_CTRL, 0x6f},
	127	{LM3692X_AUTO_FREQ_HI, 0x0},
	128	{LM3692X_AUTO_FREQ_LO, 0x0},
	129	{LM3692X_BL_ADJ_THRESH, 0x0},
	130	{LM3692X_BRT_LSB, 0x7},
	131	{LM3692X_BRT_MSB, 0xff},
	132	{LM3692X_FAULT_CTRL, 0x7},
	133	};
	134
	135	static const struct regmap_config lm3692x_regmap_config = {
	136	.reg_bits = 8,
	137	.val_bits = 8,
	138
	139	.max_register = LM3692X_FAULT_FLAGS,
	140	.reg_defaults = lm3692x_reg_defs,
	141	.num_reg_defaults = ARRAY_SIZE(lm3692x_reg_defs),
	142	.cache_type = REGCACHE_RBTREE,
	143	};
	144
	145	static int lm3692x_fault_check(struct lm3692x_led *led)
	146	{
	147	int ret;
	148	unsigned int read_buf;
	149
	150	ret = regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
	151	if (ret)
	152	return ret;
	153
	154	if (read_buf)
	155	dev_err(&led->client->dev, "Detected a fault 0x%X\n", read_buf);
	156
	157	/* The first read may clear the fault. Check again to see if the fault
	158	* still exits and return that value.
	159	*/
	160	regmap_read(led->regmap, LM3692X_FAULT_FLAGS, &read_buf);
	161	if (read_buf)
	162	dev_err(&led->client->dev, "Second read of fault flags 0x%X\n",
	163	read_buf);
	164
	165	return read_buf;
	166	}
	167
5e9d7b6f	168	static int lm3692x_leds_enable(struct lm3692x_led *led)
9699cb6b	169	{
07abd432	170	int enable_state;
d0f9cc49	171	int ret, reg_ret;
9699cb6b DM	172
	173	if (led->regulator) {
	174	ret = regulator_enable(led->regulator);
	175	if (ret) {
	176	dev_err(&led->client->dev,
1051da2c	177	"Failed to enable regulator: %d\n", ret);
9699cb6b DM	178	return ret;
	179	}
	180	}
	181
	182	if (led->enable_gpio)
	183	gpiod_direction_output(led->enable_gpio, 1);
	184
	185	ret = lm3692x_fault_check(led);
	186	if (ret) {
1051da2c GG	187	dev_err(&led->client->dev, "Cannot read/clear faults: %d\n",
1051da2c GG	188	ret);
9699cb6b DM	189	goto out;
	190	}
	191
	192	ret = regmap_write(led->regmap, LM3692X_BRT_CTRL, 0x00);
	193	if (ret)
	194	goto out;
	195
	196	/*
	197	* For glitch free operation, the following data should
07abd432 DM	198	* only be written while LEDx enable bits are 0 and the device enable
07abd432 DM	199	* bit is set to 1.
9699cb6b DM	200	* per Section 7.5.14 of the data sheet
9699cb6b DM	201	*/
07abd432 DM	202	ret = regmap_write(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN);
	203	if (ret)
	204	goto out;
	205
	206	/* Set the brightness to 0 so when enabled the LEDs do not come
	207	* on with full brightness.
	208	*/
	209	ret = regmap_write(led->regmap, LM3692X_BRT_MSB, 0);
	210	if (ret)
	211	goto out;
	212
	213	ret = regmap_write(led->regmap, LM3692X_BRT_LSB, 0);
	214	if (ret)
	215	goto out;
	216
9699cb6b DM	217	ret = regmap_write(led->regmap, LM3692X_PWM_CTRL,
	218	LM3692X_PWM_FILTER_100 \| LM3692X_PWM_SAMP_24MHZ);
	219	if (ret)
	220	goto out;
	221
cffd61a5	222	ret = regmap_write(led->regmap, LM3692X_BOOST_CTRL, led->boost_ctrl);
9699cb6b DM	223	if (ret)
	224	goto out;
	225
	226	ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_HI, 0x00);
	227	if (ret)
	228	goto out;
	229
	230	ret = regmap_write(led->regmap, LM3692X_AUTO_FREQ_LO, 0x00);
	231	if (ret)
	232	goto out;
	233
	234	ret = regmap_write(led->regmap, LM3692X_BL_ADJ_THRESH, 0x00);
	235	if (ret)
	236	goto out;
	237
	238	ret = regmap_write(led->regmap, LM3692X_BRT_CTRL,
da61a66a	239	LM3692X_BL_ADJ_POL \| LM3692X_RAMP_EN);
9699cb6b DM	240	if (ret)
	241	goto out;
	242
07abd432 DM	243	switch (led->led_enable) {
	244	case 0:
	245	default:
	246	if (led->model_id == LM36923_MODEL)
	247	enable_state = LM3692X_LED1_EN \| LM3692X_LED2_EN \|
	248	LM36923_LED3_EN;
	249	else
	250	enable_state = LM3692X_LED1_EN \| LM3692X_LED2_EN;
	251
	252	break;
	253	case 1:
	254	enable_state = LM3692X_LED1_EN;
	255	break;
	256	case 2:
	257	enable_state = LM3692X_LED2_EN;
	258	break;
	259
	260	case 3:
	261	if (led->model_id == LM36923_MODEL) {
	262	enable_state = LM36923_LED3_EN;
	263	break;
	264	}
	265
	266	ret = -EINVAL;
	267	dev_err(&led->client->dev,
	268	"LED3 sync not available on this device\n");
	269	goto out;
	270	}
	271
	272	ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_ENABLE_MASK,
	273	enable_state \| LM3692X_DEVICE_EN);
	274
9699cb6b DM	275	return ret;
	276	out:
	277	dev_err(&led->client->dev, "Fail writing initialization values\n");
	278
	279	if (led->enable_gpio)
	280	gpiod_direction_output(led->enable_gpio, 0);
	281
	282	if (led->regulator) {
d0f9cc49 GG	283	reg_ret = regulator_disable(led->regulator);
d0f9cc49 GG	284	if (reg_ret)
9699cb6b	285	dev_err(&led->client->dev,
d0f9cc49	286	"Failed to disable regulator: %d\n", reg_ret);
9699cb6b DM	287	}
	288
	289	return ret;
	290	}
d0f9cc49	291
4a8d2bee GG	292	static int lm3692x_leds_disable(struct lm3692x_led *led)
	293	{
	294	int ret;
	295
	296	ret = regmap_update_bits(led->regmap, LM3692X_EN, LM3692X_DEVICE_EN, 0);
	297	if (ret) {
	298	dev_err(&led->client->dev, "Failed to disable regulator: %d\n",
	299	ret);
	300	return ret;
	301	}
	302
	303	if (led->enable_gpio)
	304	gpiod_direction_output(led->enable_gpio, 0);
	305
	306	if (led->regulator) {
	307	ret = regulator_disable(led->regulator);
	308	if (ret)
	309	dev_err(&led->client->dev,
	310	"Failed to disable regulator: %d\n", ret);
	311	}
	312
	313	return ret;
	314	}
	315
5e9d7b6f GG	316	static int lm3692x_brightness_set(struct led_classdev *led_cdev,
	317	enum led_brightness brt_val)
	318	{
	319	struct lm3692x_led *led =
	320	container_of(led_cdev, struct lm3692x_led, led_dev);
	321	int ret;
	322	int led_brightness_lsb = (brt_val >> 5);
	323
	324	mutex_lock(&led->lock);
	325
	326	ret = lm3692x_fault_check(led);
	327	if (ret) {
	328	dev_err(&led->client->dev, "Cannot read/clear faults: %d\n",
	329	ret);
	330	goto out;
	331	}
	332
	333	ret = regmap_write(led->regmap, LM3692X_BRT_MSB, brt_val);
	334	if (ret) {
	335	dev_err(&led->client->dev, "Cannot write MSB: %d\n", ret);
	336	goto out;
	337	}
	338
	339	ret = regmap_write(led->regmap, LM3692X_BRT_LSB, led_brightness_lsb);
	340	if (ret) {
	341	dev_err(&led->client->dev, "Cannot write LSB: %d\n", ret);
	342	goto out;
	343	}
	344	out:
	345	mutex_unlock(&led->lock);
	346	return ret;
	347	}
	348
df7083b5 GG	349	static enum led_brightness lm3692x_max_brightness(struct lm3692x_led *led,
	350	u32 max_cur)
	351	{
	352	u32 max_code;
	353
	354	/* see p.12 of LM36922 data sheet for brightness formula */
	355	max_code = ((max_cur * 1000) - 37806) / 12195;
	356	if (max_code > 0x7FF)
	357	max_code = 0x7FF;
	358
	359	return max_code >> 3;
	360	}
	361
07abd432	362	static int lm3692x_probe_dt(struct lm3692x_led *led)
9699cb6b	363	{
9a5c1c64	364	struct fwnode_handle *child = NULL;
a50ff283	365	struct led_init_data init_data = {};
df7083b5	366	u32 ovp, max_cur;
9a5c1c64	367	int ret;
9699cb6b	368
07abd432	369	led->enable_gpio = devm_gpiod_get_optional(&led->client->dev,
9699cb6b DM	370	"enable", GPIOD_OUT_LOW);
	371	if (IS_ERR(led->enable_gpio)) {
	372	ret = PTR_ERR(led->enable_gpio);
07abd432 DM	373	dev_err(&led->client->dev, "Failed to get enable gpio: %d\n",
07abd432 DM	374	ret);
9699cb6b DM	375	return ret;
	376	}
	377
396128d2 GG	378	led->regulator = devm_regulator_get_optional(&led->client->dev, "vled");
	379	if (IS_ERR(led->regulator)) {
	380	ret = PTR_ERR(led->regulator);
	381	if (ret != -ENODEV) {
	382	if (ret != -EPROBE_DEFER)
	383	dev_err(&led->client->dev,
	384	"Failed to get vled regulator: %d\n",
	385	ret);
	386	return ret;
	387	}
9699cb6b	388	led->regulator = NULL;
396128d2	389	}
9699cb6b	390
cffd61a5 GG	391	led->boost_ctrl = LM3692X_BOOST_SW_1MHZ \|
	392	LM3692X_BOOST_SW_NO_SHIFT \|
	393	LM3692X_OCP_PROT_1_5A;
	394	ret = device_property_read_u32(&led->client->dev,
	395	"ti,ovp-microvolt", &ovp);
	396	if (ret) {
	397	led->boost_ctrl \|= LM3692X_OVP_29V;
	398	} else {
	399	switch (ovp) {
	400	case 17000000:
	401	break;
	402	case 21000000:
	403	led->boost_ctrl \|= LM3692X_OVP_21V;
	404	break;
	405	case 25000000:
	406	led->boost_ctrl \|= LM3692X_OVP_25V;
	407	break;
	408	case 29000000:
	409	led->boost_ctrl \|= LM3692X_OVP_29V;
	410	break;
	411	default:
	412	dev_err(&led->client->dev, "Invalid OVP %d\n", ovp);
	413	return -EINVAL;
	414	}
	415	}
	416
9a5c1c64 DM	417	child = device_get_next_child_node(&led->client->dev, child);
	418	if (!child) {
	419	dev_err(&led->client->dev, "No LED Child node\n");
07abd432	420	return -ENODEV;
9a5c1c64 DM	421	}
	422
	423	fwnode_property_read_string(child, "linux,default-trigger",
	424	&led->led_dev.default_trigger);
	425
07abd432 DM	426	ret = fwnode_property_read_u32(child, "reg", &led->led_enable);
	427	if (ret) {
	428	dev_err(&led->client->dev, "reg DT property missing\n");
	429	return ret;
	430	}
	431
df7083b5 GG	432	ret = fwnode_property_read_u32(child, "led-max-microamp", &max_cur);
	433	led->led_dev.max_brightness = ret ? LED_FULL :
	434	lm3692x_max_brightness(led, max_cur);
	435
a50ff283 JA	436	init_data.fwnode = child;
	437	init_data.devicename = led->client->name;
	438	init_data.default_label = ":";
9a5c1c64	439
a50ff283 JA	440	ret = devm_led_classdev_register_ext(&led->client->dev, &led->led_dev,
a50ff283 JA	441	&init_data);
9699cb6b	442	if (ret) {
07abd432 DM	443	dev_err(&led->client->dev, "led register err: %d\n", ret);
	444	return ret;
	445	}
	446
07abd432 DM	447	return 0;
	448	}
	449
	450	static int lm3692x_probe(struct i2c_client *client,
	451	const struct i2c_device_id *id)
	452	{
	453	struct lm3692x_led *led;
	454	int ret;
	455
	456	led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
	457	if (!led)
	458	return -ENOMEM;
	459
	460	mutex_init(&led->lock);
	461	led->client = client;
	462	led->led_dev.brightness_set_blocking = lm3692x_brightness_set;
	463	led->model_id = id->driver_data;
	464	i2c_set_clientdata(client, led);
	465
	466	led->regmap = devm_regmap_init_i2c(client, &lm3692x_regmap_config);
	467	if (IS_ERR(led->regmap)) {
	468	ret = PTR_ERR(led->regmap);
	469	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	470	ret);
9699cb6b DM	471	return ret;
	472	}
	473
07abd432 DM	474	ret = lm3692x_probe_dt(led);
	475	if (ret)
	476	return ret;
	477
5e9d7b6f	478	ret = lm3692x_leds_enable(led);
07abd432 DM	479	if (ret)
	480	return ret;
	481
9699cb6b DM	482	return 0;
	483	}
	484
	485	static int lm3692x_remove(struct i2c_client *client)
	486	{
	487	struct lm3692x_led *led = i2c_get_clientdata(client);
	488	int ret;
	489
4a8d2bee GG	490	ret = lm3692x_leds_disable(led);
4a8d2bee GG	491	if (ret)
07abd432	492	return ret;
9699cb6b DM	493	mutex_destroy(&led->lock);
	494
	495	return 0;
	496	}
	497
	498	static const struct i2c_device_id lm3692x_id[] = {
07abd432 DM	499	{ "lm36922", LM36922_MODEL },
07abd432 DM	500	{ "lm36923", LM36923_MODEL },
9699cb6b DM	501	{ }
	502	};
	503	MODULE_DEVICE_TABLE(i2c, lm3692x_id);
	504
	505	static const struct of_device_id of_lm3692x_leds_match[] = {
	506	{ .compatible = "ti,lm36922", },
	507	{ .compatible = "ti,lm36923", },
	508	{},
	509	};
	510	MODULE_DEVICE_TABLE(of, of_lm3692x_leds_match);
	511
	512	static struct i2c_driver lm3692x_driver = {
	513	.driver = {
	514	.name = "lm3692x",
	515	.of_match_table = of_lm3692x_leds_match,
	516	},
	517	.probe = lm3692x_probe,
	518	.remove = lm3692x_remove,
	519	.id_table = lm3692x_id,
	520	};
	521	module_i2c_driver(lm3692x_driver);
	522
	523	MODULE_DESCRIPTION("Texas Instruments LM3692X LED driver");
	524	MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
	525	MODULE_LICENSE("GPL v2");