drivers/leds/leds-lp5018.c - manifest_repos/kernel - Git at Google

 /*
  * LP5018 LED chip driver.
  *
  * Copyright (C) 2019 Google, Inc.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  */

 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/slab.h>
 #include <linux/platform_data/leds-lp50xx.h>

 /* Register Table */
 /* LED mode registers (read/write) */
 #define LP5018_DEVICE_CONFIG0		0x00
 #define LP5018_DEVICE_CONFIG1		0x01
 #define LP5018_GLOBAL_DIMMING		0x03
 #define LP5018_BRIGHTNESS_BASE		0x07
 #define LP5018_COLOR_BASE		0x0F
 #define LP5018_MAX_LED_CHANNELS		24

 #define NUM_OF_RETRIES			5

 struct lp5018_led {
 	struct i2c_client *client;
 	const struct lp50xx_platform_data *pdata;
 	struct attribute **all_attrs;
 	struct device_attribute *iref_pwm_attrs;
 	struct attribute_group iref_pwm_attr_group;
 	const struct lp5018_registers *reg;
 };

 enum chip_model_t {
 	LP5018,
 };

 static const struct lp5018_registers {
 	const char* model;
 	const u8 reg_global_dimming;
 	const u8 reg_pwm_base;
 	const u8 reg_iref_base;
 	const int led_channels;
 } kModelRegisterMap[] = {
 	{ "lp5018",
 	LP5018_GLOBAL_DIMMING,
 	LP5018_COLOR_BASE,
 	LP5018_BRIGHTNESS_BASE,
 	LP5018_MAX_LED_CHANNELS},
 };

 static const struct lp5018_registers* lp5018_dev_to_register (struct device *dev) {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	return data->reg;
 }

 static int lp5018_led_read_byte(struct i2c_client *client, u8 reg, u8 *buf)
 {
 	s32 ret = i2c_smbus_read_byte_data(client, reg);
 	if (ret < 0)
 		return ret;

 	*buf = ret;
 	return 0;
 }

 static int lp5018_led_write_byte(struct i2c_client *client, u8 reg, u8 val)
 {
 	int ret = i2c_smbus_write_byte_data(client, reg, val);
 	if (ret < 0) {
 		dev_err(&client->dev, "%s: failed to write byte data, ret=%d\n",
 			__func__, ret);
 	}
 	return ret;
 }

 static int lp5018_led_read_block_data(struct i2c_client *client, u8 reg,
 		u8 len, void *val)
 {
 	int ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);

 	if (ret == len)
 		return 0;

 	dev_err(&client->dev, "%s: failed on block read.\n", __func__);
 	return -EIO;
 }

 static int lp5018_led_write_block_data(struct i2c_client *client, u8 reg,
 		u8 len, const void *val)
 {
 	int ret;
 	int retry = 0;

 	// TODO: We should make sure Auto_Incr_EN is enabled
 	do {
 		ret = i2c_smbus_write_i2c_block_data(client,
 			reg, len, val);

 		if (ret < 0) {
 			dev_err(&client->dev, "%s: failed on block write. "
 				"ret=%d, retry=%d\n",
 			__func__, ret, retry);
 		}
 		++retry;

 	} while (ret == -ERESTARTSYS && retry < NUM_OF_RETRIES);

 	return ret;
 }

 static int lp5018_led_reset(struct lp5018_led *data)
 {
 	struct i2c_client *client = data->client;
 	int reset = data->pdata->reset_gpio;
 	int ret = gpio_request(reset, "LedRST");
 	if (ret) {
 		dev_err(&client->dev, "%s: failed to request GPIO%d.\n",
 			__func__, reset);
 		return ret;
 	}
 	ret = gpio_direction_output(reset, 1);
 	if (ret) {
 		dev_err(&client->dev,
 			"%s: failed to set gpio to 1.\n", __func__);
 		gpio_free(reset);
 		return ret;
 	}
 	gpio_set_value(reset, 0);
 	msleep(1);
 	gpio_set_value(reset, 1);

 	gpio_free(reset);
 	return ret;
 }

 static int lp5018_led_init(struct lp5018_led *data)
 {
 	struct i2c_client *client = data->client;

 	int ret, i;

 	printk("lp5018_led_init\n");

 	// Toggle enable pin
 	ret = lp5018_led_reset(data);
 	if (ret)
 		dev_err(&client->dev, "%s: failed to reset LED.\n", __func__);
 	msleep(1);

 	// Enable driver
 	// Set Chip_EN
 	ret = lp5018_led_write_byte(client, LP5018_DEVICE_CONFIG0, 0x40);
 	// Set Log_Scale_EN, Power_save_EN, Auto_incr_EN and PWm_Dithering_EN
 	ret = lp5018_led_write_byte(client, LP5018_DEVICE_CONFIG1, 0x3C);

 	data->reg = &kModelRegisterMap[LP5018];

 	// Set brightness to 0x80 for all LEDs (default is 0xFF)
 	for (i = 0; i < 8; ++i) {
 		ret = lp5018_led_write_byte(client,
 					    data->reg->reg_iref_base + i,
 					    0x80);
 		if (ret < 0) {
 			dev_err(&client->dev,  "%s: failed to set brightness"
 				"for led %d to 0x80. ret=%d.\n",
 				__func__, i, ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 /* Helper function to show pwm control values. */
 static ssize_t lp5018_led_pwm_show_helper(struct device *dev,
 		unsigned int led_index, char *buf,
 		u8 addr)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int ret;
 	u8 rgb[3];

 	if (led_index >= data->pdata->num_leds) {
 		dev_err(dev, "%s: invalid led number: %d\n", __func__,
 			led_index);
 		return -EINVAL;
 	}

 	addr += data->pdata->start_num[led_index];
 	ret = lp5018_led_read_block_data(client, addr, sizeof(rgb), rgb);
 	if (ret) {
 		dev_err(dev, "%s: failed to read RGB values.\n", __func__);
 		return -EIO;
 	}

 	return scnprintf(buf, PAGE_SIZE, "%hhu %hhu %hhu\n",
 			rgb[0], rgb[1], rgb[2]);
 }

 /* Helper function to show iref control values. */
 static ssize_t lp5018_led_iref_show_helper(struct device *dev,
 		unsigned int led_index, char *buf,
 		u8 addr)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int ret;
 	u8 brightness;

 	if (led_index >= data->pdata->num_leds) {
 		dev_err(dev, "%s: invalid led number: %d\n", __func__,
 			led_index);
 		return -EINVAL;
 	}

 	addr += led_index;

 	ret = lp5018_led_read_byte(client, addr, &brightness);

 	if (ret) {
 		dev_err(dev, "%s: failed to read brightness.\n", __func__);
 		return -EIO;
 	}

 	return scnprintf(buf, PAGE_SIZE, "%hhu\n", brightness);
 }

 /* Helper function to store pwm control value to certain LED.
  * Input is a char array.
  * Format: "255 255 255"
  * The input represent R, G, B values from left to right, respectively.
  */
 static ssize_t lp5018_led_pwm_store_helper(struct device *dev,
 		unsigned int led_index,
 		const char *buf, size_t count, u8 addr)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int ret;
 	u8 rgb[3];

 	if (led_index >= data->pdata->num_leds) {
 		dev_err(dev, "%s: invalid led number: %d\n", __func__,
 			led_index);
 		return -EINVAL;
 	}

 	ret = sscanf(buf, "%hhu %hhu %hhu", &rgb[0], &rgb[1], &rgb[2]);
 	if (ret != 3) {
 		dev_err(dev, "%s: failed to parse rgb values, ret=%d.\n",
 			__func__, ret);
 		return -EINVAL;
 	}

 	addr += data->pdata->start_num[led_index];
 	ret = lp5018_led_write_block_data(client, addr, sizeof(rgb), rgb);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to write rgb values to led%d.\n",
 			__func__, led_index);
 		return ret;
 	}
 	dev_dbg(dev, "%s %s: set led%u(0x%02x): R=%hhu, G=%hhu, B=%hhu\n",
 		__func__, client->name, led_index, addr,
 		rgb[0], rgb[1], rgb[2]);
 	return count;
 }

 static ssize_t lp5018_led_iref_store_helper(struct device *dev,
 		unsigned int led_index,
 		const char *buf, size_t count, u8 addr)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int ret;
 	u8 brightness;

 	if (led_index >= data->pdata->num_leds) {
 		dev_err(dev, "%s: invalid led number: %d\n", __func__,
 			led_index);
 		return -EINVAL;
 	}

 	ret = sscanf(buf, "%hhu", &brightness);
 	if (ret != 1) {
 		dev_err(dev, "%s: failed to parse brightness, ret=%d.\n",
 			__func__, ret);
 		return -EINVAL;
 	}

 	addr += led_index;

 	ret = lp5018_led_write_byte(client, addr, brightness);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to write brightness to led%d.\n",
 			__func__, led_index);
 		return ret;
 	}
 	dev_dbg(dev, "%s %s: set led%u(0x%02x): Val=%hhu\n",
 		__func__, client->name, led_index, addr,
 		brightness);
 	return count;
 }

 static ssize_t lp5018_led_pwm_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	unsigned int led_index;
 	int ret = sscanf(attr->attr.name, "pwm%u", &led_index);

 	if (ret != 1) {
 		dev_err(dev, "%s: failed to get led index.\n", __func__);
 		return -EINVAL;
 	}

 	return lp5018_led_pwm_show_helper(dev, led_index, buf,
 			lp5018_dev_to_register(dev)->reg_pwm_base);
 }

 static ssize_t lp5018_led_pwm_store(struct device *dev,
 		struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	unsigned int led_index;
 	int ret = sscanf(attr->attr.name, "pwm%u", &led_index);

 	if (ret != 1) {
 		dev_err(dev, "%s: failed to get led index.\n", __func__);
 		return -EINVAL;
 	}

 	return lp5018_led_pwm_store_helper(dev, led_index, buf, count,
 			lp5018_dev_to_register(dev)->reg_pwm_base);
 }


 /* Function to store pwm control values to specified LEDs.
  * Input Format" "LED_Index R G B LED_Index R G B ..."
  * Note: All LED indices not specified will have their
  *    (R,G,B) set to (0, 0 ,0)
  * LED indices can be specified in any order
  * For example: "0 255 255 255 1 100 150 200" is equivalent
  *    to "1 100 150 200 0 255 255 255"
  */
 static ssize_t lp5018_led_pwm_all_store(struct device *dev,
 		struct device_attribute *attr,
 		const char *buf,
 		size_t count)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int num_leds = 0;
 	int chars_read = 0;
 	int led_idx;
 	int ret;
 	int rgb_start_idx;
 	u8 rgb[lp5018_dev_to_register(dev)->led_channels];
 	memset(rgb, 0, sizeof(rgb));

 	while (sscanf(buf, "%d%n", &led_idx, &chars_read) == 1) {
 		if (led_idx > data->pdata->num_leds - 1 || led_idx < 0) {
 			dev_err(dev, "%s: incorrect led index %d supplied\n", __func__, led_idx);
 			return -EINVAL;
 		}

 		++num_leds;
 		if (num_leds > data->pdata->num_leds) {
 			dev_err(dev, "%s: incorrect number of leds supplied\n", __func__);
 			return -EINVAL;
 		}

 		buf += chars_read;
 		rgb_start_idx = data->pdata->start_num[led_idx];
 		if (sscanf(buf, "%hhu %hhu %hhu%n", &rgb[rgb_start_idx],
 					&rgb[rgb_start_idx + 1],
 					&rgb[rgb_start_idx + 2],
 					&chars_read) != 3) {
 			dev_err(dev, "%s: unable to parse led values to write\n", __func__);
 			return -EINVAL;
 		}
 		buf += chars_read;
 	}

 	ret = lp5018_led_write_block_data(client,
 			lp5018_dev_to_register(dev)->reg_pwm_base,
 			sizeof(rgb), rgb);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to write rgb values to all leds, err: %d\n",
 				__func__, ret);
 		return ret;
 	}

 	return count;
 }

 static ssize_t lp5018_led_iref_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
 	unsigned int led_index;
 	int ret = sscanf(attr->attr.name, "iref%u", &led_index);

 	if (ret != 1) {
 		dev_err(dev, "%s: failed to get led index.\n", __func__);
 		return -EINVAL;
 	}

 	return lp5018_led_iref_show_helper(dev, led_index, buf,
 			lp5018_dev_to_register(dev)->reg_iref_base);
 }

 static ssize_t lp5018_led_iref_store(struct device *dev,
 				struct device_attribute *attr,
 				const char *buf, size_t count)
 {
 	unsigned int led_index;
 	int ret = sscanf(attr->attr.name, "iref%u", &led_index);
 	if (ret != 1) {
 		dev_err(dev, "%s: failed to get led index.\n", __func__);
 		return -EINVAL;
 	}

 	return lp5018_led_iref_store_helper(dev, led_index, buf, count,
 			lp5018_dev_to_register(dev)->reg_iref_base);
 }


 static ssize_t lp5018_led_show_byte_helper(struct device *dev,
 		char *buf, u8 addr)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	u8 read_buf;
 	int ret = lp5018_led_read_byte(client, addr, &read_buf);

 	if (ret < 0)
 		return ret;

 	return scnprintf(buf, PAGE_SIZE, "%u\n", read_buf);
 }

 static ssize_t lp5018_led_global_dimming_show(struct device *dev,
 		struct device_attribute *attr,
 		char *buf)
 {
 	return lp5018_led_show_byte_helper(dev, buf,
 			lp5018_dev_to_register(dev)->reg_global_dimming);
 }

 static ssize_t lp5018_led_global_dimming_store(struct device *dev,
 		struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	int global_dimming;
 	int ret;

 	if (kstrtouint(buf, 10, &global_dimming))
 		return -EINVAL;

 	/* Do the mask to handle minor input errors without reporting error. */
 	global_dimming = global_dimming & 0xFF;
 	ret = lp5018_led_write_byte(client,
 			lp5018_dev_to_register(dev)->reg_global_dimming,
 			global_dimming);
 	if (ret < 0) {
 		dev_err(dev, "%s: failed to write global_dimming.\n", __func__);
 		return ret;
 	}

 	return count;
 }

 static ssize_t lp5018_led_init_store(struct device *dev,
 		struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct i2c_client *client = to_i2c_client(dev);
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int ret;

 	dev_info(dev, "%s: initializing LED...\n", __func__);
 	ret = lp5018_led_init(data);
 	if (ret) {
 		dev_err(dev, "%s: failed to initialize LED. ret=%d\n",
 			__func__, ret);
 		return ret;
 	}

 	return count;
 }

 static DEVICE_ATTR(global_dimming, S_IWUSR | S_IWGRP | S_IRUGO,
 		lp5018_led_global_dimming_show,
 		lp5018_led_global_dimming_store);
 static DEVICE_ATTR(init_led, S_IWUSR | S_IWGRP, NULL, lp5018_led_init_store);
 static DEVICE_ATTR(pwm_all, S_IWUSR | S_IWGRP | S_IRUGO,
 		NULL, lp5018_led_pwm_all_store);

 static struct attribute *other_led_attrs[] = {
 	&dev_attr_global_dimming.attr,
 	&dev_attr_init_led.attr,
 	&dev_attr_pwm_all.attr,
 	NULL
 };


 static const struct attribute_group lp5018_led_other_attr_group = {
 	.attrs = other_led_attrs,
 };

 #ifdef CONFIG_OF
 static struct lp50xx_platform_data *lp5018_led_parse_devtree(
 		struct i2c_client *client)
 {
 	struct device *dev = &client->dev;
 	struct device_node *node;
 	struct lp50xx_platform_data *pdata;
 	int reset_gpio = -1;

 	node = dev->of_node;
 	if (!node) {
 		dev_err(dev, "%s: of_node is NULL.\n", __func__);
 		return ERR_PTR(-ENODEV);
 	}

 	pdata = devm_kzalloc(dev, sizeof(struct device_node), GFP_KERNEL);
 	if (!pdata) {
 		dev_err(dev, "%s: not enough memory left.\n", __func__);
 		return ERR_PTR(-ENOMEM);
 	}

 	if (of_property_read_u32(node, "num_leds", &pdata->num_leds)) {
 		dev_err(dev, "%s: failed to get number of leds.\n", __func__);
 		devm_kfree(dev, pdata);
 		return ERR_PTR(-EINVAL);
 	}
 	printk("lp5018 num_leds=%d\n", pdata->num_leds);

 	if (of_property_read_u32_array(node, "start_num", (u32 *)&pdata->start_num,
 				pdata->num_leds)) {
 		dev_err(dev, "%s: failed to get pwm register addresses.\n",
 			__func__);
 		devm_kfree(dev, pdata);
 		return ERR_PTR(-EINVAL);
 	}

 	reset_gpio = of_get_named_gpio(node, "reset_gpio", 0);
 	if (!gpio_is_valid(reset_gpio)) {
 		dev_err(dev, "%s: failed to get reset_gpio.\n", __func__);
 		return ERR_PTR(-ENODEV);
 	}
 	pdata->reset_gpio = reset_gpio;

 	return pdata;
 }
 #endif

 static void delete_iref_pwm_attr_array(struct lp5018_led *data, int num_leds)
 {
 	if (data->iref_pwm_attrs) {
 		int i;
 		for (i = 0; i < 2 * num_leds ; i++) {
 			kfree(data->iref_pwm_attrs[i].attr.name);
 		}
 		kfree(data->iref_pwm_attrs);
 	}
 	kfree(data->all_attrs);
 	return;
 }

 static void construct_iref_pwm_device_attributes(struct lp5018_led *data,
                                                  int num_leds,
                                                  struct kobject *kobj) {
 	int i, error;
 	// need to NULL terminate the list of attributes -> add 1
 	data->all_attrs = kzalloc(sizeof(struct attribute *) * (num_leds * 2 + 1),
 			GFP_KERNEL);
 	if (data->all_attrs == NULL)
 		return;
 	data->iref_pwm_attrs =
 		kzalloc(sizeof(struct device_attribute) * num_leds * 2,
 			GFP_KERNEL);
 	if (data->iref_pwm_attrs == NULL)
 		goto fail;
 	for (i = 0; i < 2 * num_leds; ++i) {
 		char buf[8];
 		char* name;
 		if (i < num_leds)
 			snprintf(buf, sizeof(buf), "iref%u", i);
 		else
 			snprintf(buf, sizeof(buf), "pwm%u", i - num_leds);
 		name = kzalloc(strlen(buf) + 1, GFP_KERNEL);
 		if (name == NULL)
 			goto fail;
 		strncpy(name, buf, strlen(buf) + 1);

 		data->iref_pwm_attrs[i].attr.name = name;
 		data->iref_pwm_attrs[i].attr.mode = S_IWUSR | S_IWGRP | S_IRUGO;
 		if (i < num_leds) {
 			data->iref_pwm_attrs[i].show = lp5018_led_iref_show;
 			data->iref_pwm_attrs[i].store = lp5018_led_iref_store;
 		} else {
 			data->iref_pwm_attrs[i].show = lp5018_led_pwm_show;
 			data->iref_pwm_attrs[i].store = lp5018_led_pwm_store;
 		}
 		data->all_attrs[i] = &data->iref_pwm_attrs[i].attr;
 	}
 	data->iref_pwm_attr_group.attrs = data->all_attrs;
 	error = sysfs_create_group(kobj, &data->iref_pwm_attr_group);
 	if (error)
 		printk("%s: failed to create sysfs, err:%d\n", __func__, error);
 	return;

 fail:
 	delete_iref_pwm_attr_array(data, num_leds);
 }

 static int lp5018_led_probe(struct i2c_client *client,
 		const struct i2c_device_id *id)
 {
 	struct lp5018_led *data;
 	struct device *dev = &client->dev;
 	struct lp50xx_platform_data *pdata = dev_get_platdata(dev);
 	int error = 0;

 	if (!pdata) {
 		pdata = lp5018_led_parse_devtree(client);
 		if (IS_ERR(pdata)) {
 			dev_err(dev,
 			"%s: failed to get device data from device tree.\n",
 			__func__);
 			error = -EINVAL;
 			goto err_get_pdata;
 		}
 	}
 	dev_info(dev, "%s: %s number of leds supported: %d\n", __func__,
 		client->name, pdata->num_leds);

 	data = kzalloc(sizeof(struct lp5018_led), GFP_KERNEL);
 	if (!data) {
 		dev_err(dev, "%s: failed to allocate memory.\n",
 			__func__);
 		error = -ENOMEM;
 		goto err_free_mem;
 	}

 	data->client = client;
 	data->pdata = pdata;

 	i2c_set_clientdata(client, data);

 	error = lp5018_led_init(data);
 	if (error) {
 		dev_err(&client->dev, "%s: failed to initialize leds, err:%d\n",
 			__func__, error);
 		goto err_free_mem;
 	}

 	construct_iref_pwm_device_attributes(data, pdata->num_leds,
 			&client->dev.kobj);
 	error = sysfs_create_group(&client->dev.kobj,
 			&lp5018_led_other_attr_group);
 	if (error) {
 		dev_err(&client->dev, "%s: failed to create sysfs, err:%d\n",
 			__func__, error);
 		goto err_free_sysfs;
 	}

 	dev_info(dev, "%s: %s probe successfully!\n", __func__, client->name);
 	return 0;

 err_free_sysfs:
 	delete_iref_pwm_attr_array(data, pdata->num_leds);
 err_free_mem:
 	kfree(data);
 err_get_pdata:
 	return error;
 }

 static int lp5018_led_remove(struct i2c_client *client)
 {
 	/* There is no power-off for the product so probably i2c driver/device
 	 * unbinding is not called. Leave this function here for driver
 	 * integrity but return 0 directly.
 	 * */
 	return 0;
 }

 static void lp5018_led_shutdown(struct i2c_client *client)
 {
 	struct lp5018_led *data = i2c_get_clientdata(client);
 	int num_leds = data->pdata->num_leds;
 	int ret;

 	dev_info(&client->dev, "%s: prepare to shutdown device.\n", __func__);
 	ret = lp5018_led_reset(data);
 	if (ret)
 		dev_err(&client->dev, "%s: failed to reset LED.\n", __func__);

 	sysfs_remove_group(&client->dev.kobj, &data->iref_pwm_attr_group);
 	sysfs_remove_group(&client->dev.kobj, &lp5018_led_other_attr_group);
 	delete_iref_pwm_attr_array(data, num_leds);
 	kfree(data);
 }

 static const struct i2c_device_id lp5018_led_id[] = {
 	{ "led-lp5108", 0 },
 	{ }
 };
 MODULE_DEVICE_TABLE(i2c, lp5018_led_id);

 #ifdef CONFIG_OF
 static const struct of_device_id lp5018_led_of_match[] = {
 	{ .compatible = "ti,led-lp5018" },
 	{ }
 };
 #endif

 static struct i2c_driver lp5018_led_driver = {
 	.driver = {
 		.name    = "lp5018-leds",
 		.owner   = THIS_MODULE,
 		.pm      = NULL,
 		.of_match_table = of_match_ptr(lp5018_led_of_match),
 	},
 	.probe           = lp5018_led_probe,
 	.remove          = lp5018_led_remove,
 	.shutdown        = lp5018_led_shutdown,
 	.id_table        = lp5018_led_id,
 };

 module_i2c_driver(lp5018_led_driver);

 MODULE_AUTHOR("Blake Jacquot <blakejacquot@google.com>");
 MODULE_DESCRIPTION("TI LP5018 LED driver");
 MODULE_LICENSE("GPL");
	/*
	* LP5018 LED chip driver.
	*
	* Copyright (C) 2019 Google, Inc.
	*
	* This software is licensed under the terms of the GNU General Public
	* License version 2, as published by the Free Software Foundation, and
	* may be copied, distributed, and modified under those terms.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	*/

	#include <linux/delay.h>
	#include <linux/device.h>
	#include <linux/err.h>
	#include <linux/i2c.h>
	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/of_gpio.h>
	#include <linux/slab.h>
	#include <linux/platform_data/leds-lp50xx.h>

	/* Register Table */
	/* LED mode registers (read/write) */
	#define LP5018_DEVICE_CONFIG0 0x00
	#define LP5018_DEVICE_CONFIG1 0x01
	#define LP5018_GLOBAL_DIMMING 0x03
	#define LP5018_BRIGHTNESS_BASE 0x07
	#define LP5018_COLOR_BASE 0x0F
	#define LP5018_MAX_LED_CHANNELS 24

	#define NUM_OF_RETRIES 5

	struct lp5018_led {
	struct i2c_client *client;
	const struct lp50xx_platform_data *pdata;
	struct attribute **all_attrs;
	struct device_attribute *iref_pwm_attrs;
	struct attribute_group iref_pwm_attr_group;
	const struct lp5018_registers *reg;
	};

	enum chip_model_t {
	LP5018,
	};

	static const struct lp5018_registers {
	const char* model;
	const u8 reg_global_dimming;
	const u8 reg_pwm_base;
	const u8 reg_iref_base;
	const int led_channels;
	} kModelRegisterMap[] = {
	{ "lp5018",
	LP5018_GLOBAL_DIMMING,
	LP5018_COLOR_BASE,
	LP5018_BRIGHTNESS_BASE,
	LP5018_MAX_LED_CHANNELS},
	};

	static const struct lp5018_registers* lp5018_dev_to_register (struct device *dev) {
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	return data->reg;
	}

	static int lp5018_led_read_byte(struct i2c_client client, u8 reg, u8 buf)
	{
	s32 ret = i2c_smbus_read_byte_data(client, reg);
	if (ret < 0)
	return ret;

	*buf = ret;
	return 0;
	}

	static int lp5018_led_write_byte(struct i2c_client *client, u8 reg, u8 val)
	{
	int ret = i2c_smbus_write_byte_data(client, reg, val);
	if (ret < 0) {
	dev_err(&client->dev, "%s: failed to write byte data, ret=%d\n",
	__func__, ret);
	}
	return ret;
	}

	static int lp5018_led_read_block_data(struct i2c_client *client, u8 reg,
	u8 len, void *val)
	{
	int ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);

	if (ret == len)
	return 0;

	dev_err(&client->dev, "%s: failed on block read.\n", __func__);
	return -EIO;
	}

	static int lp5018_led_write_block_data(struct i2c_client *client, u8 reg,
	u8 len, const void *val)
	{
	int ret;
	int retry = 0;

	// TODO: We should make sure Auto_Incr_EN is enabled
	do {
	ret = i2c_smbus_write_i2c_block_data(client,
	reg, len, val);

	if (ret < 0) {
	dev_err(&client->dev, "%s: failed on block write. "
	"ret=%d, retry=%d\n",
	__func__, ret, retry);
	}
	++retry;

	} while (ret == -ERESTARTSYS && retry < NUM_OF_RETRIES);

	return ret;
	}

	static int lp5018_led_reset(struct lp5018_led *data)
	{
	struct i2c_client *client = data->client;
	int reset = data->pdata->reset_gpio;
	int ret = gpio_request(reset, "LedRST");
	if (ret) {
	dev_err(&client->dev, "%s: failed to request GPIO%d.\n",
	__func__, reset);
	return ret;
	}
	ret = gpio_direction_output(reset, 1);
	if (ret) {
	dev_err(&client->dev,
	"%s: failed to set gpio to 1.\n", __func__);
	gpio_free(reset);
	return ret;
	}
	gpio_set_value(reset, 0);
	msleep(1);
	gpio_set_value(reset, 1);

	gpio_free(reset);
	return ret;
	}

	static int lp5018_led_init(struct lp5018_led *data)
	{
	struct i2c_client *client = data->client;

	int ret, i;

	printk("lp5018_led_init\n");

	// Toggle enable pin
	ret = lp5018_led_reset(data);
	if (ret)
	dev_err(&client->dev, "%s: failed to reset LED.\n", __func__);
	msleep(1);

	// Enable driver
	// Set Chip_EN
	ret = lp5018_led_write_byte(client, LP5018_DEVICE_CONFIG0, 0x40);
	// Set Log_Scale_EN, Power_save_EN, Auto_incr_EN and PWm_Dithering_EN
	ret = lp5018_led_write_byte(client, LP5018_DEVICE_CONFIG1, 0x3C);

	data->reg = &kModelRegisterMap[LP5018];

	// Set brightness to 0x80 for all LEDs (default is 0xFF)
	for (i = 0; i < 8; ++i) {
	ret = lp5018_led_write_byte(client,
	data->reg->reg_iref_base + i,
	0x80);
	if (ret < 0) {
	dev_err(&client->dev, "%s: failed to set brightness"
	"for led %d to 0x80. ret=%d.\n",
	__func__, i, ret);
	return ret;
	}
	}

	return 0;
	}

	/* Helper function to show pwm control values. */
	static ssize_t lp5018_led_pwm_show_helper(struct device *dev,
	unsigned int led_index, char *buf,
	u8 addr)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	int ret;
	u8 rgb[3];

	if (led_index >= data->pdata->num_leds) {
	dev_err(dev, "%s: invalid led number: %d\n", __func__,
	led_index);
	return -EINVAL;
	}

	addr += data->pdata->start_num[led_index];
	ret = lp5018_led_read_block_data(client, addr, sizeof(rgb), rgb);
	if (ret) {
	dev_err(dev, "%s: failed to read RGB values.\n", __func__);
	return -EIO;
	}

	return scnprintf(buf, PAGE_SIZE, "%hhu %hhu %hhu\n",
	rgb[0], rgb[1], rgb[2]);
	}

	/* Helper function to show iref control values. */
	static ssize_t lp5018_led_iref_show_helper(struct device *dev,
	unsigned int led_index, char *buf,
	u8 addr)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	int ret;
	u8 brightness;

	if (led_index >= data->pdata->num_leds) {
	dev_err(dev, "%s: invalid led number: %d\n", __func__,
	led_index);
	return -EINVAL;
	}

	addr += led_index;

	ret = lp5018_led_read_byte(client, addr, &brightness);

	if (ret) {
	dev_err(dev, "%s: failed to read brightness.\n", __func__);
	return -EIO;
	}

	return scnprintf(buf, PAGE_SIZE, "%hhu\n", brightness);
	}

	/* Helper function to store pwm control value to certain LED.
	* Input is a char array.
	* Format: "255 255 255"
	* The input represent R, G, B values from left to right, respectively.
	*/
	static ssize_t lp5018_led_pwm_store_helper(struct device *dev,
	unsigned int led_index,
	const char *buf, size_t count, u8 addr)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	int ret;
	u8 rgb[3];

	if (led_index >= data->pdata->num_leds) {
	dev_err(dev, "%s: invalid led number: %d\n", __func__,
	led_index);
	return -EINVAL;
	}

	ret = sscanf(buf, "%hhu %hhu %hhu", &rgb[0], &rgb[1], &rgb[2]);
	if (ret != 3) {
	dev_err(dev, "%s: failed to parse rgb values, ret=%d.\n",
	__func__, ret);
	return -EINVAL;
	}

	addr += data->pdata->start_num[led_index];
	ret = lp5018_led_write_block_data(client, addr, sizeof(rgb), rgb);
	if (ret < 0) {
	dev_err(dev, "%s: failed to write rgb values to led%d.\n",
	__func__, led_index);
	return ret;
	}
	dev_dbg(dev, "%s %s: set led%u(0x%02x): R=%hhu, G=%hhu, B=%hhu\n",
	__func__, client->name, led_index, addr,
	rgb[0], rgb[1], rgb[2]);
	return count;
	}

	static ssize_t lp5018_led_iref_store_helper(struct device *dev,
	unsigned int led_index,
	const char *buf, size_t count, u8 addr)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	int ret;
	u8 brightness;

	if (led_index >= data->pdata->num_leds) {
	dev_err(dev, "%s: invalid led number: %d\n", __func__,
	led_index);
	return -EINVAL;
	}

	ret = sscanf(buf, "%hhu", &brightness);
	if (ret != 1) {
	dev_err(dev, "%s: failed to parse brightness, ret=%d.\n",
	__func__, ret);
	return -EINVAL;
	}

	addr += led_index;

	ret = lp5018_led_write_byte(client, addr, brightness);
	if (ret < 0) {
	dev_err(dev, "%s: failed to write brightness to led%d.\n",
	__func__, led_index);
	return ret;
	}
	dev_dbg(dev, "%s %s: set led%u(0x%02x): Val=%hhu\n",
	__func__, client->name, led_index, addr,
	brightness);
	return count;
	}

	static ssize_t lp5018_led_pwm_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	unsigned int led_index;
	int ret = sscanf(attr->attr.name, "pwm%u", &led_index);

	if (ret != 1) {
	dev_err(dev, "%s: failed to get led index.\n", __func__);
	return -EINVAL;
	}

	return lp5018_led_pwm_show_helper(dev, led_index, buf,
	lp5018_dev_to_register(dev)->reg_pwm_base);
	}

	static ssize_t lp5018_led_pwm_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	unsigned int led_index;
	int ret = sscanf(attr->attr.name, "pwm%u", &led_index);

	if (ret != 1) {
	dev_err(dev, "%s: failed to get led index.\n", __func__);
	return -EINVAL;
	}

	return lp5018_led_pwm_store_helper(dev, led_index, buf, count,
	lp5018_dev_to_register(dev)->reg_pwm_base);
	}



	/* Function to store pwm control values to specified LEDs.
	* Input Format" "LED_Index R G B LED_Index R G B ..."
	* Note: All LED indices not specified will have their
	* (R,G,B) set to (0, 0 ,0)
	* LED indices can be specified in any order
	* For example: "0 255 255 255 1 100 150 200" is equivalent
	* to "1 100 150 200 0 255 255 255"
	*/
	static ssize_t lp5018_led_pwm_all_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf,
	size_t count)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	int num_leds = 0;
	int chars_read = 0;
	int led_idx;
	int ret;
	int rgb_start_idx;
	u8 rgb[lp5018_dev_to_register(dev)->led_channels];
	memset(rgb, 0, sizeof(rgb));

	while (sscanf(buf, "%d%n", &led_idx, &chars_read) == 1) {
	if (led_idx > data->pdata->num_leds - 1 \|\| led_idx < 0) {
	dev_err(dev, "%s: incorrect led index %d supplied\n", __func__, led_idx);
	return -EINVAL;
	}

	++num_leds;
	if (num_leds > data->pdata->num_leds) {
	dev_err(dev, "%s: incorrect number of leds supplied\n", __func__);
	return -EINVAL;
	}

	buf += chars_read;
	rgb_start_idx = data->pdata->start_num[led_idx];
	if (sscanf(buf, "%hhu %hhu %hhu%n", &rgb[rgb_start_idx],
	&rgb[rgb_start_idx + 1],
	&rgb[rgb_start_idx + 2],
	&chars_read) != 3) {
	dev_err(dev, "%s: unable to parse led values to write\n", __func__);
	return -EINVAL;
	}
	buf += chars_read;
	}

	ret = lp5018_led_write_block_data(client,
	lp5018_dev_to_register(dev)->reg_pwm_base,
	sizeof(rgb), rgb);
	if (ret < 0) {
	dev_err(dev, "%s: failed to write rgb values to all leds, err: %d\n",
	__func__, ret);
	return ret;
	}

	return count;
	}

	static ssize_t lp5018_led_iref_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	unsigned int led_index;
	int ret = sscanf(attr->attr.name, "iref%u", &led_index);

	if (ret != 1) {
	dev_err(dev, "%s: failed to get led index.\n", __func__);
	return -EINVAL;
	}

	return lp5018_led_iref_show_helper(dev, led_index, buf,
	lp5018_dev_to_register(dev)->reg_iref_base);
	}

	static ssize_t lp5018_led_iref_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	unsigned int led_index;
	int ret = sscanf(attr->attr.name, "iref%u", &led_index);
	if (ret != 1) {
	dev_err(dev, "%s: failed to get led index.\n", __func__);
	return -EINVAL;
	}

	return lp5018_led_iref_store_helper(dev, led_index, buf, count,
	lp5018_dev_to_register(dev)->reg_iref_base);
	}


	static ssize_t lp5018_led_show_byte_helper(struct device *dev,
	char *buf, u8 addr)
	{
	struct i2c_client *client = to_i2c_client(dev);
	u8 read_buf;
	int ret = lp5018_led_read_byte(client, addr, &read_buf);

	if (ret < 0)
	return ret;

	return scnprintf(buf, PAGE_SIZE, "%u\n", read_buf);
	}

	static ssize_t lp5018_led_global_dimming_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	return lp5018_led_show_byte_helper(dev, buf,
	lp5018_dev_to_register(dev)->reg_global_dimming);
	}

	static ssize_t lp5018_led_global_dimming_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct i2c_client *client = to_i2c_client(dev);
	int global_dimming;
	int ret;

	if (kstrtouint(buf, 10, &global_dimming))
	return -EINVAL;

	/* Do the mask to handle minor input errors without reporting error. */
	global_dimming = global_dimming & 0xFF;
	ret = lp5018_led_write_byte(client,
	lp5018_dev_to_register(dev)->reg_global_dimming,
	global_dimming);
	if (ret < 0) {
	dev_err(dev, "%s: failed to write global_dimming.\n", __func__);
	return ret;
	}

	return count;
	}

	static ssize_t lp5018_led_init_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5018_led *data = i2c_get_clientdata(client);
	int ret;

	dev_info(dev, "%s: initializing LED...\n", __func__);
	ret = lp5018_led_init(data);
	if (ret) {
	dev_err(dev, "%s: failed to initialize LED. ret=%d\n",
	__func__, ret);
	return ret;
	}

	return count;
	}

	static DEVICE_ATTR(global_dimming, S_IWUSR \| S_IWGRP \| S_IRUGO,
	lp5018_led_global_dimming_show,
	lp5018_led_global_dimming_store);
	static DEVICE_ATTR(init_led, S_IWUSR \| S_IWGRP, NULL, lp5018_led_init_store);
	static DEVICE_ATTR(pwm_all, S_IWUSR \| S_IWGRP \| S_IRUGO,
	NULL, lp5018_led_pwm_all_store);

	static struct attribute *other_led_attrs[] = {
	&dev_attr_global_dimming.attr,
	&dev_attr_init_led.attr,
	&dev_attr_pwm_all.attr,
	NULL
	};


	static const struct attribute_group lp5018_led_other_attr_group = {
	.attrs = other_led_attrs,
	};

	#ifdef CONFIG_OF
	static struct lp50xx_platform_data *lp5018_led_parse_devtree(
	struct i2c_client *client)
	{
	struct device *dev = &client->dev;
	struct device_node *node;
	struct lp50xx_platform_data *pdata;
	int reset_gpio = -1;

	node = dev->of_node;
	if (!node) {
	dev_err(dev, "%s: of_node is NULL.\n", __func__);
	return ERR_PTR(-ENODEV);
	}

	pdata = devm_kzalloc(dev, sizeof(struct device_node), GFP_KERNEL);
	if (!pdata) {
	dev_err(dev, "%s: not enough memory left.\n", __func__);
	return ERR_PTR(-ENOMEM);
	}

	if (of_property_read_u32(node, "num_leds", &pdata->num_leds)) {
	dev_err(dev, "%s: failed to get number of leds.\n", __func__);
	devm_kfree(dev, pdata);
	return ERR_PTR(-EINVAL);
	}
	printk("lp5018 num_leds=%d\n", pdata->num_leds);

	if (of_property_read_u32_array(node, "start_num", (u32 *)&pdata->start_num,
	pdata->num_leds)) {
	dev_err(dev, "%s: failed to get pwm register addresses.\n",
	__func__);
	devm_kfree(dev, pdata);
	return ERR_PTR(-EINVAL);
	}

	reset_gpio = of_get_named_gpio(node, "reset_gpio", 0);
	if (!gpio_is_valid(reset_gpio)) {
	dev_err(dev, "%s: failed to get reset_gpio.\n", __func__);
	return ERR_PTR(-ENODEV);
	}
	pdata->reset_gpio = reset_gpio;

	return pdata;
	}
	#endif

	static void delete_iref_pwm_attr_array(struct lp5018_led *data, int num_leds)
	{
	if (data->iref_pwm_attrs) {
	int i;
	for (i = 0; i < 2 * num_leds ; i++) {
	kfree(data->iref_pwm_attrs[i].attr.name);
	}
	kfree(data->iref_pwm_attrs);
	}
	kfree(data->all_attrs);
	return;
	}

	static void construct_iref_pwm_device_attributes(struct lp5018_led *data,
	int num_leds,
	struct kobject *kobj) {
	int i, error;
	// need to NULL terminate the list of attributes -> add 1
	data->all_attrs = kzalloc(sizeof(struct attribute ) (num_leds * 2 + 1),
	GFP_KERNEL);
	if (data->all_attrs == NULL)
	return;
	data->iref_pwm_attrs =
	kzalloc(sizeof(struct device_attribute) * num_leds * 2,
	GFP_KERNEL);
	if (data->iref_pwm_attrs == NULL)
	goto fail;
	for (i = 0; i < 2 * num_leds; ++i) {
	char buf[8];
	char* name;
	if (i < num_leds)
	snprintf(buf, sizeof(buf), "iref%u", i);
	else
	snprintf(buf, sizeof(buf), "pwm%u", i - num_leds);
	name = kzalloc(strlen(buf) + 1, GFP_KERNEL);
	if (name == NULL)
	goto fail;
	strncpy(name, buf, strlen(buf) + 1);

	data->iref_pwm_attrs[i].attr.name = name;
	data->iref_pwm_attrs[i].attr.mode = S_IWUSR \| S_IWGRP \| S_IRUGO;
	if (i < num_leds) {
	data->iref_pwm_attrs[i].show = lp5018_led_iref_show;
	data->iref_pwm_attrs[i].store = lp5018_led_iref_store;
	} else {
	data->iref_pwm_attrs[i].show = lp5018_led_pwm_show;
	data->iref_pwm_attrs[i].store = lp5018_led_pwm_store;
	}
	data->all_attrs[i] = &data->iref_pwm_attrs[i].attr;
	}
	data->iref_pwm_attr_group.attrs = data->all_attrs;
	error = sysfs_create_group(kobj, &data->iref_pwm_attr_group);
	if (error)
	printk("%s: failed to create sysfs, err:%d\n", __func__, error);
	return;

	fail:
	delete_iref_pwm_attr_array(data, num_leds);
	}

	static int lp5018_led_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	struct lp5018_led *data;
	struct device *dev = &client->dev;
	struct lp50xx_platform_data *pdata = dev_get_platdata(dev);
	int error = 0;

	if (!pdata) {
	pdata = lp5018_led_parse_devtree(client);
	if (IS_ERR(pdata)) {
	dev_err(dev,
	"%s: failed to get device data from device tree.\n",
	__func__);
	error = -EINVAL;
	goto err_get_pdata;
	}
	}
	dev_info(dev, "%s: %s number of leds supported: %d\n", __func__,
	client->name, pdata->num_leds);

	data = kzalloc(sizeof(struct lp5018_led), GFP_KERNEL);
	if (!data) {
	dev_err(dev, "%s: failed to allocate memory.\n",
	__func__);
	error = -ENOMEM;
	goto err_free_mem;
	}

	data->client = client;
	data->pdata = pdata;

	i2c_set_clientdata(client, data);

	error = lp5018_led_init(data);
	if (error) {
	dev_err(&client->dev, "%s: failed to initialize leds, err:%d\n",
	__func__, error);
	goto err_free_mem;
	}

	construct_iref_pwm_device_attributes(data, pdata->num_leds,
	&client->dev.kobj);
	error = sysfs_create_group(&client->dev.kobj,
	&lp5018_led_other_attr_group);
	if (error) {
	dev_err(&client->dev, "%s: failed to create sysfs, err:%d\n",
	__func__, error);
	goto err_free_sysfs;
	}

	dev_info(dev, "%s: %s probe successfully!\n", __func__, client->name);
	return 0;

	err_free_sysfs:
	delete_iref_pwm_attr_array(data, pdata->num_leds);
	err_free_mem:
	kfree(data);
	err_get_pdata:
	return error;
	}

	static int lp5018_led_remove(struct i2c_client *client)
	{
	/* There is no power-off for the product so probably i2c driver/device
	* unbinding is not called. Leave this function here for driver
	* integrity but return 0 directly.
	* */
	return 0;
	}

	static void lp5018_led_shutdown(struct i2c_client *client)
	{
	struct lp5018_led *data = i2c_get_clientdata(client);
	int num_leds = data->pdata->num_leds;
	int ret;

	dev_info(&client->dev, "%s: prepare to shutdown device.\n", __func__);
	ret = lp5018_led_reset(data);
	if (ret)
	dev_err(&client->dev, "%s: failed to reset LED.\n", __func__);

	sysfs_remove_group(&client->dev.kobj, &data->iref_pwm_attr_group);
	sysfs_remove_group(&client->dev.kobj, &lp5018_led_other_attr_group);
	delete_iref_pwm_attr_array(data, num_leds);
	kfree(data);
	}

	static const struct i2c_device_id lp5018_led_id[] = {
	{ "led-lp5108", 0 },
	{ }
	};
	MODULE_DEVICE_TABLE(i2c, lp5018_led_id);

	#ifdef CONFIG_OF
	static const struct of_device_id lp5018_led_of_match[] = {
	{ .compatible = "ti,led-lp5018" },
	{ }
	};
	#endif

	static struct i2c_driver lp5018_led_driver = {
	.driver = {
	.name = "lp5018-leds",
	.owner = THIS_MODULE,
	.pm = NULL,
	.of_match_table = of_match_ptr(lp5018_led_of_match),
	},
	.probe = lp5018_led_probe,
	.remove = lp5018_led_remove,
	.shutdown = lp5018_led_shutdown,
	.id_table = lp5018_led_id,
	};

	module_i2c_driver(lp5018_led_driver);

	MODULE_AUTHOR("Blake Jacquot <blakejacquot@google.com>");
	MODULE_DESCRIPTION("TI LP5018 LED driver");
	MODULE_LICENSE("GPL");