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

// SPDX-License-Identifier: GPL-2.0
// TI LM3532 LED driver
// Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/

#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/regmap.h>
#include <linux/types.h>
#include <linux/regulator/consumer.h>
#include <linux/module.h>
#include <uapi/linux/uleds.h>
#include <linux/gpio/consumer.h>

#define LM3532_NAME "lm3532-led"
#define LM3532_BL_MODE_MANUAL	0x00
#define LM3532_BL_MODE_ALS	0x01

#define LM3532_REG_OUTPUT_CFG	0x10
#define LM3532_REG_STARTSHUT_RAMP	0x11
#define LM3532_REG_RT_RAMP	0x12
#define LM3532_REG_PWM_A_CFG	0x13
#define LM3532_REG_PWM_B_CFG	0x14
#define LM3532_REG_PWM_C_CFG	0x15
#define LM3532_REG_ZONE_CFG_A	0x16
#define LM3532_REG_CTRL_A_BRT	0x17
#define LM3532_REG_ZONE_CFG_B	0x18
#define LM3532_REG_CTRL_B_BRT	0x19
#define LM3532_REG_ZONE_CFG_C	0x1a
#define LM3532_REG_CTRL_C_BRT	0x1b
#define LM3532_REG_ENABLE	0x1d
#define LM3532_ALS_CONFIG	0x23
#define LM3532_REG_ZN_0_HI	0x60
#define LM3532_REG_ZN_0_LO	0x61
#define LM3532_REG_ZN_1_HI	0x62
#define LM3532_REG_ZN_1_LO	0x63
#define LM3532_REG_ZN_2_HI	0x64
#define LM3532_REG_ZN_2_LO	0x65
#define LM3532_REG_ZN_3_HI	0x66
#define LM3532_REG_ZN_3_LO	0x67
#define LM3532_REG_MAX		0x7e

/* Contorl Enable */
#define LM3532_CTRL_A_ENABLE	BIT(0)
#define LM3532_CTRL_B_ENABLE	BIT(1)
#define LM3532_CTRL_C_ENABLE	BIT(2)

/* PWM Zone Control */
#define LM3532_PWM_ZONE_MASK	0x7c
#define LM3532_PWM_ZONE_0_EN	BIT(2)
#define LM3532_PWM_ZONE_1_EN	BIT(3)
#define LM3532_PWM_ZONE_2_EN	BIT(4)
#define LM3532_PWM_ZONE_3_EN	BIT(5)
#define LM3532_PWM_ZONE_4_EN	BIT(6)

/* Brightness Configuration */
#define LM3532_I2C_CTRL		BIT(0)
#define LM3532_ALS_CTRL		0
#define LM3532_LINEAR_MAP	BIT(1)
#define LM3532_ZONE_MASK	(BIT(2) | BIT(3) | BIT(4))
#define LM3532_ZONE_0		0
#define LM3532_ZONE_1		BIT(2)
#define LM3532_ZONE_2		BIT(3)
#define LM3532_ZONE_3		(BIT(2) | BIT(3))
#define LM3532_ZONE_4		BIT(4)

#define LM3532_ENABLE_ALS	BIT(3)
#define LM3532_ALS_SEL_SHIFT	6

/* Zone Boundary Register */
#define LM3532_ALS_WINDOW_mV	2000
#define LM3532_ALS_ZB_MAX	4
#define LM3532_ALS_OFFSET_mV	2

#define LM3532_CONTROL_A	0
#define LM3532_CONTROL_B	1
#define LM3532_CONTROL_C	2
#define LM3532_MAX_CONTROL_BANKS 3
#define LM3532_MAX_LED_STRINGS	3

#define LM3532_OUTPUT_CFG_MASK	0x3
#define LM3532_BRT_VAL_ADJUST	8
#define LM3532_RAMP_DOWN_SHIFT	3

#define LM3532_NUM_RAMP_VALS	8
#define LM3532_NUM_AVG_VALS	8
#define LM3532_NUM_IMP_VALS	32

/*
 * struct lm3532_als_data
 * @config - value of ALS configuration register
 * @als1_imp_sel - value of ALS1 resistor select register
 * @als2_imp_sel - value of ALS2 resistor select register
 * @als_avrg_time - ALS averaging time
 * @als_input_mode - ALS input mode for brightness control
 * @als_vmin - Minimum ALS voltage
 * @als_vmax - Maximum ALS voltage
 * @zone_lo - values of ALS lo ZB(Zone Boundary) registers
 * @zone_hi - values of ALS hi ZB(Zone Boundary) registers
 */
struct lm3532_als_data {
	u8 config;
	u8 als1_imp_sel;
	u8 als2_imp_sel;
	u8 als_avrg_time;
	u8 als_input_mode;
	u32 als_vmin;
	u32 als_vmax;
	u8 zones_lo[LM3532_ALS_ZB_MAX];
	u8 zones_hi[LM3532_ALS_ZB_MAX];
};

/**
 * struct lm3532_led
 * @led_dev: led class device
 * @priv - Pointer the device data structure
 * @control_bank - Control bank the LED is associated to
 * @mode - Mode of the LED string
 * @num_leds - Number of LED strings are supported in this array
 * @led_strings - The LED strings supported in this array
 * @label - LED label
 */
struct lm3532_led {
	struct led_classdev led_dev;
	struct lm3532_data *priv;

	int control_bank;
	int mode;
	int num_leds;
	u32 led_strings[LM3532_MAX_CONTROL_BANKS];
	char label[LED_MAX_NAME_SIZE];
};

/**
 * struct lm3532_data
 * @enable_gpio - Hardware enable gpio
 * @regulator: regulator
 * @client: i2c client
 * @regmap - Devices register map
 * @dev - Pointer to the devices device struct
 * @lock - Lock for reading/writing the device
 * @als_data - Pointer to the als data struct
 * @runtime_ramp_up - Runtime ramp up setting
 * @runtime_ramp_down - Runtime ramp down setting
 * @leds - Array of LED strings
 */
struct lm3532_data {
	struct gpio_desc *enable_gpio;
	struct regulator *regulator;
	struct i2c_client *client;
	struct regmap *regmap;
	struct device *dev;
	struct mutex lock;

	struct lm3532_als_data *als_data;

	u32 runtime_ramp_up;
	u32 runtime_ramp_down;

	struct lm3532_led leds[];
};

static const struct reg_default lm3532_reg_defs[] = {
	{LM3532_REG_OUTPUT_CFG, 0xe4},
	{LM3532_REG_STARTSHUT_RAMP, 0xc0},
	{LM3532_REG_RT_RAMP, 0xc0},
	{LM3532_REG_PWM_A_CFG, 0x82},
	{LM3532_REG_PWM_B_CFG, 0x82},
	{LM3532_REG_PWM_C_CFG, 0x82},
	{LM3532_REG_ZONE_CFG_A, 0xf1},
	{LM3532_REG_CTRL_A_BRT, 0xf3},
	{LM3532_REG_ZONE_CFG_B, 0xf1},
	{LM3532_REG_CTRL_B_BRT, 0xf3},
	{LM3532_REG_ZONE_CFG_C, 0xf1},
	{LM3532_REG_CTRL_C_BRT, 0xf3},
	{LM3532_REG_ENABLE, 0xf8},
	{LM3532_ALS_CONFIG, 0x44},
	{LM3532_REG_ZN_0_HI, 0x35},
	{LM3532_REG_ZN_0_LO, 0x33},
	{LM3532_REG_ZN_1_HI, 0x6a},
	{LM3532_REG_ZN_1_LO, 0x66},
	{LM3532_REG_ZN_2_HI, 0xa1},
	{LM3532_REG_ZN_2_LO, 0x99},
	{LM3532_REG_ZN_3_HI, 0xdc},
	{LM3532_REG_ZN_3_LO, 0xcc},
};

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

	.max_register = LM3532_REG_MAX,
	.reg_defaults = lm3532_reg_defs,
	.num_reg_defaults = ARRAY_SIZE(lm3532_reg_defs),
	.cache_type = REGCACHE_FLAT,
};

const static int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330,
						       92500, 7400, 6170, 5290,
						       4630, 4110, 3700, 3360,
						       3080, 2850, 2640, 2440,
						       2310, 2180, 2060, 1950,
						       1850, 1760, 1680, 1610,
						       1540, 1480, 1420, 1370,
						       1320, 1280, 1230, 1190};
static int lm3532_get_als_imp_index(int als_imped)
{
	int i;

	if (als_imped > als_imp_table[1])
		return 0;

	if (als_imped < als_imp_table[LM3532_NUM_IMP_VALS - 1])
		return LM3532_NUM_IMP_VALS - 1;

	for (i = 1; i < LM3532_NUM_IMP_VALS; i++) {
		if (als_imped == als_imp_table[i])
			return i;

		/* Find an approximate index by looking up the table */
		if (als_imped < als_imp_table[i - 1] &&
		    als_imped > als_imp_table[i]) {
			if (als_imped - als_imp_table[i - 1] <
			    als_imp_table[i] - als_imped)
				return i + 1;
			else
				return i;
		}
	}

	return -EINVAL;
}

static int lm3532_get_index(const int table[], int size, int value)
{
	int i;

	for (i = 1; i < size; i++) {
		if (value == table[i])
			return i;

		/* Find an approximate index by looking up the table */
		if (value > table[i - 1] &&
		    value < table[i]) {
			if (value - table[i - 1] < table[i] - value)
				return i - 1;
			else
				return i;
		}
	}

	return -EINVAL;
}

const static int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680,
							1433360, 286720, 573440,
							1146880, 2293760};
static int lm3532_get_als_avg_index(int avg_time)
{
	if (avg_time <= als_avrg_table[0])
		return 0;

	if (avg_time > als_avrg_table[LM3532_NUM_AVG_VALS - 1])
		return LM3532_NUM_AVG_VALS - 1;

	return lm3532_get_index(&als_avrg_table[0], LM3532_NUM_AVG_VALS,
				avg_time);
}

const static int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192,
						     16384, 32768, 65536};
static int lm3532_get_ramp_index(int ramp_time)
{
	if (ramp_time <= ramp_table[0])
		return 0;

	if (ramp_time > ramp_table[LM3532_NUM_RAMP_VALS - 1])
		return LM3532_NUM_RAMP_VALS - 1;

	return lm3532_get_index(&ramp_table[0], LM3532_NUM_RAMP_VALS,
				ramp_time);
}

static int lm3532_led_enable(struct lm3532_led *led_data)
{
	int ctrl_en_val = BIT(led_data->control_bank);
	int ret;

	ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
					 ctrl_en_val, ctrl_en_val);
	if (ret) {
		dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
		return ret;
	}

	return regulator_enable(led_data->priv->regulator);
}

static int lm3532_led_disable(struct lm3532_led *led_data)
{
	int ctrl_en_val = BIT(led_data->control_bank);
	int ret;

	ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
					 ctrl_en_val, ~ctrl_en_val);
	if (ret) {
		dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
		return ret;
	}

	return regulator_disable(led_data->priv->regulator);
}

static int lm3532_brightness_set(struct led_classdev *led_cdev,
				 enum led_brightness brt_val)
{
	struct lm3532_led *led =
			container_of(led_cdev, struct lm3532_led, led_dev);
	u8 brightness_reg;
	int ret;

	mutex_lock(&led->priv->lock);

	if (led->mode == LM3532_BL_MODE_ALS) {
		if (brt_val > LED_OFF)
			ret = lm3532_led_enable(led);
		else
			ret = lm3532_led_disable(led);

		goto unlock;
	}

	if (brt_val == LED_OFF) {
		ret = lm3532_led_disable(led);
		goto unlock;
	}

	ret = lm3532_led_enable(led);
	if (ret)
		goto unlock;

	brightness_reg = LM3532_REG_CTRL_A_BRT + led->control_bank * 2;
	brt_val = brt_val / LM3532_BRT_VAL_ADJUST;

	ret = regmap_write(led->priv->regmap, brightness_reg, brt_val);

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

static int lm3532_init_registers(struct lm3532_led *led)
{
	struct lm3532_data *drvdata = led->priv;
	unsigned int runtime_ramp_val;
	unsigned int output_cfg_val = 0;
	unsigned int output_cfg_shift = 0;
	unsigned int output_cfg_mask = 0;
	int ret, i;

	for (i = 0; i < led->num_leds; i++) {
		output_cfg_shift = led->led_strings[i] * 2;
		output_cfg_val |= (led->control_bank << output_cfg_shift);
		output_cfg_mask |= LM3532_OUTPUT_CFG_MASK << output_cfg_shift;
	}

	ret = regmap_update_bits(drvdata->regmap, LM3532_REG_OUTPUT_CFG,
				 output_cfg_mask, output_cfg_val);
	if (ret)
		return ret;

	runtime_ramp_val = drvdata->runtime_ramp_up |
			 (drvdata->runtime_ramp_down << LM3532_RAMP_DOWN_SHIFT);

	return regmap_write(drvdata->regmap, LM3532_REG_RT_RAMP,
			    runtime_ramp_val);
}

static int lm3532_als_configure(struct lm3532_data *priv,
				struct lm3532_led *led)
{
	struct lm3532_als_data *als = priv->als_data;
	u32 als_vmin, als_vmax, als_vstep;
	int zone_reg = LM3532_REG_ZN_0_HI;
	int brightnes_config_reg;
	int ret;
	int i;

	als_vmin = als->als_vmin;
	als_vmax = als->als_vmax;

	als_vstep = (als_vmax - als_vmin) / ((LM3532_ALS_ZB_MAX + 1) * 2);

	for (i = 0; i < LM3532_ALS_ZB_MAX; i++) {
		als->zones_lo[i] = ((als_vmin + als_vstep + (i * als_vstep)) *
				LED_FULL) / 1000;
		als->zones_hi[i] = ((als_vmin + LM3532_ALS_OFFSET_mV +
				als_vstep + (i * als_vstep)) * LED_FULL) / 1000;

		zone_reg = LM3532_REG_ZN_0_HI + i * 2;
		ret = regmap_write(priv->regmap, zone_reg, als->zones_lo[i]);
		if (ret)
			return ret;

		zone_reg += 1;
		ret = regmap_write(priv->regmap, zone_reg, als->zones_hi[i]);
		if (ret)
			return ret;
	}

	als->config = (als->als_avrg_time | (LM3532_ENABLE_ALS) |
		(als->als_input_mode << LM3532_ALS_SEL_SHIFT));

	ret = regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config);
	if (ret)
		return ret;

	brightnes_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2;

	return regmap_update_bits(priv->regmap, brightnes_config_reg,
				  LM3532_I2C_CTRL, LM3532_ALS_CTRL);
}

static int lm3532_parse_als(struct lm3532_data *priv)
{
	struct lm3532_als_data *als;
	int als_avg_time;
	int als_impedance;
	int ret;

	als = devm_kzalloc(priv->dev, sizeof(*als), GFP_KERNEL);
	if (als == NULL)
		return -ENOMEM;

	ret = device_property_read_u32(&priv->client->dev, "ti,als-vmin",
				       &als->als_vmin);
	if (ret)
		als->als_vmin = 0;

	ret = device_property_read_u32(&priv->client->dev, "ti,als-vmax",
				       &als->als_vmax);
	if (ret)
		als->als_vmax = LM3532_ALS_WINDOW_mV;

	if (als->als_vmax > LM3532_ALS_WINDOW_mV) {
		ret = -EINVAL;
		return ret;
	}

	ret = device_property_read_u32(&priv->client->dev, "ti,als1-imp-sel",
				      &als_impedance);
	if (ret)
		als->als1_imp_sel = 0;
	else
		als->als1_imp_sel = lm3532_get_als_imp_index(als_impedance);

	ret = device_property_read_u32(&priv->client->dev, "ti,als2-imp-sel",
				      &als_impedance);
	if (ret)
		als->als2_imp_sel = 0;
	else
		als->als2_imp_sel = lm3532_get_als_imp_index(als_impedance);

	ret = device_property_read_u32(&priv->client->dev, "ti,als-avrg-time-us",
				      &als_avg_time);
	if (ret)
		als->als_avrg_time = 0;
	else
		als->als_avrg_time = lm3532_get_als_avg_index(als_avg_time);

	ret = device_property_read_u8(&priv->client->dev, "ti,als-input-mode",
				      &als->als_input_mode);
	if (ret)
		als->als_input_mode = 0;

	if (als->als_input_mode > LM3532_BL_MODE_ALS) {
		ret = -EINVAL;
		return ret;
	}

	priv->als_data = als;

	return ret;
}

static int lm3532_parse_node(struct lm3532_data *priv)
{
	struct fwnode_handle *child = NULL;
	struct lm3532_led *led;
	const char *name;
	int control_bank;
	u32 ramp_time;
	size_t i = 0;
	int ret;

	priv->enable_gpio = devm_gpiod_get_optional(&priv->client->dev,
						   "enable", GPIOD_OUT_LOW);
	if (IS_ERR(priv->enable_gpio))
		priv->enable_gpio = NULL;

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

	ret = device_property_read_u32(&priv->client->dev, "ramp-up-us",
				       &ramp_time);
	if (ret)
		dev_info(&priv->client->dev, "ramp-up-ms property missing\n");
	else
		priv->runtime_ramp_up = lm3532_get_ramp_index(ramp_time);

	ret = device_property_read_u32(&priv->client->dev, "ramp-down-us",
				       &ramp_time);
	if (ret)
		dev_info(&priv->client->dev, "ramp-down-ms property missing\n");
	else
		priv->runtime_ramp_down = lm3532_get_ramp_index(ramp_time);

	device_for_each_child_node(priv->dev, child) {
		led = &priv->leds[i];

		ret = fwnode_property_read_u32(child, "reg", &control_bank);
		if (ret) {
			dev_err(&priv->client->dev, "reg property missing\n");
			fwnode_handle_put(child);
			goto child_out;
		}

		if (control_bank > LM3532_CONTROL_C) {
			dev_err(&priv->client->dev, "Control bank invalid\n");
			continue;
		}

		led->control_bank = control_bank;

		ret = fwnode_property_read_u32(child, "ti,led-mode",
					       &led->mode);
		if (ret) {
			dev_err(&priv->client->dev, "ti,led-mode property missing\n");
			fwnode_handle_put(child);
			goto child_out;
		}

		if (led->mode == LM3532_BL_MODE_ALS) {
			ret = lm3532_parse_als(priv);
			if (ret)
				dev_err(&priv->client->dev, "Failed to parse als\n");
			else
				lm3532_als_configure(priv, led);
		}

		led->num_leds = fwnode_property_read_u32_array(child,
							       "led-sources",
							       NULL, 0);

		if (led->num_leds > LM3532_MAX_LED_STRINGS) {
			dev_err(&priv->client->dev, "To many LED string defined\n");
			continue;
		}

		ret = fwnode_property_read_u32_array(child, "led-sources",
						    led->led_strings,
						    led->num_leds);
		if (ret) {
			dev_err(&priv->client->dev, "led-sources property missing\n");
			fwnode_handle_put(child);
			goto child_out;
		}

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

		ret = fwnode_property_read_string(child, "label", &name);
		if (ret)
			snprintf(led->label, sizeof(led->label),
				"%s::", priv->client->name);
		else
			snprintf(led->label, sizeof(led->label),
				 "%s:%s", priv->client->name, name);

		led->priv = priv;
		led->led_dev.name = led->label;
		led->led_dev.brightness_set_blocking = lm3532_brightness_set;

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

		lm3532_init_registers(led);

		i++;
	}

child_out:
	return ret;
}

static int lm3532_probe(struct i2c_client *client,
			   const struct i2c_device_id *id)
{
	struct lm3532_data *drvdata;
	int ret = 0;
	int count;

	count = device_get_child_node_count(&client->dev);
	if (!count) {
		dev_err(&client->dev, "LEDs are not defined in device tree!");
		return -ENODEV;
	}

	drvdata = devm_kzalloc(&client->dev, struct_size(drvdata, leds, count),
			   GFP_KERNEL);
	if (drvdata == NULL)
		return -ENOMEM;

	drvdata->client = client;
	drvdata->dev = &client->dev;

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

	mutex_init(&drvdata->lock);
	i2c_set_clientdata(client, drvdata);

	ret = lm3532_parse_node(drvdata);
	if (ret) {
		dev_err(&client->dev, "Failed to parse node\n");
		return ret;
	}

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

	return ret;
}

static int lm3532_remove(struct i2c_client *client)
{
	struct lm3532_data *drvdata = i2c_get_clientdata(client);

	mutex_destroy(&drvdata->lock);

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

	return 0;
}

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

static const struct i2c_device_id lm3532_id[] = {
	{LM3532_NAME, 0},
	{}
};
MODULE_DEVICE_TABLE(i2c, lm3532_id);

static struct i2c_driver lm3532_i2c_driver = {
	.probe = lm3532_probe,
	.remove = lm3532_remove,
	.id_table = lm3532_id,
	.driver = {
		.name = LM3532_NAME,
		.of_match_table = of_lm3532_leds_match,
	},
};
module_i2c_driver(lm3532_i2c_driver);

MODULE_DESCRIPTION("Back Light driver for LM3532");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
Commit	Line	Data
bc1b8492 DM	1	// SPDX-License-Identifier: GPL-2.0
	2	// TI LM3532 LED driver
	3	// Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
	4
	5	#include <linux/i2c.h>
	6	#include <linux/leds.h>
	7	#include <linux/slab.h>
	8	#include <linux/regmap.h>
	9	#include <linux/types.h>
	10	#include <linux/regulator/consumer.h>
	11	#include <linux/module.h>
	12	#include <uapi/linux/uleds.h>
	13	#include <linux/gpio/consumer.h>
	14
	15	#define LM3532_NAME "lm3532-led"
	16	#define LM3532_BL_MODE_MANUAL 0x00
	17	#define LM3532_BL_MODE_ALS 0x01
	18
	19	#define LM3532_REG_OUTPUT_CFG 0x10
	20	#define LM3532_REG_STARTSHUT_RAMP 0x11
	21	#define LM3532_REG_RT_RAMP 0x12
	22	#define LM3532_REG_PWM_A_CFG 0x13
	23	#define LM3532_REG_PWM_B_CFG 0x14
	24	#define LM3532_REG_PWM_C_CFG 0x15
	25	#define LM3532_REG_ZONE_CFG_A 0x16
	26	#define LM3532_REG_CTRL_A_BRT 0x17
	27	#define LM3532_REG_ZONE_CFG_B 0x18
	28	#define LM3532_REG_CTRL_B_BRT 0x19
	29	#define LM3532_REG_ZONE_CFG_C 0x1a
	30	#define LM3532_REG_CTRL_C_BRT 0x1b
	31	#define LM3532_REG_ENABLE 0x1d
	32	#define LM3532_ALS_CONFIG 0x23
	33	#define LM3532_REG_ZN_0_HI 0x60
	34	#define LM3532_REG_ZN_0_LO 0x61
	35	#define LM3532_REG_ZN_1_HI 0x62
	36	#define LM3532_REG_ZN_1_LO 0x63
	37	#define LM3532_REG_ZN_2_HI 0x64
	38	#define LM3532_REG_ZN_2_LO 0x65
	39	#define LM3532_REG_ZN_3_HI 0x66
	40	#define LM3532_REG_ZN_3_LO 0x67
	41	#define LM3532_REG_MAX 0x7e
	42
	43	/* Contorl Enable */
	44	#define LM3532_CTRL_A_ENABLE BIT(0)
	45	#define LM3532_CTRL_B_ENABLE BIT(1)
	46	#define LM3532_CTRL_C_ENABLE BIT(2)
	47
	48	/* PWM Zone Control */
	49	#define LM3532_PWM_ZONE_MASK 0x7c
	50	#define LM3532_PWM_ZONE_0_EN BIT(2)
	51	#define LM3532_PWM_ZONE_1_EN BIT(3)
	52	#define LM3532_PWM_ZONE_2_EN BIT(4)
	53	#define LM3532_PWM_ZONE_3_EN BIT(5)
	54	#define LM3532_PWM_ZONE_4_EN BIT(6)
	55
	56	/* Brightness Configuration */
	57	#define LM3532_I2C_CTRL BIT(0)
	58	#define LM3532_ALS_CTRL 0
	59	#define LM3532_LINEAR_MAP BIT(1)
	60	#define LM3532_ZONE_MASK (BIT(2) \| BIT(3) \| BIT(4))
	61	#define LM3532_ZONE_0 0
	62	#define LM3532_ZONE_1 BIT(2)
	63	#define LM3532_ZONE_2 BIT(3)
	64	#define LM3532_ZONE_3 (BIT(2) \| BIT(3))
65	#define LM3532_ZONE_4 BIT(4)
66
67	#define LM3532_ENABLE_ALS BIT(3)
68	#define LM3532_ALS_SEL_SHIFT 6
69
70	/* Zone Boundary Register */
71	#define LM3532_ALS_WINDOW_mV 2000
72	#define LM3532_ALS_ZB_MAX 4
73	#define LM3532_ALS_OFFSET_mV 2
74
75	#define LM3532_CONTROL_A 0
76	#define LM3532_CONTROL_B 1
77	#define LM3532_CONTROL_C 2
78	#define LM3532_MAX_CONTROL_BANKS 3
79	#define LM3532_MAX_LED_STRINGS 3
80
81	#define LM3532_OUTPUT_CFG_MASK 0x3
82	#define LM3532_BRT_VAL_ADJUST 8
83	#define LM3532_RAMP_DOWN_SHIFT 3
84
85	#define LM3532_NUM_RAMP_VALS 8
86	#define LM3532_NUM_AVG_VALS 8
87	#define LM3532_NUM_IMP_VALS 32
88
89	/*
90	* struct lm3532_als_data
91	* @config - value of ALS configuration register
92	* @als1_imp_sel - value of ALS1 resistor select register
93	* @als2_imp_sel - value of ALS2 resistor select register
94	* @als_avrg_time - ALS averaging time
95	* @als_input_mode - ALS input mode for brightness control
96	* @als_vmin - Minimum ALS voltage
97	* @als_vmax - Maximum ALS voltage
98	* @zone_lo - values of ALS lo ZB(Zone Boundary) registers
99	* @zone_hi - values of ALS hi ZB(Zone Boundary) registers
100	*/
101	struct lm3532_als_data {
102	u8 config;
103	u8 als1_imp_sel;
104	u8 als2_imp_sel;
105	u8 als_avrg_time;
106	u8 als_input_mode;
107	u32 als_vmin;
108	u32 als_vmax;
109	u8 zones_lo[LM3532_ALS_ZB_MAX];
110	u8 zones_hi[LM3532_ALS_ZB_MAX];
111	};
112
113	/**
114	* struct lm3532_led
115	* @led_dev: led class device
116	* @priv - Pointer the device data structure
117	* @control_bank - Control bank the LED is associated to
118	* @mode - Mode of the LED string
119	* @num_leds - Number of LED strings are supported in this array
120	* @led_strings - The LED strings supported in this array
121	* @label - LED label
122	*/
123	struct lm3532_led {
124	struct led_classdev led_dev;
125	struct lm3532_data *priv;
126
127	int control_bank;
128	int mode;
129	int num_leds;
130	u32 led_strings[LM3532_MAX_CONTROL_BANKS];
131	char label[LED_MAX_NAME_SIZE];
132	};
133
134	/**
135	* struct lm3532_data
136	* @enable_gpio - Hardware enable gpio
137	* @regulator: regulator
138	* @client: i2c client
139	* @regmap - Devices register map
140	* @dev - Pointer to the devices device struct
141	* @lock - Lock for reading/writing the device
142	* @als_data - Pointer to the als data struct
143	* @runtime_ramp_up - Runtime ramp up setting
144	* @runtime_ramp_down - Runtime ramp down setting
145	* @leds - Array of LED strings
146	*/
147	struct lm3532_data {
148	struct gpio_desc *enable_gpio;
149	struct regulator *regulator;
150	struct i2c_client *client;
151	struct regmap *regmap;
152	struct device *dev;
153	struct mutex lock;
154
155	struct lm3532_als_data *als_data;
156
157	u32 runtime_ramp_up;
158	u32 runtime_ramp_down;
159
160	struct lm3532_led leds[];
161	};
162
163	static const struct reg_default lm3532_reg_defs[] = {
164	{LM3532_REG_OUTPUT_CFG, 0xe4},
165	{LM3532_REG_STARTSHUT_RAMP, 0xc0},
166	{LM3532_REG_RT_RAMP, 0xc0},
167	{LM3532_REG_PWM_A_CFG, 0x82},
168	{LM3532_REG_PWM_B_CFG, 0x82},
169	{LM3532_REG_PWM_C_CFG, 0x82},
170	{LM3532_REG_ZONE_CFG_A, 0xf1},
171	{LM3532_REG_CTRL_A_BRT, 0xf3},
172	{LM3532_REG_ZONE_CFG_B, 0xf1},
173	{LM3532_REG_CTRL_B_BRT, 0xf3},
174	{LM3532_REG_ZONE_CFG_C, 0xf1},
175	{LM3532_REG_CTRL_C_BRT, 0xf3},
176	{LM3532_REG_ENABLE, 0xf8},
177	{LM3532_ALS_CONFIG, 0x44},
178	{LM3532_REG_ZN_0_HI, 0x35},
179	{LM3532_REG_ZN_0_LO, 0x33},
180	{LM3532_REG_ZN_1_HI, 0x6a},
181	{LM3532_REG_ZN_1_LO, 0x66},
182	{LM3532_REG_ZN_2_HI, 0xa1},
183	{LM3532_REG_ZN_2_LO, 0x99},
184	{LM3532_REG_ZN_3_HI, 0xdc},
185	{LM3532_REG_ZN_3_LO, 0xcc},
186	};
187
188	static const struct regmap_config lm3532_regmap_config = {
189	.reg_bits = 8,
190	.val_bits = 8,
191
192	.max_register = LM3532_REG_MAX,
193	.reg_defaults = lm3532_reg_defs,
194	.num_reg_defaults = ARRAY_SIZE(lm3532_reg_defs),
195	.cache_type = REGCACHE_FLAT,
196	};
197
198	const static int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330,
199	92500, 7400, 6170, 5290,
200	4630, 4110, 3700, 3360,
201	3080, 2850, 2640, 2440,
202	2310, 2180, 2060, 1950,
203	1850, 1760, 1680, 1610,
204	1540, 1480, 1420, 1370,
205	1320, 1280, 1230, 1190};
206	static int lm3532_get_als_imp_index(int als_imped)
207	{
208	int i;
209
210	if (als_imped > als_imp_table[1])
211	return 0;
212
213	if (als_imped < als_imp_table[LM3532_NUM_IMP_VALS - 1])
214	return LM3532_NUM_IMP_VALS - 1;
215
216	for (i = 1; i < LM3532_NUM_IMP_VALS; i++) {
217	if (als_imped == als_imp_table[i])
218	return i;
219
220	/* Find an approximate index by looking up the table */
221	if (als_imped < als_imp_table[i - 1] &&
222	als_imped > als_imp_table[i]) {
223	if (als_imped - als_imp_table[i - 1] <
224	als_imp_table[i] - als_imped)
225	return i + 1;
226	else
227	return i;
228	}
229	}
230
231	return -EINVAL;
232	}
233
234	static int lm3532_get_index(const int table[], int size, int value)
235	{
236	int i;
237
238	for (i = 1; i < size; i++) {
239	if (value == table[i])
240	return i;
241
242	/* Find an approximate index by looking up the table */
243	if (value > table[i - 1] &&
244	value < table[i]) {
245	if (value - table[i - 1] < table[i] - value)
246	return i - 1;
247	else
248	return i;
249	}
250	}
251
252	return -EINVAL;
253	}
254
255	const static int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680,
256	1433360, 286720, 573440,
257	1146880, 2293760};
258	static int lm3532_get_als_avg_index(int avg_time)
259	{
260	if (avg_time <= als_avrg_table[0])
261	return 0;
262
263	if (avg_time > als_avrg_table[LM3532_NUM_AVG_VALS - 1])
264	return LM3532_NUM_AVG_VALS - 1;
265
266	return lm3532_get_index(&als_avrg_table[0], LM3532_NUM_AVG_VALS,
267	avg_time);
268	}
269
270	const static int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192,
271	16384, 32768, 65536};
272	static int lm3532_get_ramp_index(int ramp_time)
273	{
274	if (ramp_time <= ramp_table[0])
275	return 0;
276
277	if (ramp_time > ramp_table[LM3532_NUM_RAMP_VALS - 1])
278	return LM3532_NUM_RAMP_VALS - 1;
279
280	return lm3532_get_index(&ramp_table[0], LM3532_NUM_RAMP_VALS,
281	ramp_time);
282	}
283
284	static int lm3532_led_enable(struct lm3532_led *led_data)
285	{
286	int ctrl_en_val = BIT(led_data->control_bank);
287	int ret;
288
289	ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
290	ctrl_en_val, ctrl_en_val);
291	if (ret) {
292	dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
293	return ret;
294	}
295
296	return regulator_enable(led_data->priv->regulator);
297	}
298
299	static int lm3532_led_disable(struct lm3532_led *led_data)
300	{
301	int ctrl_en_val = BIT(led_data->control_bank);
302	int ret;
303
304	ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
305	ctrl_en_val, ~ctrl_en_val);
306	if (ret) {
307	dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
308	return ret;
309	}
310
311	return regulator_disable(led_data->priv->regulator);
312	}
313
314	static int lm3532_brightness_set(struct led_classdev *led_cdev,
315	enum led_brightness brt_val)
316	{
317	struct lm3532_led *led =
318	container_of(led_cdev, struct lm3532_led, led_dev);
319	u8 brightness_reg;
320	int ret;
321
322	mutex_lock(&led->priv->lock);
323
324	if (led->mode == LM3532_BL_MODE_ALS) {
325	if (brt_val > LED_OFF)
326	ret = lm3532_led_enable(led);
327	else
328	ret = lm3532_led_disable(led);
329
330	goto unlock;
331	}
332
333	if (brt_val == LED_OFF) {
334	ret = lm3532_led_disable(led);
335	goto unlock;
336	}
337
338	ret = lm3532_led_enable(led);
339	if (ret)
340	goto unlock;
341
342	brightness_reg = LM3532_REG_CTRL_A_BRT + led->control_bank * 2;
343	brt_val = brt_val / LM3532_BRT_VAL_ADJUST;
344
345	ret = regmap_write(led->priv->regmap, brightness_reg, brt_val);
346
347	unlock:
348	mutex_unlock(&led->priv->lock);
349	return ret;
350	}
351
352	static int lm3532_init_registers(struct lm3532_led *led)
353	{
354	struct lm3532_data *drvdata = led->priv;
355	unsigned int runtime_ramp_val;
356	unsigned int output_cfg_val = 0;
357	unsigned int output_cfg_shift = 0;
358	unsigned int output_cfg_mask = 0;
359	int ret, i;
360
361	for (i = 0; i < led->num_leds; i++) {
362	output_cfg_shift = led->led_strings[i] * 2;
363	output_cfg_val \|= (led->control_bank << output_cfg_shift);
364	output_cfg_mask \|= LM3532_OUTPUT_CFG_MASK << output_cfg_shift;
365	}
366
367	ret = regmap_update_bits(drvdata->regmap, LM3532_REG_OUTPUT_CFG,
368	output_cfg_mask, output_cfg_val);
369	if (ret)
370	return ret;
371
372	runtime_ramp_val = drvdata->runtime_ramp_up \|
373	(drvdata->runtime_ramp_down << LM3532_RAMP_DOWN_SHIFT);
374
375	return regmap_write(drvdata->regmap, LM3532_REG_RT_RAMP,
376	runtime_ramp_val);
377	}
378
379	static int lm3532_als_configure(struct lm3532_data *priv,
380	struct lm3532_led *led)
381	{
382	struct lm3532_als_data *als = priv->als_data;
383	u32 als_vmin, als_vmax, als_vstep;
384	int zone_reg = LM3532_REG_ZN_0_HI;
385	int brightnes_config_reg;
386	int ret;
387	int i;
388
389	als_vmin = als->als_vmin;
390	als_vmax = als->als_vmax;
391
392	als_vstep = (als_vmax - als_vmin) / ((LM3532_ALS_ZB_MAX + 1) * 2);
393
394	for (i = 0; i < LM3532_ALS_ZB_MAX; i++) {
395	als->zones_lo[i] = ((als_vmin + als_vstep + (i * als_vstep)) *
396	LED_FULL) / 1000;
397	als->zones_hi[i] = ((als_vmin + LM3532_ALS_OFFSET_mV +
398	als_vstep + (i * als_vstep)) * LED_FULL) / 1000;
399
400	zone_reg = LM3532_REG_ZN_0_HI + i * 2;
401	ret = regmap_write(priv->regmap, zone_reg, als->zones_lo[i]);
402	if (ret)
403	return ret;
404
405	zone_reg += 1;
406	ret = regmap_write(priv->regmap, zone_reg, als->zones_hi[i]);
407	if (ret)
408	return ret;
409	}
410
411	als->config = (als->als_avrg_time \| (LM3532_ENABLE_ALS) \|
412	(als->als_input_mode << LM3532_ALS_SEL_SHIFT));
413
414	ret = regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config);
415	if (ret)
416	return ret;
417
418	brightnes_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2;
419
420	return regmap_update_bits(priv->regmap, brightnes_config_reg,
421	LM3532_I2C_CTRL, LM3532_ALS_CTRL);
422	}
423
424	static int lm3532_parse_als(struct lm3532_data *priv)
425	{
426	struct lm3532_als_data *als;
427	int als_avg_time;
428	int als_impedance;
429	int ret;
430
431	als = devm_kzalloc(priv->dev, sizeof(*als), GFP_KERNEL);
432	if (als == NULL)
433	return -ENOMEM;
434
435	ret = device_property_read_u32(&priv->client->dev, "ti,als-vmin",
436	&als->als_vmin);
437	if (ret)
438	als->als_vmin = 0;
439
440	ret = device_property_read_u32(&priv->client->dev, "ti,als-vmax",
441	&als->als_vmax);
442	if (ret)
443	als->als_vmax = LM3532_ALS_WINDOW_mV;
444
445	if (als->als_vmax > LM3532_ALS_WINDOW_mV) {
446	ret = -EINVAL;
447	return ret;
448	}
449
450	ret = device_property_read_u32(&priv->client->dev, "ti,als1-imp-sel",
451	&als_impedance);
452	if (ret)
453	als->als1_imp_sel = 0;
454	else
455	als->als1_imp_sel = lm3532_get_als_imp_index(als_impedance);
456
457	ret = device_property_read_u32(&priv->client->dev, "ti,als2-imp-sel",
458	&als_impedance);
459	if (ret)
460	als->als2_imp_sel = 0;
461	else
462	als->als2_imp_sel = lm3532_get_als_imp_index(als_impedance);
463
464	ret = device_property_read_u32(&priv->client->dev, "ti,als-avrg-time-us",
465	&als_avg_time);
466	if (ret)
467	als->als_avrg_time = 0;
468	else
469	als->als_avrg_time = lm3532_get_als_avg_index(als_avg_time);
470
471	ret = device_property_read_u8(&priv->client->dev, "ti,als-input-mode",
472	&als->als_input_mode);
473	if (ret)
474	als->als_input_mode = 0;
475
476	if (als->als_input_mode > LM3532_BL_MODE_ALS) {
477	ret = -EINVAL;
478	return ret;
479	}
480
481	priv->als_data = als;
482
483	return ret;
484	}
485
486	static int lm3532_parse_node(struct lm3532_data *priv)
487	{
488	struct fwnode_handle *child = NULL;
489	struct lm3532_led *led;
490	const char *name;
491	int control_bank;
492	u32 ramp_time;
493	size_t i = 0;
494	int ret;
495
496	priv->enable_gpio = devm_gpiod_get_optional(&priv->client->dev,
497	"enable", GPIOD_OUT_LOW);
498	if (IS_ERR(priv->enable_gpio))
499	priv->enable_gpio = NULL;
500
501	priv->regulator = devm_regulator_get(&priv->client->dev, "vin");
502	if (IS_ERR(priv->regulator))
503	priv->regulator = NULL;
504
505	ret = device_property_read_u32(&priv->client->dev, "ramp-up-us",
506	&ramp_time);
507	if (ret)
508	dev_info(&priv->client->dev, "ramp-up-ms property missing\n");
509	else
510	priv->runtime_ramp_up = lm3532_get_ramp_index(ramp_time);
511
512	ret = device_property_read_u32(&priv->client->dev, "ramp-down-us",
513	&ramp_time);
514	if (ret)
515	dev_info(&priv->client->dev, "ramp-down-ms property missing\n");
516	else
517	priv->runtime_ramp_down = lm3532_get_ramp_index(ramp_time);
518
519	device_for_each_child_node(priv->dev, child) {
520	led = &priv->leds[i];
521
522	ret = fwnode_property_read_u32(child, "reg", &control_bank);
523	if (ret) {
524	dev_err(&priv->client->dev, "reg property missing\n");
525	fwnode_handle_put(child);
526	goto child_out;
527	}
528
529	if (control_bank > LM3532_CONTROL_C) {
530	dev_err(&priv->client->dev, "Control bank invalid\n");
531	continue;
532	}
533
534	led->control_bank = control_bank;
535
536	ret = fwnode_property_read_u32(child, "ti,led-mode",
537	&led->mode);
538	if (ret) {
539	dev_err(&priv->client->dev, "ti,led-mode property missing\n");
540	fwnode_handle_put(child);
541	goto child_out;
542	}
543
544	if (led->mode == LM3532_BL_MODE_ALS) {
545	ret = lm3532_parse_als(priv);
546	if (ret)
547	dev_err(&priv->client->dev, "Failed to parse als\n");
548	else
549	lm3532_als_configure(priv, led);
550	}
551
552	led->num_leds = fwnode_property_read_u32_array(child,
553	"led-sources",
554	NULL, 0);
555
556	if (led->num_leds > LM3532_MAX_LED_STRINGS) {
557	dev_err(&priv->client->dev, "To many LED string defined\n");
558	continue;
559	}
560
561	ret = fwnode_property_read_u32_array(child, "led-sources",
562	led->led_strings,
563	led->num_leds);
564	if (ret) {
565	dev_err(&priv->client->dev, "led-sources property missing\n");
566	fwnode_handle_put(child);
567	goto child_out;
568	}
569
570	fwnode_property_read_string(child, "linux,default-trigger",
571	&led->led_dev.default_trigger);
572
573	ret = fwnode_property_read_string(child, "label", &name);
574	if (ret)
575	snprintf(led->label, sizeof(led->label),
576	"%s::", priv->client->name);
577	else
578	snprintf(led->label, sizeof(led->label),
579	"%s:%s", priv->client->name, name);
580
581	led->priv = priv;
582	led->led_dev.name = led->label;
583	led->led_dev.brightness_set_blocking = lm3532_brightness_set;
584
585	ret = devm_led_classdev_register(priv->dev, &led->led_dev);
586	if (ret) {
587	dev_err(&priv->client->dev, "led register err: %d\n",
588	ret);
589	fwnode_handle_put(child);
590	goto child_out;
591	}
592
593	lm3532_init_registers(led);
594
595	i++;
596	}
597
598	child_out:
599	return ret;
600	}
601
602	static int lm3532_probe(struct i2c_client *client,
603	const struct i2c_device_id *id)
604	{
605	struct lm3532_data *drvdata;
606	int ret = 0;
607	int count;
608
609	count = device_get_child_node_count(&client->dev);
610	if (!count) {
611	dev_err(&client->dev, "LEDs are not defined in device tree!");
612	return -ENODEV;
613	}
614
615	drvdata = devm_kzalloc(&client->dev, struct_size(drvdata, leds, count),
616	GFP_KERNEL);
617	if (drvdata == NULL)
618	return -ENOMEM;
619
620	drvdata->client = client;
621	drvdata->dev = &client->dev;
622
623	drvdata->regmap = devm_regmap_init_i2c(client, &lm3532_regmap_config);
624	if (IS_ERR(drvdata->regmap)) {
625	ret = PTR_ERR(drvdata->regmap);
626	dev_err(&client->dev, "Failed to allocate register map: %d\n",
627	ret);
628	return ret;
629	}
630
631	mutex_init(&drvdata->lock);
632	i2c_set_clientdata(client, drvdata);
633
634	ret = lm3532_parse_node(drvdata);
635	if (ret) {
636	dev_err(&client->dev, "Failed to parse node\n");
637	return ret;
638	}
639
640	if (drvdata->enable_gpio)
641	gpiod_direction_output(drvdata->enable_gpio, 1);
642
643	return ret;
644	}
645
646	static int lm3532_remove(struct i2c_client *client)
647	{
648	struct lm3532_data *drvdata = i2c_get_clientdata(client);
649
650	mutex_destroy(&drvdata->lock);
651
652	if (drvdata->enable_gpio)
653	gpiod_direction_output(drvdata->enable_gpio, 0);
654
655	return 0;
656	}
657
658	static const struct of_device_id of_lm3532_leds_match[] = {
659	{ .compatible = "ti,lm3532", },
660	{},
661	};
662	MODULE_DEVICE_TABLE(of, of_lm3532_leds_match);
663
664	static const struct i2c_device_id lm3532_id[] = {
665	{LM3532_NAME, 0},
666	{}
667	};
668	MODULE_DEVICE_TABLE(i2c, lm3532_id);
669
670	static struct i2c_driver lm3532_i2c_driver = {
671	.probe = lm3532_probe,
672	.remove = lm3532_remove,
673	.id_table = lm3532_id,
674	.driver = {
675	.name = LM3532_NAME,
676	.of_match_table = of_lm3532_leds_match,
677	},
678	};
679	module_i2c_driver(lm3532_i2c_driver);
680
681	MODULE_DESCRIPTION("Back Light driver for LM3532");
682	MODULE_LICENSE("GPL v2");
683	MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");