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

// SPDX-License-Identifier: GPL-2.0
// TI LP50XX LED chip family driver
// Copyright (C) 2018-20 Texas Instruments Incorporated - https://www.ti.com/

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

#include <linux/led-class-multicolor.h>

#include "leds.h"

#define LP50XX_DEV_CFG0		0x00
#define LP50XX_DEV_CFG1		0x01
#define LP50XX_LED_CFG0		0x02

/* LP5009 and LP5012 registers */
#define LP5012_BNK_BRT		0x03
#define LP5012_BNKA_CLR		0x04
#define LP5012_BNKB_CLR		0x05
#define LP5012_BNKC_CLR		0x06
#define LP5012_LED0_BRT		0x07
#define LP5012_OUT0_CLR		0x0b
#define LP5012_RESET		0x17

/* LP5018 and LP5024 registers */
#define LP5024_BNK_BRT		0x03
#define LP5024_BNKA_CLR		0x04
#define LP5024_BNKB_CLR		0x05
#define LP5024_BNKC_CLR		0x06
#define LP5024_LED0_BRT		0x07
#define LP5024_OUT0_CLR		0x0f
#define LP5024_RESET		0x27

/* LP5030 and LP5036 registers */
#define LP5036_LED_CFG1		0x03
#define LP5036_BNK_BRT		0x04
#define LP5036_BNKA_CLR		0x05
#define LP5036_BNKB_CLR		0x06
#define LP5036_BNKC_CLR		0x07
#define LP5036_LED0_BRT		0x08
#define LP5036_OUT0_CLR		0x14
#define LP5036_RESET		0x38

#define LP50XX_SW_RESET		0xff
#define LP50XX_CHIP_EN		BIT(6)

/* There are 3 LED outputs per bank */
#define LP50XX_LEDS_PER_MODULE	3

#define LP5009_MAX_LED_MODULES	2
#define LP5012_MAX_LED_MODULES	4
#define LP5018_MAX_LED_MODULES	6
#define LP5024_MAX_LED_MODULES	8
#define LP5030_MAX_LED_MODULES	10
#define LP5036_MAX_LED_MODULES	12

static const struct reg_default lp5012_reg_defs[] = {
	{LP50XX_DEV_CFG0, 0x0},
	{LP50XX_DEV_CFG1, 0x3c},
	{LP50XX_LED_CFG0, 0x0},
	{LP5012_BNK_BRT, 0xff},
	{LP5012_BNKA_CLR, 0x0f},
	{LP5012_BNKB_CLR, 0x0f},
	{LP5012_BNKC_CLR, 0x0f},
	{LP5012_LED0_BRT, 0x0f},
	/* LEDX_BRT registers are all 0xff for defaults */
	{0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff},
	{LP5012_OUT0_CLR, 0x0f},
	/* OUTX_CLR registers are all 0x0 for defaults */
	{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, {0x10, 0x00},
	{0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},	{0x15, 0x00},
	{0x16, 0x00},
	{LP5012_RESET, 0x00}
};

static const struct reg_default lp5024_reg_defs[] = {
	{LP50XX_DEV_CFG0, 0x0},
	{LP50XX_DEV_CFG1, 0x3c},
	{LP50XX_LED_CFG0, 0x0},
	{LP5024_BNK_BRT, 0xff},
	{LP5024_BNKA_CLR, 0x0f},
	{LP5024_BNKB_CLR, 0x0f},
	{LP5024_BNKC_CLR, 0x0f},
	{LP5024_LED0_BRT, 0x0f},
	/* LEDX_BRT registers are all 0xff for defaults */
	{0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
	{0x0d, 0xff}, {0x0e, 0xff},
	{LP5024_OUT0_CLR, 0x0f},
	/* OUTX_CLR registers are all 0x0 for defaults */
	{0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},
	{0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
	{0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
	{0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
	{0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00},
	{LP5024_RESET, 0x00}
};

static const struct reg_default lp5036_reg_defs[] = {
	{LP50XX_DEV_CFG0, 0x0},
	{LP50XX_DEV_CFG1, 0x3c},
	{LP50XX_LED_CFG0, 0x0},
	{LP5036_LED_CFG1, 0x0},
	{LP5036_BNK_BRT, 0xff},
	{LP5036_BNKA_CLR, 0x0f},
	{LP5036_BNKB_CLR, 0x0f},
	{LP5036_BNKC_CLR, 0x0f},
	{LP5036_LED0_BRT, 0x0f},
	/* LEDX_BRT registers are all 0xff for defaults */
	{0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
	{0x0d, 0xff}, {0x0e, 0xff}, {0x0f, 0xff}, {0x10, 0xff}, {0x11, 0xff},
	{0x12, 0xff}, {0x13, 0xff},
	{LP5036_OUT0_CLR, 0x0f},
	/* OUTX_CLR registers are all 0x0 for defaults */
	{0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
	{0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
	{0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
	{0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
	{0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00},
	{0x2e, 0x00}, {0x2f, 0x00}, {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00},
	{0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
	{LP5036_RESET, 0x00}
};

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

	.max_register = LP5012_RESET,
	.reg_defaults = lp5012_reg_defs,
	.num_reg_defaults = ARRAY_SIZE(lp5012_reg_defs),
	.cache_type = REGCACHE_FLAT,
};

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

	.max_register = LP5024_RESET,
	.reg_defaults = lp5024_reg_defs,
	.num_reg_defaults = ARRAY_SIZE(lp5024_reg_defs),
	.cache_type = REGCACHE_FLAT,
};

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

	.max_register = LP5036_RESET,
	.reg_defaults = lp5036_reg_defs,
	.num_reg_defaults = ARRAY_SIZE(lp5036_reg_defs),
	.cache_type = REGCACHE_FLAT,
};

enum lp50xx_model {
	LP5009,
	LP5012,
	LP5018,
	LP5024,
	LP5030,
	LP5036,
};

/**
 * struct lp50xx_chip_info -
 * @lp50xx_regmap_config: regmap register configuration
 * @model_id: LED device model
 * @max_modules: total number of supported LED modules
 * @num_leds: number of LED outputs available on the device
 * @led_brightness0_reg: first brightness register of the device
 * @mix_out0_reg: first color mix register of the device
 * @bank_brt_reg: bank brightness register
 * @bank_mix_reg: color mix register
 * @reset_reg: device reset register
 */
struct lp50xx_chip_info {
	const struct regmap_config *lp50xx_regmap_config;
	int model_id;
	u8 max_modules;
	u8 num_leds;
	u8 led_brightness0_reg;
	u8 mix_out0_reg;
	u8 bank_brt_reg;
	u8 bank_mix_reg;
	u8 reset_reg;
};

static const struct lp50xx_chip_info lp50xx_chip_info_tbl[] = {
	[LP5009] = {
		.model_id = LP5009,
		.max_modules = LP5009_MAX_LED_MODULES,
		.num_leds = LP5009_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
		.led_brightness0_reg = LP5012_LED0_BRT,
		.mix_out0_reg = LP5012_OUT0_CLR,
		.bank_brt_reg = LP5012_BNK_BRT,
		.bank_mix_reg = LP5012_BNKA_CLR,
		.reset_reg = LP5012_RESET,
		.lp50xx_regmap_config = &lp5012_regmap_config,
	},
	[LP5012] = {
		.model_id = LP5012,
		.max_modules = LP5012_MAX_LED_MODULES,
		.num_leds = LP5012_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
		.led_brightness0_reg = LP5012_LED0_BRT,
		.mix_out0_reg = LP5012_OUT0_CLR,
		.bank_brt_reg = LP5012_BNK_BRT,
		.bank_mix_reg = LP5012_BNKA_CLR,
		.reset_reg = LP5012_RESET,
		.lp50xx_regmap_config = &lp5012_regmap_config,
	},
	[LP5018] = {
		.model_id = LP5018,
		.max_modules = LP5018_MAX_LED_MODULES,
		.num_leds = LP5018_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
		.led_brightness0_reg = LP5024_LED0_BRT,
		.mix_out0_reg = LP5024_OUT0_CLR,
		.bank_brt_reg = LP5024_BNK_BRT,
		.bank_mix_reg = LP5024_BNKA_CLR,
		.reset_reg = LP5024_RESET,
		.lp50xx_regmap_config = &lp5024_regmap_config,
	},
	[LP5024] = {
		.model_id = LP5024,
		.max_modules = LP5024_MAX_LED_MODULES,
		.num_leds = LP5024_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
		.led_brightness0_reg = LP5024_LED0_BRT,
		.mix_out0_reg = LP5024_OUT0_CLR,
		.bank_brt_reg = LP5024_BNK_BRT,
		.bank_mix_reg = LP5024_BNKA_CLR,
		.reset_reg = LP5024_RESET,
		.lp50xx_regmap_config = &lp5024_regmap_config,
	},
	[LP5030] = {
		.model_id = LP5030,
		.max_modules = LP5030_MAX_LED_MODULES,
		.num_leds = LP5030_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
		.led_brightness0_reg = LP5036_LED0_BRT,
		.mix_out0_reg = LP5036_OUT0_CLR,
		.bank_brt_reg = LP5036_BNK_BRT,
		.bank_mix_reg = LP5036_BNKA_CLR,
		.reset_reg = LP5036_RESET,
		.lp50xx_regmap_config = &lp5036_regmap_config,
	},
	[LP5036] = {
		.model_id = LP5036,
		.max_modules = LP5036_MAX_LED_MODULES,
		.num_leds = LP5036_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
		.led_brightness0_reg = LP5036_LED0_BRT,
		.mix_out0_reg = LP5036_OUT0_CLR,
		.bank_brt_reg = LP5036_BNK_BRT,
		.bank_mix_reg = LP5036_BNKA_CLR,
		.reset_reg = LP5036_RESET,
		.lp50xx_regmap_config = &lp5036_regmap_config,
	},
};

struct lp50xx_led {
	struct led_classdev_mc mc_cdev;
	struct lp50xx *priv;
	u8 ctrl_bank_enabled;
	int led_number;
};

/**
 * struct lp50xx -
 * @enable_gpio: hardware enable gpio
 * @regulator: LED supply regulator pointer
 * @client: pointer to the I2C client
 * @regmap: device register map
 * @dev: pointer to the devices device struct
 * @lock: lock for reading/writing the device
 * @chip_info: chip specific information (ie num_leds)
 * @leds: array of LED strings
 */
struct lp50xx {
	struct gpio_desc *enable_gpio;
	struct regulator *regulator;
	struct i2c_client *client;
	struct regmap *regmap;
	struct device *dev;
	struct mutex lock;
	const struct lp50xx_chip_info *chip_info;

	/* This needs to be at the end of the struct */
	struct lp50xx_led leds[];
};

static struct lp50xx_led *mcled_cdev_to_led(struct led_classdev_mc *mc_cdev)
{
	return container_of(mc_cdev, struct lp50xx_led, mc_cdev);
}

static int lp50xx_brightness_set(struct led_classdev *cdev,
			     enum led_brightness brightness)
{
	struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev);
	struct lp50xx_led *led = mcled_cdev_to_led(mc_dev);
	const struct lp50xx_chip_info *led_chip = led->priv->chip_info;
	u8 led_offset, reg_val;
	int ret = 0;
	int i;

	mutex_lock(&led->priv->lock);
	if (led->ctrl_bank_enabled)
		reg_val = led_chip->bank_brt_reg;
	else
		reg_val = led_chip->led_brightness0_reg +
			  led->led_number;

	ret = regmap_write(led->priv->regmap, reg_val, brightness);
	if (ret) {
		dev_err(led->priv->dev,
			"Cannot write brightness value %d\n", ret);
		goto out;
	}

	for (i = 0; i < led->mc_cdev.num_colors; i++) {
		if (led->ctrl_bank_enabled) {
			reg_val = led_chip->bank_mix_reg + i;
		} else {
			led_offset = (led->led_number * 3) + i;
			reg_val = led_chip->mix_out0_reg + led_offset;
		}

		ret = regmap_write(led->priv->regmap, reg_val,
				   mc_dev->subled_info[i].intensity);
		if (ret) {
			dev_err(led->priv->dev,
				"Cannot write intensity value %d\n", ret);
			goto out;
		}
	}
out:
	mutex_unlock(&led->priv->lock);
	return ret;
}

static int lp50xx_set_banks(struct lp50xx *priv, u32 led_banks[])
{
	u8 led_config_lo, led_config_hi;
	u32 bank_enable_mask = 0;
	int ret;
	int i;

	for (i = 0; i < priv->chip_info->max_modules; i++) {
		if (led_banks[i])
			bank_enable_mask |= (1 << led_banks[i]);
	}

	led_config_lo = bank_enable_mask;
	led_config_hi = bank_enable_mask >> 8;

	ret = regmap_write(priv->regmap, LP50XX_LED_CFG0, led_config_lo);
	if (ret)
		return ret;

	if (priv->chip_info->model_id >= LP5030)
		ret = regmap_write(priv->regmap, LP5036_LED_CFG1, led_config_hi);

	return ret;
}

static int lp50xx_reset(struct lp50xx *priv)
{
	return regmap_write(priv->regmap, priv->chip_info->reset_reg, LP50XX_SW_RESET);
}

static int lp50xx_enable_disable(struct lp50xx *priv, int enable_disable)
{
	int ret;

	ret = gpiod_direction_output(priv->enable_gpio, enable_disable);
	if (ret)
		return ret;

	if (enable_disable)
		return regmap_write(priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_EN);
	else
		return regmap_write(priv->regmap, LP50XX_DEV_CFG0, 0);

}

static int lp50xx_probe_leds(struct fwnode_handle *child, struct lp50xx *priv,
			     struct lp50xx_led *led, int num_leds)
{
	u32 led_banks[LP5036_MAX_LED_MODULES] = {0};
	int led_number;
	int ret;

	if (num_leds > 1) {
		if (num_leds > priv->chip_info->max_modules) {
			dev_err(priv->dev, "reg property is invalid\n");
			return -EINVAL;
		}

		ret = fwnode_property_read_u32_array(child, "reg", led_banks, num_leds);
		if (ret) {
			dev_err(priv->dev, "reg property is missing\n");
			return ret;
		}

		ret = lp50xx_set_banks(priv, led_banks);
		if (ret) {
			dev_err(priv->dev, "Cannot setup banked LEDs\n");
			return ret;
		}

		led->ctrl_bank_enabled = 1;
	} else {
		ret = fwnode_property_read_u32(child, "reg", &led_number);
		if (ret) {
			dev_err(priv->dev, "led reg property missing\n");
			return ret;
		}

		if (led_number > priv->chip_info->num_leds) {
			dev_err(priv->dev, "led-sources property is invalid\n");
			return -EINVAL;
		}

		led->led_number = led_number;
	}

	return 0;
}

static int lp50xx_probe_dt(struct lp50xx *priv)
{
	struct fwnode_handle *child = NULL;
	struct fwnode_handle *led_node = NULL;
	struct led_init_data init_data = {};
	struct led_classdev *led_cdev;
	struct mc_subled *mc_led_info;
	struct lp50xx_led *led;
	int ret = -EINVAL;
	int num_colors;
	u32 color_id;
	int i = 0;

	priv->enable_gpio = devm_gpiod_get_optional(priv->dev, "enable", GPIOD_OUT_LOW);
	if (IS_ERR(priv->enable_gpio))
		return dev_err_probe(priv->dev, PTR_ERR(priv->enable_gpio),
				     "Failed to get enable GPIO\n");

	priv->regulator = devm_regulator_get(priv->dev, "vled");
	if (IS_ERR(priv->regulator))
		priv->regulator = NULL;

	device_for_each_child_node(priv->dev, child) {
		led = &priv->leds[i];
		ret = fwnode_property_count_u32(child, "reg");
		if (ret < 0) {
			dev_err(priv->dev, "reg property is invalid\n");
			goto child_out;
		}

		ret = lp50xx_probe_leds(child, priv, led, ret);
		if (ret)
			goto child_out;

		init_data.fwnode = child;
		num_colors = 0;

		/*
		 * There are only 3 LEDs per module otherwise they should be
		 * banked which also is presented as 3 LEDs.
		 */
		mc_led_info = devm_kcalloc(priv->dev, LP50XX_LEDS_PER_MODULE,
					   sizeof(*mc_led_info), GFP_KERNEL);
		if (!mc_led_info) {
			ret = -ENOMEM;
			goto child_out;
		}

		fwnode_for_each_child_node(child, led_node) {
			ret = fwnode_property_read_u32(led_node, "color",
						       &color_id);
			if (ret) {
				fwnode_handle_put(led_node);
				dev_err(priv->dev, "Cannot read color\n");
				goto child_out;
			}

			mc_led_info[num_colors].color_index = color_id;
			num_colors++;
		}

		led->priv = priv;
		led->mc_cdev.num_colors = num_colors;
		led->mc_cdev.subled_info = mc_led_info;
		led_cdev = &led->mc_cdev.led_cdev;
		led_cdev->brightness_set_blocking = lp50xx_brightness_set;

		ret = devm_led_classdev_multicolor_register_ext(priv->dev,
						       &led->mc_cdev,
						       &init_data);
		if (ret) {
			dev_err(priv->dev, "led register err: %d\n", ret);
			goto child_out;
		}
		i++;
	}

	return 0;

child_out:
	fwnode_handle_put(child);
	return ret;
}

static int lp50xx_probe(struct i2c_client *client)
{
	struct lp50xx *led;
	int count;
	int ret;

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

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

	mutex_init(&led->lock);
	led->client = client;
	led->dev = &client->dev;
	led->chip_info = device_get_match_data(&client->dev);
	i2c_set_clientdata(client, led);
	led->regmap = devm_regmap_init_i2c(client,
					led->chip_info->lp50xx_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 = lp50xx_reset(led);
	if (ret)
		return ret;

	ret = lp50xx_enable_disable(led, 1);
	if (ret)
		return ret;

	return lp50xx_probe_dt(led);
}

static void lp50xx_remove(struct i2c_client *client)
{
	struct lp50xx *led = i2c_get_clientdata(client);
	int ret;

	ret = lp50xx_enable_disable(led, 0);
	if (ret)
		dev_err(led->dev, "Failed to disable chip\n");

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

	mutex_destroy(&led->lock);
}

static const struct i2c_device_id lp50xx_id[] = {
	{ "lp5009", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5009] },
	{ "lp5012", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5012] },
	{ "lp5018", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5018] },
	{ "lp5024", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5024] },
	{ "lp5030", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5030] },
	{ "lp5036", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5036] },
	{ }
};
MODULE_DEVICE_TABLE(i2c, lp50xx_id);

static const struct of_device_id of_lp50xx_leds_match[] = {
	{ .compatible = "ti,lp5009", .data = &lp50xx_chip_info_tbl[LP5009] },
	{ .compatible = "ti,lp5012", .data = &lp50xx_chip_info_tbl[LP5012] },
	{ .compatible = "ti,lp5018", .data = &lp50xx_chip_info_tbl[LP5018] },
	{ .compatible = "ti,lp5024", .data = &lp50xx_chip_info_tbl[LP5024] },
	{ .compatible = "ti,lp5030", .data = &lp50xx_chip_info_tbl[LP5030] },
	{ .compatible = "ti,lp5036", .data = &lp50xx_chip_info_tbl[LP5036] },
	{}
};
MODULE_DEVICE_TABLE(of, of_lp50xx_leds_match);

static struct i2c_driver lp50xx_driver = {
	.driver = {
		.name	= "lp50xx",
		.of_match_table = of_lp50xx_leds_match,
	},
	.probe		= lp50xx_probe,
	.remove		= lp50xx_remove,
	.id_table	= lp50xx_id,
};
module_i2c_driver(lp50xx_driver);

MODULE_DESCRIPTION("Texas Instruments LP50XX LED driver");
MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
242b8117 DM	1	// SPDX-License-Identifier: GPL-2.0
	2	// TI LP50XX LED chip family driver
	3	// Copyright (C) 2018-20 Texas Instruments Incorporated - https://www.ti.com/
	4
	5	#include <linux/gpio/consumer.h>
	6	#include <linux/i2c.h>
	7	#include <linux/init.h>
	8	#include <linux/leds.h>
fb0f236b	9	#include <linux/mod_devicetable.h>
242b8117 DM	10	#include <linux/module.h>
242b8117 DM	11	#include <linux/mutex.h>
242b8117 DM	12	#include <linux/regmap.h>
	13	#include <linux/regulator/consumer.h>
	14	#include <linux/slab.h>
	15	#include <uapi/linux/uleds.h>
	16
	17	#include <linux/led-class-multicolor.h>
	18
	19	#include "leds.h"
	20
	21	#define LP50XX_DEV_CFG0 0x00
	22	#define LP50XX_DEV_CFG1 0x01
	23	#define LP50XX_LED_CFG0 0x02
	24
	25	/* LP5009 and LP5012 registers */
	26	#define LP5012_BNK_BRT 0x03
	27	#define LP5012_BNKA_CLR 0x04
	28	#define LP5012_BNKB_CLR 0x05
	29	#define LP5012_BNKC_CLR 0x06
	30	#define LP5012_LED0_BRT 0x07
	31	#define LP5012_OUT0_CLR 0x0b
	32	#define LP5012_RESET 0x17
	33
	34	/* LP5018 and LP5024 registers */
	35	#define LP5024_BNK_BRT 0x03
	36	#define LP5024_BNKA_CLR 0x04
	37	#define LP5024_BNKB_CLR 0x05
	38	#define LP5024_BNKC_CLR 0x06
	39	#define LP5024_LED0_BRT 0x07
	40	#define LP5024_OUT0_CLR 0x0f
	41	#define LP5024_RESET 0x27
	42
	43	/* LP5030 and LP5036 registers */
	44	#define LP5036_LED_CFG1 0x03
	45	#define LP5036_BNK_BRT 0x04
	46	#define LP5036_BNKA_CLR 0x05
	47	#define LP5036_BNKB_CLR 0x06
	48	#define LP5036_BNKC_CLR 0x07
	49	#define LP5036_LED0_BRT 0x08
	50	#define LP5036_OUT0_CLR 0x14
	51	#define LP5036_RESET 0x38
	52
	53	#define LP50XX_SW_RESET 0xff
	54	#define LP50XX_CHIP_EN BIT(6)
	55
	56	/* There are 3 LED outputs per bank */
	57	#define LP50XX_LEDS_PER_MODULE 3
	58
	59	#define LP5009_MAX_LED_MODULES 2
	60	#define LP5012_MAX_LED_MODULES 4
	61	#define LP5018_MAX_LED_MODULES 6
	62	#define LP5024_MAX_LED_MODULES 8
	63	#define LP5030_MAX_LED_MODULES 10
	64	#define LP5036_MAX_LED_MODULES 12
	65
	66	static const struct reg_default lp5012_reg_defs[] = {
	67	{LP50XX_DEV_CFG0, 0x0},
	68	{LP50XX_DEV_CFG1, 0x3c},
	69	{LP50XX_LED_CFG0, 0x0},
	70	{LP5012_BNK_BRT, 0xff},
	71	{LP5012_BNKA_CLR, 0x0f},
	72	{LP5012_BNKB_CLR, 0x0f},
	73	{LP5012_BNKC_CLR, 0x0f},
	74	{LP5012_LED0_BRT, 0x0f},
	75	/* LEDX_BRT registers are all 0xff for defaults */
76	{0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff},
77	{LP5012_OUT0_CLR, 0x0f},
78	/* OUTX_CLR registers are all 0x0 for defaults */
79	{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00}, {0x10, 0x00},
80	{0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00}, {0x15, 0x00},
81	{0x16, 0x00},
82	{LP5012_RESET, 0x00}
83	};
84
85	static const struct reg_default lp5024_reg_defs[] = {
86	{LP50XX_DEV_CFG0, 0x0},
87	{LP50XX_DEV_CFG1, 0x3c},
88	{LP50XX_LED_CFG0, 0x0},
89	{LP5024_BNK_BRT, 0xff},
90	{LP5024_BNKA_CLR, 0x0f},
91	{LP5024_BNKB_CLR, 0x0f},
92	{LP5024_BNKC_CLR, 0x0f},
93	{LP5024_LED0_BRT, 0x0f},
94	/* LEDX_BRT registers are all 0xff for defaults */
95	{0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
96	{0x0d, 0xff}, {0x0e, 0xff},
97	{LP5024_OUT0_CLR, 0x0f},
98	/* OUTX_CLR registers are all 0x0 for defaults */
99	{0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00}, {0x14, 0x00},
100	{0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
101	{0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
102	{0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
103	{0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00},
104	{LP5024_RESET, 0x00}
105	};
106
107	static const struct reg_default lp5036_reg_defs[] = {
108	{LP50XX_DEV_CFG0, 0x0},
109	{LP50XX_DEV_CFG1, 0x3c},
110	{LP50XX_LED_CFG0, 0x0},
111	{LP5036_LED_CFG1, 0x0},
112	{LP5036_BNK_BRT, 0xff},
113	{LP5036_BNKA_CLR, 0x0f},
114	{LP5036_BNKB_CLR, 0x0f},
115	{LP5036_BNKC_CLR, 0x0f},
116	{LP5036_LED0_BRT, 0x0f},
117	/* LEDX_BRT registers are all 0xff for defaults */
118	{0x08, 0xff}, {0x09, 0xff}, {0x0a, 0xff}, {0x0b, 0xff}, {0x0c, 0xff},
119	{0x0d, 0xff}, {0x0e, 0xff}, {0x0f, 0xff}, {0x10, 0xff}, {0x11, 0xff},
120	{0x12, 0xff}, {0x13, 0xff},
121	{LP5036_OUT0_CLR, 0x0f},
122	/* OUTX_CLR registers are all 0x0 for defaults */
123	{0x15, 0x00}, {0x16, 0x00}, {0x17, 0x00}, {0x18, 0x00}, {0x19, 0x00},
124	{0x1a, 0x00}, {0x1b, 0x00}, {0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00},
125	{0x1f, 0x00}, {0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x00},
126	{0x24, 0x00}, {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
127	{0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00}, {0x2c, 0x00}, {0x2d, 0x00},
128	{0x2e, 0x00}, {0x2f, 0x00}, {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00},
129	{0x33, 0x00}, {0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x00},
130	{LP5036_RESET, 0x00}
131	};
132
133	static const struct regmap_config lp5012_regmap_config = {
134	.reg_bits = 8,
135	.val_bits = 8,
136
137	.max_register = LP5012_RESET,
138	.reg_defaults = lp5012_reg_defs,
139	.num_reg_defaults = ARRAY_SIZE(lp5012_reg_defs),
140	.cache_type = REGCACHE_FLAT,
141	};
142
143	static const struct regmap_config lp5024_regmap_config = {
144	.reg_bits = 8,
145	.val_bits = 8,
146
147	.max_register = LP5024_RESET,
148	.reg_defaults = lp5024_reg_defs,
149	.num_reg_defaults = ARRAY_SIZE(lp5024_reg_defs),
150	.cache_type = REGCACHE_FLAT,
151	};
152
153	static const struct regmap_config lp5036_regmap_config = {
154	.reg_bits = 8,
155	.val_bits = 8,
156
157	.max_register = LP5036_RESET,
158	.reg_defaults = lp5036_reg_defs,
159	.num_reg_defaults = ARRAY_SIZE(lp5036_reg_defs),
160	.cache_type = REGCACHE_FLAT,
161	};
162
163	enum lp50xx_model {
164	LP5009,
165	LP5012,
166	LP5018,
167	LP5024,
168	LP5030,
169	LP5036,
170	};
171
172	/**
173	* struct lp50xx_chip_info -
174	* @lp50xx_regmap_config: regmap register configuration
175	* @model_id: LED device model
176	* @max_modules: total number of supported LED modules
177	* @num_leds: number of LED outputs available on the device
178	* @led_brightness0_reg: first brightness register of the device
179	* @mix_out0_reg: first color mix register of the device
180	* @bank_brt_reg: bank brightness register
181	* @bank_mix_reg: color mix register
182	* @reset_reg: device reset register
183	*/
184	struct lp50xx_chip_info {
185	const struct regmap_config *lp50xx_regmap_config;
186	int model_id;
187	u8 max_modules;
188	u8 num_leds;
189	u8 led_brightness0_reg;
190	u8 mix_out0_reg;
191	u8 bank_brt_reg;
192	u8 bank_mix_reg;
193	u8 reset_reg;
194	};
195
196	static const struct lp50xx_chip_info lp50xx_chip_info_tbl[] = {
197	[LP5009] = {
198	.model_id = LP5009,
199	.max_modules = LP5009_MAX_LED_MODULES,
200	.num_leds = LP5009_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
201	.led_brightness0_reg = LP5012_LED0_BRT,
202	.mix_out0_reg = LP5012_OUT0_CLR,
203	.bank_brt_reg = LP5012_BNK_BRT,
204	.bank_mix_reg = LP5012_BNKA_CLR,
205	.reset_reg = LP5012_RESET,
206	.lp50xx_regmap_config = &lp5012_regmap_config,
207	},
208	[LP5012] = {
209	.model_id = LP5012,
210	.max_modules = LP5012_MAX_LED_MODULES,
211	.num_leds = LP5012_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
212	.led_brightness0_reg = LP5012_LED0_BRT,
213	.mix_out0_reg = LP5012_OUT0_CLR,
214	.bank_brt_reg = LP5012_BNK_BRT,
215	.bank_mix_reg = LP5012_BNKA_CLR,
216	.reset_reg = LP5012_RESET,
217	.lp50xx_regmap_config = &lp5012_regmap_config,
218	},
219	[LP5018] = {
220	.model_id = LP5018,
221	.max_modules = LP5018_MAX_LED_MODULES,
222	.num_leds = LP5018_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
223	.led_brightness0_reg = LP5024_LED0_BRT,
224	.mix_out0_reg = LP5024_OUT0_CLR,
225	.bank_brt_reg = LP5024_BNK_BRT,
226	.bank_mix_reg = LP5024_BNKA_CLR,
227	.reset_reg = LP5024_RESET,
228	.lp50xx_regmap_config = &lp5024_regmap_config,
229	},
230	[LP5024] = {
231	.model_id = LP5024,
232	.max_modules = LP5024_MAX_LED_MODULES,
233	.num_leds = LP5024_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
234	.led_brightness0_reg = LP5024_LED0_BRT,
235	.mix_out0_reg = LP5024_OUT0_CLR,
236	.bank_brt_reg = LP5024_BNK_BRT,
237	.bank_mix_reg = LP5024_BNKA_CLR,
238	.reset_reg = LP5024_RESET,
239	.lp50xx_regmap_config = &lp5024_regmap_config,
240	},
241	[LP5030] = {
242	.model_id = LP5030,
243	.max_modules = LP5030_MAX_LED_MODULES,
244	.num_leds = LP5030_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
245	.led_brightness0_reg = LP5036_LED0_BRT,
246	.mix_out0_reg = LP5036_OUT0_CLR,
247	.bank_brt_reg = LP5036_BNK_BRT,
248	.bank_mix_reg = LP5036_BNKA_CLR,
249	.reset_reg = LP5036_RESET,
250	.lp50xx_regmap_config = &lp5036_regmap_config,
251	},
252	[LP5036] = {
253	.model_id = LP5036,
254	.max_modules = LP5036_MAX_LED_MODULES,
255	.num_leds = LP5036_MAX_LED_MODULES * LP50XX_LEDS_PER_MODULE,
256	.led_brightness0_reg = LP5036_LED0_BRT,
257	.mix_out0_reg = LP5036_OUT0_CLR,
258	.bank_brt_reg = LP5036_BNK_BRT,
259	.bank_mix_reg = LP5036_BNKA_CLR,
260	.reset_reg = LP5036_RESET,
261	.lp50xx_regmap_config = &lp5036_regmap_config,
262	},
263	};
264
265	struct lp50xx_led {
266	struct led_classdev_mc mc_cdev;
267	struct lp50xx *priv;
242b8117 DM	268	u8 ctrl_bank_enabled;
	269	int led_number;
	270	};
	271
	272	/**
	273	* struct lp50xx -
	274	* @enable_gpio: hardware enable gpio
	275	* @regulator: LED supply regulator pointer
	276	* @client: pointer to the I2C client
	277	* @regmap: device register map
	278	* @dev: pointer to the devices device struct
	279	* @lock: lock for reading/writing the device
	280	* @chip_info: chip specific information (ie num_leds)
242b8117 DM	281	* @leds: array of LED strings
	282	*/
	283	struct lp50xx {
	284	struct gpio_desc *enable_gpio;
	285	struct regulator *regulator;
	286	struct i2c_client *client;
	287	struct regmap *regmap;
	288	struct device *dev;
	289	struct mutex lock;
	290	const struct lp50xx_chip_info *chip_info;
242b8117 DM	291
	292	/* This needs to be at the end of the struct */
	293	struct lp50xx_led leds[];
	294	};
	295
	296	static struct lp50xx_led mcled_cdev_to_led(struct led_classdev_mc mc_cdev)
	297	{
	298	return container_of(mc_cdev, struct lp50xx_led, mc_cdev);
	299	}
	300
	301	static int lp50xx_brightness_set(struct led_classdev *cdev,
	302	enum led_brightness brightness)
	303	{
	304	struct led_classdev_mc *mc_dev = lcdev_to_mccdev(cdev);
	305	struct lp50xx_led *led = mcled_cdev_to_led(mc_dev);
	306	const struct lp50xx_chip_info *led_chip = led->priv->chip_info;
	307	u8 led_offset, reg_val;
	308	int ret = 0;
	309	int i;
	310
	311	mutex_lock(&led->priv->lock);
	312	if (led->ctrl_bank_enabled)
	313	reg_val = led_chip->bank_brt_reg;
	314	else
	315	reg_val = led_chip->led_brightness0_reg +
	316	led->led_number;
	317
	318	ret = regmap_write(led->priv->regmap, reg_val, brightness);
	319	if (ret) {
556f15fe	320	dev_err(led->priv->dev,
242b8117 DM	321	"Cannot write brightness value %d\n", ret);
	322	goto out;
	323	}
	324
	325	for (i = 0; i < led->mc_cdev.num_colors; i++) {
	326	if (led->ctrl_bank_enabled) {
	327	reg_val = led_chip->bank_mix_reg + i;
	328	} else {
	329	led_offset = (led->led_number * 3) + i;
	330	reg_val = led_chip->mix_out0_reg + led_offset;
	331	}
	332
	333	ret = regmap_write(led->priv->regmap, reg_val,
	334	mc_dev->subled_info[i].intensity);
	335	if (ret) {
556f15fe	336	dev_err(led->priv->dev,
242b8117 DM	337	"Cannot write intensity value %d\n", ret);
	338	goto out;
	339	}
	340	}
	341	out:
	342	mutex_unlock(&led->priv->lock);
	343	return ret;
	344	}
	345
	346	static int lp50xx_set_banks(struct lp50xx *priv, u32 led_banks[])
	347	{
	348	u8 led_config_lo, led_config_hi;
	349	u32 bank_enable_mask = 0;
	350	int ret;
	351	int i;
	352
	353	for (i = 0; i < priv->chip_info->max_modules; i++) {
	354	if (led_banks[i])
	355	bank_enable_mask \|= (1 << led_banks[i]);
	356	}
	357
b0a82efa AS	358	led_config_lo = bank_enable_mask;
b0a82efa AS	359	led_config_hi = bank_enable_mask >> 8;
242b8117 DM	360
	361	ret = regmap_write(priv->regmap, LP50XX_LED_CFG0, led_config_lo);
	362	if (ret)
	363	return ret;
	364
	365	if (priv->chip_info->model_id >= LP5030)
	366	ret = regmap_write(priv->regmap, LP5036_LED_CFG1, led_config_hi);
	367
	368	return ret;
	369	}
	370
	371	static int lp50xx_reset(struct lp50xx *priv)
	372	{
	373	return regmap_write(priv->regmap, priv->chip_info->reset_reg, LP50XX_SW_RESET);
	374	}
	375
	376	static int lp50xx_enable_disable(struct lp50xx *priv, int enable_disable)
	377	{
	378	int ret;
	379
5d2bfb3f AS	380	ret = gpiod_direction_output(priv->enable_gpio, enable_disable);
	381	if (ret)
	382	return ret;
242b8117 DM	383
	384	if (enable_disable)
	385	return regmap_write(priv->regmap, LP50XX_DEV_CFG0, LP50XX_CHIP_EN);
	386	else
	387	return regmap_write(priv->regmap, LP50XX_DEV_CFG0, 0);
	388
	389	}
	390
	391	static int lp50xx_probe_leds(struct fwnode_handle child, struct lp50xx priv,
	392	struct lp50xx_led *led, int num_leds)
	393	{
	394	u32 led_banks[LP5036_MAX_LED_MODULES] = {0};
	395	int led_number;
	396	int ret;
	397
	398	if (num_leds > 1) {
	399	if (num_leds > priv->chip_info->max_modules) {
556f15fe	400	dev_err(priv->dev, "reg property is invalid\n");
242b8117 DM	401	return -EINVAL;
	402	}
	403
242b8117 DM	404	ret = fwnode_property_read_u32_array(child, "reg", led_banks, num_leds);
242b8117 DM	405	if (ret) {
556f15fe	406	dev_err(priv->dev, "reg property is missing\n");
242b8117 DM	407	return ret;
	408	}
	409
	410	ret = lp50xx_set_banks(priv, led_banks);
	411	if (ret) {
556f15fe	412	dev_err(priv->dev, "Cannot setup banked LEDs\n");
242b8117 DM	413	return ret;
	414	}
	415
	416	led->ctrl_bank_enabled = 1;
	417	} else {
	418	ret = fwnode_property_read_u32(child, "reg", &led_number);
	419	if (ret) {
556f15fe	420	dev_err(priv->dev, "led reg property missing\n");
242b8117 DM	421	return ret;
	422	}
	423
	424	if (led_number > priv->chip_info->num_leds) {
556f15fe	425	dev_err(priv->dev, "led-sources property is invalid\n");
242b8117 DM	426	return -EINVAL;
	427	}
	428
	429	led->led_number = led_number;
	430	}
	431
	432	return 0;
	433	}
	434
	435	static int lp50xx_probe_dt(struct lp50xx *priv)
	436	{
	437	struct fwnode_handle *child = NULL;
	438	struct fwnode_handle *led_node = NULL;
	439	struct led_init_data init_data = {};
	440	struct led_classdev *led_cdev;
	441	struct mc_subled *mc_led_info;
	442	struct lp50xx_led *led;
	443	int ret = -EINVAL;
	444	int num_colors;
	445	u32 color_id;
	446	int i = 0;
	447
	448	priv->enable_gpio = devm_gpiod_get_optional(priv->dev, "enable", GPIOD_OUT_LOW);
9a10def9 AS	449	if (IS_ERR(priv->enable_gpio))
	450	return dev_err_probe(priv->dev, PTR_ERR(priv->enable_gpio),
	451	"Failed to get enable GPIO\n");
242b8117 DM	452
	453	priv->regulator = devm_regulator_get(priv->dev, "vled");
	454	if (IS_ERR(priv->regulator))
	455	priv->regulator = NULL;
	456
	457	device_for_each_child_node(priv->dev, child) {
	458	led = &priv->leds[i];
	459	ret = fwnode_property_count_u32(child, "reg");
	460	if (ret < 0) {
556f15fe	461	dev_err(priv->dev, "reg property is invalid\n");
242b8117 DM	462	goto child_out;
	463	}
	464
	465	ret = lp50xx_probe_leds(child, priv, led, ret);
	466	if (ret)
	467	goto child_out;
	468
	469	init_data.fwnode = child;
	470	num_colors = 0;
	471
	472	/*
	473	* There are only 3 LEDs per module otherwise they should be
	474	* banked which also is presented as 3 LEDs.
	475	*/
	476	mc_led_info = devm_kcalloc(priv->dev, LP50XX_LEDS_PER_MODULE,
	477	sizeof(*mc_led_info), GFP_KERNEL);
6d8d014c CJ	478	if (!mc_led_info) {
	479	ret = -ENOMEM;
	480	goto child_out;
	481	}
242b8117 DM	482
	483	fwnode_for_each_child_node(child, led_node) {
	484	ret = fwnode_property_read_u32(led_node, "color",
	485	&color_id);
	486	if (ret) {
f1e1d532	487	fwnode_handle_put(led_node);
242b8117 DM	488	dev_err(priv->dev, "Cannot read color\n");
	489	goto child_out;
	490	}
	491
	492	mc_led_info[num_colors].color_index = color_id;
	493	num_colors++;
	494	}
	495
	496	led->priv = priv;
	497	led->mc_cdev.num_colors = num_colors;
	498	led->mc_cdev.subled_info = mc_led_info;
	499	led_cdev = &led->mc_cdev.led_cdev;
	500	led_cdev->brightness_set_blocking = lp50xx_brightness_set;
	501
556f15fe	502	ret = devm_led_classdev_multicolor_register_ext(priv->dev,
242b8117 DM	503	&led->mc_cdev,
	504	&init_data);
	505	if (ret) {
556f15fe	506	dev_err(priv->dev, "led register err: %d\n", ret);
242b8117 DM	507	goto child_out;
	508	}
	509	i++;
242b8117 DM	510	}
	511
	512	return 0;
	513
	514	child_out:
	515	fwnode_handle_put(child);
	516	return ret;
	517	}
	518
ea1ff99c	519	static int lp50xx_probe(struct i2c_client *client)
242b8117 DM	520	{
	521	struct lp50xx *led;
	522	int count;
	523	int ret;
	524
	525	count = device_get_child_node_count(&client->dev);
	526	if (!count) {
	527	dev_err(&client->dev, "LEDs are not defined in device tree!");
	528	return -ENODEV;
	529	}
	530
	531	led = devm_kzalloc(&client->dev, struct_size(led, leds, count),
	532	GFP_KERNEL);
	533	if (!led)
	534	return -ENOMEM;
	535
	536	mutex_init(&led->lock);
	537	led->client = client;
	538	led->dev = &client->dev;
ea1ff99c	539	led->chip_info = device_get_match_data(&client->dev);
242b8117 DM	540	i2c_set_clientdata(client, led);
	541	led->regmap = devm_regmap_init_i2c(client,
	542	led->chip_info->lp50xx_regmap_config);
	543	if (IS_ERR(led->regmap)) {
	544	ret = PTR_ERR(led->regmap);
	545	dev_err(&client->dev, "Failed to allocate register map: %d\n",
	546	ret);
	547	return ret;
	548	}
	549
	550	ret = lp50xx_reset(led);
	551	if (ret)
	552	return ret;
	553
	554	ret = lp50xx_enable_disable(led, 1);
	555	if (ret)
	556	return ret;
	557
	558	return lp50xx_probe_dt(led);
	559	}
	560
ed5c2f5f	561	static void lp50xx_remove(struct i2c_client *client)
242b8117 DM	562	{
	563	struct lp50xx *led = i2c_get_clientdata(client);
	564	int ret;
	565
	566	ret = lp50xx_enable_disable(led, 0);
73bce575	567	if (ret)
556f15fe	568	dev_err(led->dev, "Failed to disable chip\n");
242b8117 DM	569
	570	if (led->regulator) {
	571	ret = regulator_disable(led->regulator);
	572	if (ret)
556f15fe	573	dev_err(led->dev, "Failed to disable regulator\n");
242b8117 DM	574	}
	575
	576	mutex_destroy(&led->lock);
242b8117 DM	577	}
	578
	579	static const struct i2c_device_id lp50xx_id[] = {
ea1ff99c AS	580	{ "lp5009", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5009] },
	581	{ "lp5012", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5012] },
	582	{ "lp5018", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5018] },
	583	{ "lp5024", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5024] },
	584	{ "lp5030", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5030] },
	585	{ "lp5036", (kernel_ulong_t)&lp50xx_chip_info_tbl[LP5036] },
242b8117 DM	586	{ }
	587	};
	588	MODULE_DEVICE_TABLE(i2c, lp50xx_id);
	589
	590	static const struct of_device_id of_lp50xx_leds_match[] = {
ea1ff99c AS	591	{ .compatible = "ti,lp5009", .data = &lp50xx_chip_info_tbl[LP5009] },
	592	{ .compatible = "ti,lp5012", .data = &lp50xx_chip_info_tbl[LP5012] },
	593	{ .compatible = "ti,lp5018", .data = &lp50xx_chip_info_tbl[LP5018] },
	594	{ .compatible = "ti,lp5024", .data = &lp50xx_chip_info_tbl[LP5024] },
	595	{ .compatible = "ti,lp5030", .data = &lp50xx_chip_info_tbl[LP5030] },
	596	{ .compatible = "ti,lp5036", .data = &lp50xx_chip_info_tbl[LP5036] },
	597	{}
242b8117 DM	598	};
	599	MODULE_DEVICE_TABLE(of, of_lp50xx_leds_match);
	600
	601	static struct i2c_driver lp50xx_driver = {
	602	.driver = {
	603	.name = "lp50xx",
	604	.of_match_table = of_lp50xx_leds_match,
	605	},
d9ff8a8e	606	.probe = lp50xx_probe,
242b8117 DM	607	.remove = lp50xx_remove,
	608	.id_table = lp50xx_id,
	609	};
	610	module_i2c_driver(lp50xx_driver);
	611
	612	MODULE_DESCRIPTION("Texas Instruments LP50XX LED driver");
	613	MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
	614	MODULE_LICENSE("GPL v2");