drivers/leds/leds-lp5009.c

/*
 * LP5009 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 LP5009_DEVICE_CONFIG0		0x00
#define LP5009_DEVICE_CONFIG1		0x01
#define LP5009_GLOBAL_DIMMING		0x03
#define LP5009_BRIGHTNESS_BASE		0x07
#define LP5009_COLOR_BASE		0x0B
#define LP5009_MAX_LED_CHANNELS		12
#define LP5009_MAX_LED_NUM		4

#define NUM_OF_RETRIES			5

struct lp5009_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 lp5009_registers *reg;
	int sw_control_enable_pin;
};

enum chip_model_t {
	LP5009,
};

static const struct lp5009_registers {
	const char* model;
	const u8 reg_global_dimming;
	const u8 reg_pwm_base;
	const u8 reg_iref_base;
	const int led_channels;
} kModelRegisterMap[] = {
	{ "lp5009",
	LP5009_GLOBAL_DIMMING,
	LP5009_COLOR_BASE,
	LP5009_BRIGHTNESS_BASE,
	LP5009_MAX_LED_CHANNELS},
};

static const struct lp5009_registers* lp5009_dev_to_register (struct device *dev) {
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5009_led *data = i2c_get_clientdata(client);
	return data->reg;
}

static int lp5009_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 lp5009_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 lp5009_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 lp5009_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 lp5009_led_reset(struct lp5009_led *data)
{
	struct i2c_client *client = data->client;
	if (data->sw_control_enable_pin == 0) {
		dev_info(&client->dev,
			 "%s: skipping reset because enable pin is controlled"
			 "by HW\n",
			 __func__);
		return 0;
	}
	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 lp5009_enable(struct lp5009_led *data, u8 enable)
{
	struct i2c_client *client = data->client;
	if (data->sw_control_enable_pin == 0) {
		dev_info(&client->dev,
			 "%s: skipping enable because enable pin is controlled"
			 "by HW\n",
			 __func__);
		return 0;
	}
	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, enable);
	if (ret) {
		dev_err(&client->dev, "%s: failed to set gpio to 1.\n",
			__func__);
	}
	gpio_free(reset);
	return ret;
}

static int lp5009_led_init(struct lp5009_led *data)
{
	struct i2c_client *client = data->client;

	int ret;

	printk("lp5009_led_init\n");

	if (data->sw_control_enable_pin == 1) {
		if (data->pdata->soft_init) {
			// Set enable pin
			ret = lp5009_enable(data, 1);
			msleep(1);
		} else {
			// Toggle enable pin
			ret = lp5009_led_reset(data);
			msleep(1);
		}
		if (ret) {
			dev_err(&client->dev,
				"%s: failed to set or reset LED.\n",
				__func__);
			return ret;
		}
	}

	// Enable driver
	// Set Chip_EN
	ret = lp5009_led_write_byte(client, LP5009_DEVICE_CONFIG0, 0x40);
	if (ret) {
		dev_err(&client->dev, "%s: failed to set CONFIG0, ret: %d\n", __func__, ret);
		return ret;
	}

	// Log_Scale_EN=0, Power_save_EN=1, Auto_incr_EN=1, PWM_Dithering_EN=1
	ret = lp5009_led_write_byte(client, LP5009_DEVICE_CONFIG1, 0x1C);
	if (ret) {
		dev_err(&client->dev, "%s: failed to set CONFIG1, ret: %d\n", __func__, ret);
		return ret;
	}

	data->reg = &kModelRegisterMap[LP5009];

	return 0;
}

/* Helper function to show pwm control values. */
static ssize_t lp5009_led_pwm_show_helper(struct device *dev,
		unsigned int led_index, char *buf,
		u8 addr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5009_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 = lp5009_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 lp5009_led_iref_show_helper(struct device *dev,
		unsigned int led_index, char *buf,
		u8 addr)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct lp5009_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 = lp5009_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 lp5009_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 lp5009_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 = lp5009_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 lp5009_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 lp5009_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 = lp5009_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 lp5009_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 lp5009_led_pwm_show_helper(dev, led_index, buf,
			lp5009_dev_to_register(dev)->reg_pwm_base);
}

static ssize_t lp5009_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 lp5009_led_pwm_store_helper(dev, led_index, buf, count,
			lp5009_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 lp5009_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 lp5009_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[lp5009_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 = lp5009_led_write_block_data(client,
			lp5009_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;
}

/* Function to store brightness and color control values of all LEDs.
 * Takes 1 to 12 values [0-255].
 * Writes all the received values in one block write.
 * Input Format:
 * "iref0 iref1 iref2 iref3 brt00 brt01 brt02 brt10 brt11 brt12 brt20 ..."
 */
static ssize_t lp5009_led_iref_pwm_all_store(struct device *dev,
					     struct device_attribute *attr,
					     const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	int chars_read = 0;
	int idx = 0;
	int ret;
	u8 value;
	u8 values[lp5009_dev_to_register(dev)->led_channels + 4];

	memset(values, 0, sizeof(values));

	while (sscanf(buf, "%hhu%n", &value, &chars_read) == 1) {
		if (idx == sizeof(values)) {
			dev_err(dev, "%s: too many values received\n",
				__func__);
			return -EINVAL;
		}
		values[idx] = value;
		idx++;
		buf += chars_read;
	}
	if (idx == 0) {
		dev_err(dev, "%s: no valid values received\n", __func__);
		return -EINVAL;
	}

	ret = lp5009_led_write_block_data(client,
			lp5009_dev_to_register(dev)->reg_iref_base, idx,
			values);
	if (ret < 0) {
		dev_err(dev,
			"%s: failed to write iref/pwm values to all leds, err: %d\n",
			__func__, ret);
		return ret;
	}

	return count;
}

static ssize_t lp5009_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 lp5009_led_iref_show_helper(dev, led_index, buf,
			lp5009_dev_to_register(dev)->reg_iref_base);
}

static ssize_t lp5009_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 lp5009_led_iref_store_helper(dev, led_index, buf, count,
			lp5009_dev_to_register(dev)->reg_iref_base);
}


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

	if (ret < 0)
		return ret;

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

static ssize_t lp5009_led_global_dimming_show(struct device *dev,
		struct device_attribute *attr,
		char *buf)
{
	return lp5009_led_show_byte_helper(dev, buf,
			lp5009_dev_to_register(dev)->reg_global_dimming);
}

static ssize_t lp5009_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 = lp5009_led_write_byte(client,
			lp5009_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 lp5009_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 lp5009_led *data = i2c_get_clientdata(client);
	int ret;

	dev_info(dev, "%s: initializing LED...\n", __func__);
	ret = lp5009_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,
		lp5009_led_global_dimming_show,
		lp5009_led_global_dimming_store);
static DEVICE_ATTR(init_led, S_IWUSR | S_IWGRP, NULL, lp5009_led_init_store);
static DEVICE_ATTR(pwm_all, S_IWUSR | S_IWGRP | S_IRUGO,
		NULL, lp5009_led_pwm_all_store);
static DEVICE_ATTR(iref_pwm_all, 0664, NULL, lp5009_led_iref_pwm_all_store);

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


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

#ifdef CONFIG_OF
static struct lp50xx_platform_data *lp5009_led_parse_devtree(
		struct i2c_client *client, struct lp5009_led *data)
{
	struct device *dev = &client->dev;
	struct device_node *node;
	struct lp50xx_platform_data *pdata;
	int reset_gpio = -1;
	int len = 0;

	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("lp5009 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);
	}

	if (of_find_property(node, "ignore_enable_pin", &len) == NULL) {
		data->sw_control_enable_pin = 1;
		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;

		pdata->soft_init = 0;
		of_property_read_u8(node, "soft-init", &pdata->soft_init);
	} else {
		data->sw_control_enable_pin = 0;
		dev_info(dev,
			 "%s: %s ignore enable pin setted. "
			 "Expecting enable pin pulled up by HW\n", __func__,
			 client->name);
	}

	return pdata;
}
#endif

static void delete_iref_pwm_attr_array(struct lp5009_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 lp5009_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 = lp5009_led_iref_show;
			data->iref_pwm_attrs[i].store = lp5009_led_iref_store;
		} else {
			data->iref_pwm_attrs[i].show = lp5009_led_pwm_show;
			data->iref_pwm_attrs[i].store = lp5009_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 lp5009_led_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	struct lp5009_led *data;
	struct device *dev = &client->dev;
	struct lp50xx_platform_data *pdata = dev_get_platdata(dev);
	int error = 0;

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

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


	data->pdata = pdata;

	error = lp5009_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,
			&lp5009_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:
	return error;
}

static int lp5009_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 lp5009_led_shutdown(struct i2c_client *client)
{
	struct lp5009_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 = lp5009_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, &lp5009_led_other_attr_group);
	delete_iref_pwm_attr_array(data, num_leds);
	kfree(data);
}

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

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

static struct i2c_driver lp5009_led_driver = {
	.driver = {
		.name    = "lp5009-leds",
		.owner   = THIS_MODULE,
		.pm      = NULL,
		.of_match_table = of_match_ptr(lp5009_led_of_match),
	},
	.probe           = lp5009_led_probe,
	.remove          = lp5009_led_remove,
	.shutdown        = lp5009_led_shutdown,
	.id_table        = lp5009_led_id,
};

module_i2c_driver(lp5009_led_driver);

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