[linux-block.git] / drivers / leds / leds-blinkm.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  leds-blinkm.c
 *  (c) Jan-Simon Möller (dl9pf@gmx.de)
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/printk.h>
#include <linux/pm_runtime.h>
#include <linux/leds.h>
#include <linux/delay.h>

/* Addresses to scan - BlinkM is on 0x09 by default*/
static const unsigned short normal_i2c[] = { 0x09, I2C_CLIENT_END };

static int blinkm_transfer_hw(struct i2c_client *client, int cmd);
static int blinkm_test_run(struct i2c_client *client);

struct blinkm_led {
	struct i2c_client *i2c_client;
	struct led_classdev led_cdev;
	int id;
};

#define cdev_to_blmled(c)          container_of(c, struct blinkm_led, led_cdev)

struct blinkm_data {
	struct i2c_client *i2c_client;
	struct mutex update_lock;
	/* used for led class interface */
	struct blinkm_led blinkm_leds[3];
	/* used for "blinkm" sysfs interface */
	u8 red;			/* color red */
	u8 green;		/* color green */
	u8 blue;		/* color blue */
	/* next values to use for transfer */
	u8 next_red;			/* color red */
	u8 next_green;		/* color green */
	u8 next_blue;		/* color blue */
	/* internal use */
	u8 args[7];		/* set of args for transmission */
	u8 i2c_addr;		/* i2c addr */
	u8 fw_ver;		/* firmware version */
	/* used, but not from userspace */
	u8 hue;			/* HSB  hue */
	u8 saturation;		/* HSB  saturation */
	u8 brightness;		/* HSB  brightness */
	u8 next_hue;			/* HSB  hue */
	u8 next_saturation;		/* HSB  saturation */
	u8 next_brightness;		/* HSB  brightness */
	/* currently unused / todo */
	u8 fade_speed;		/* fade speed     1 - 255 */
	s8 time_adjust;		/* time adjust -128 - 127 */
	u8 fade:1;		/* fade on = 1, off = 0 */
	u8 rand:1;		/* rand fade mode on = 1 */
	u8 script_id;		/* script ID */
	u8 script_repeats;	/* repeats of script */
	u8 script_startline;	/* line to start */
};

/* Colors */
#define RED   0
#define GREEN 1
#define BLUE  2

/* mapping command names to cmd chars - see datasheet */
#define BLM_GO_RGB            0
#define BLM_FADE_RGB          1
#define BLM_FADE_HSB          2
#define BLM_FADE_RAND_RGB     3
#define BLM_FADE_RAND_HSB     4
#define BLM_PLAY_SCRIPT       5
#define BLM_STOP_SCRIPT       6
#define BLM_SET_FADE_SPEED    7
#define BLM_SET_TIME_ADJ      8
#define BLM_GET_CUR_RGB       9
#define BLM_WRITE_SCRIPT_LINE 10
#define BLM_READ_SCRIPT_LINE  11
#define BLM_SET_SCRIPT_LR     12	/* Length & Repeats */
#define BLM_SET_ADDR          13
#define BLM_GET_ADDR          14
#define BLM_GET_FW_VER        15
#define BLM_SET_STARTUP_PARAM 16

/* BlinkM Commands
 *  as extracted out of the datasheet:
 *
 *  cmdchar = command (ascii)
 *  cmdbyte = command in hex
 *  nr_args = number of arguments (to send)
 *  nr_ret  = number of return values (to read)
 *  dir = direction (0 = read, 1 = write, 2 = both)
 *
 */
static const struct {
	char cmdchar;
	u8 cmdbyte;
	u8 nr_args;
	u8 nr_ret;
	u8 dir:2;
} blinkm_cmds[17] = {
  /* cmdchar, cmdbyte, nr_args, nr_ret,  dir */
	{ 'n', 0x6e, 3, 0, 1},
	{ 'c', 0x63, 3, 0, 1},
	{ 'h', 0x68, 3, 0, 1},
	{ 'C', 0x43, 3, 0, 1},
	{ 'H', 0x48, 3, 0, 1},
	{ 'p', 0x70, 3, 0, 1},
	{ 'o', 0x6f, 0, 0, 1},
	{ 'f', 0x66, 1, 0, 1},
	{ 't', 0x74, 1, 0, 1},
	{ 'g', 0x67, 0, 3, 0},
	{ 'W', 0x57, 7, 0, 1},
	{ 'R', 0x52, 2, 5, 2},
	{ 'L', 0x4c, 3, 0, 1},
	{ 'A', 0x41, 4, 0, 1},
	{ 'a', 0x61, 0, 1, 0},
	{ 'Z', 0x5a, 0, 1, 0},
	{ 'B', 0x42, 5, 0, 1},
};

static ssize_t show_color_common(struct device *dev, char *buf, int color)
{
	struct i2c_client *client;
	struct blinkm_data *data;
	int ret;

	client = to_i2c_client(dev);
	data = i2c_get_clientdata(client);

	ret = blinkm_transfer_hw(client, BLM_GET_CUR_RGB);
	if (ret < 0)
		return ret;
	switch (color) {
	case RED:
		return scnprintf(buf, PAGE_SIZE, "%02X\n", data->red);
	case GREEN:
		return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green);
	case BLUE:
		return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue);
	default:
		return -EINVAL;
	}
	return -EINVAL;
}

static int store_color_common(struct device *dev, const char *buf, int color)
{
	struct i2c_client *client;
	struct blinkm_data *data;
	int ret;
	u8 value;

	client = to_i2c_client(dev);
	data = i2c_get_clientdata(client);

	ret = kstrtou8(buf, 10, &value);
	if (ret < 0) {
		dev_err(dev, "BlinkM: value too large!\n");
		return ret;
	}

	switch (color) {
	case RED:
		data->next_red = value;
		break;
	case GREEN:
		data->next_green = value;
		break;
	case BLUE:
		data->next_blue = value;
		break;
	default:
		return -EINVAL;
	}

	dev_dbg(dev, "next_red = %d, next_green = %d, next_blue = %d\n",
			data->next_red, data->next_green, data->next_blue);

	/* if mode ... */
	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
	if (ret < 0) {
		dev_err(dev, "BlinkM: can't set RGB\n");
		return ret;
	}
	return 0;
}

static ssize_t red_show(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	return show_color_common(dev, buf, RED);
}

static ssize_t red_store(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	int ret;

	ret = store_color_common(dev, buf, RED);
	if (ret < 0)
		return ret;
	return count;
}

static DEVICE_ATTR_RW(red);

static ssize_t green_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	return show_color_common(dev, buf, GREEN);
}

static ssize_t green_store(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{

	int ret;

	ret = store_color_common(dev, buf, GREEN);
	if (ret < 0)
		return ret;
	return count;
}

static DEVICE_ATTR_RW(green);

static ssize_t blue_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	return show_color_common(dev, buf, BLUE);
}

static ssize_t blue_store(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	int ret;

	ret = store_color_common(dev, buf, BLUE);
	if (ret < 0)
		return ret;
	return count;
}

static DEVICE_ATTR_RW(blue);

static ssize_t test_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	return scnprintf(buf, PAGE_SIZE,
			 "#Write into test to start test sequence!#\n");
}

static ssize_t test_store(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{

	struct i2c_client *client;
	int ret;
	client = to_i2c_client(dev);

	/*test */
	ret = blinkm_test_run(client);
	if (ret < 0)
		return ret;

	return count;
}

static DEVICE_ATTR_RW(test);

/* TODO: HSB, fade, timeadj, script ... */

static struct attribute *blinkm_attrs[] = {
	&dev_attr_red.attr,
	&dev_attr_green.attr,
	&dev_attr_blue.attr,
	&dev_attr_test.attr,
	NULL,
};

static const struct attribute_group blinkm_group = {
	.name = "blinkm",
	.attrs = blinkm_attrs,
};

static int blinkm_write(struct i2c_client *client, int cmd, u8 *arg)
{
	int result;
	int i;
	int arglen = blinkm_cmds[cmd].nr_args;
	/* write out cmd to blinkm - always / default step */
	result = i2c_smbus_write_byte(client, blinkm_cmds[cmd].cmdbyte);
	if (result < 0)
		return result;
	/* no args to write out */
	if (arglen == 0)
		return 0;

	for (i = 0; i < arglen; i++) {
		/* repeat for arglen */
		result = i2c_smbus_write_byte(client, arg[i]);
		if (result < 0)
			return result;
	}
	return 0;
}

static int blinkm_read(struct i2c_client *client, int cmd, u8 *arg)
{
	int result;
	int i;
	int retlen = blinkm_cmds[cmd].nr_ret;
	for (i = 0; i < retlen; i++) {
		/* repeat for retlen */
		result = i2c_smbus_read_byte(client);
		if (result < 0)
			return result;
		arg[i] = result;
	}

	return 0;
}

static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
{
	/* the protocol is simple but non-standard:
	 * e.g.  cmd 'g' (= 0x67) for "get device address"
	 * - which defaults to 0x09 - would be the sequence:
	 *   a) write 0x67 to the device (byte write)
	 *   b) read the value (0x09) back right after (byte read)
	 *
	 * Watch out for "unfinished" sequences (i.e. not enough reads
	 * or writes after a command. It will make the blinkM misbehave.
	 * Sequence is key here.
	 */

	/* args / return are in private data struct */
	struct blinkm_data *data = i2c_get_clientdata(client);

	/* We start hardware transfers which are not to be
	 * mixed with other commands. Aquire a lock now. */
	if (mutex_lock_interruptible(&data->update_lock) < 0)
		return -EAGAIN;

	/* switch cmd - usually write before reads */
	switch (cmd) {
	case BLM_FADE_RAND_RGB:
	case BLM_GO_RGB:
	case BLM_FADE_RGB:
		data->args[0] = data->next_red;
		data->args[1] = data->next_green;
		data->args[2] = data->next_blue;
		blinkm_write(client, cmd, data->args);
		data->red = data->args[0];
		data->green = data->args[1];
		data->blue = data->args[2];
		break;
	case BLM_FADE_HSB:
	case BLM_FADE_RAND_HSB:
		data->args[0] = data->next_hue;
		data->args[1] = data->next_saturation;
		data->args[2] = data->next_brightness;
		blinkm_write(client, cmd, data->args);
		data->hue = data->next_hue;
		data->saturation = data->next_saturation;
		data->brightness = data->next_brightness;
		break;
	case BLM_PLAY_SCRIPT:
		data->args[0] = data->script_id;
		data->args[1] = data->script_repeats;
		data->args[2] = data->script_startline;
		blinkm_write(client, cmd, data->args);
		break;
	case BLM_STOP_SCRIPT:
		blinkm_write(client, cmd, NULL);
		break;
	case BLM_GET_CUR_RGB:
		data->args[0] = data->red;
		data->args[1] = data->green;
		data->args[2] = data->blue;
		blinkm_write(client, cmd, NULL);
		blinkm_read(client, cmd, data->args);
		data->red = data->args[0];
		data->green = data->args[1];
		data->blue = data->args[2];
		break;
	case BLM_GET_ADDR:
		data->args[0] = data->i2c_addr;
		blinkm_write(client, cmd, NULL);
		blinkm_read(client, cmd, data->args);
		data->i2c_addr = data->args[0];
		break;
	case BLM_SET_TIME_ADJ:
	case BLM_SET_FADE_SPEED:
	case BLM_READ_SCRIPT_LINE:
	case BLM_WRITE_SCRIPT_LINE:
	case BLM_SET_SCRIPT_LR:
	case BLM_SET_ADDR:
	case BLM_GET_FW_VER:
	case BLM_SET_STARTUP_PARAM:
		dev_err(&client->dev,
				"BlinkM: cmd %d not implemented yet.\n", cmd);
		break;
	default:
		dev_err(&client->dev, "BlinkM: unknown command %d\n", cmd);
		mutex_unlock(&data->update_lock);
		return -EINVAL;
	}			/* end switch(cmd) */

	/* transfers done, unlock */
	mutex_unlock(&data->update_lock);
	return 0;
}

static int blinkm_led_common_set(struct led_classdev *led_cdev,
				 enum led_brightness value, int color)
{
	/* led_brightness is 0, 127 or 255 - we just use it here as-is */
	struct blinkm_led *led = cdev_to_blmled(led_cdev);
	struct blinkm_data *data = i2c_get_clientdata(led->i2c_client);

	switch (color) {
	case RED:
		/* bail out if there's no change */
		if (data->next_red == (u8) value)
			return 0;
		data->next_red = (u8) value;
		break;
	case GREEN:
		/* bail out if there's no change */
		if (data->next_green == (u8) value)
			return 0;
		data->next_green = (u8) value;
		break;
	case BLUE:
		/* bail out if there's no change */
		if (data->next_blue == (u8) value)
			return 0;
		data->next_blue = (u8) value;
		break;

	default:
		dev_err(&led->i2c_client->dev, "BlinkM: unknown color.\n");
		return -EINVAL;
	}

	blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB);
	dev_dbg(&led->i2c_client->dev,
			"# DONE # next_red = %d, next_green = %d,"
			" next_blue = %d\n",
			data->next_red, data->next_green,
			data->next_blue);
	return 0;
}

static int blinkm_led_red_set(struct led_classdev *led_cdev,
			       enum led_brightness value)
{
	return blinkm_led_common_set(led_cdev, value, RED);
}

static int blinkm_led_green_set(struct led_classdev *led_cdev,
				 enum led_brightness value)
{
	return blinkm_led_common_set(led_cdev, value, GREEN);
}

static int blinkm_led_blue_set(struct led_classdev *led_cdev,
				enum led_brightness value)
{
	return blinkm_led_common_set(led_cdev, value, BLUE);
}

static void blinkm_init_hw(struct i2c_client *client)
{
	blinkm_transfer_hw(client, BLM_STOP_SCRIPT);
	blinkm_transfer_hw(client, BLM_GO_RGB);
}

static int blinkm_test_run(struct i2c_client *client)
{
	int ret;
	struct blinkm_data *data = i2c_get_clientdata(client);

	data->next_red = 0x01;
	data->next_green = 0x05;
	data->next_blue = 0x10;
	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
	if (ret < 0)
		return ret;
	msleep(2000);

	data->next_red = 0x25;
	data->next_green = 0x10;
	data->next_blue = 0x31;
	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
	if (ret < 0)
		return ret;
	msleep(2000);

	data->next_hue = 0x50;
	data->next_saturation = 0x10;
	data->next_brightness = 0x20;
	ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
	if (ret < 0)
		return ret;
	msleep(2000);

	return 0;
}

/* Return 0 if detection is successful, -ENODEV otherwise */
static int blinkm_detect(struct i2c_client *client, struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = client->adapter;
	int ret;
	int count = 99;
	u8 tmpargs[7];

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
				     | I2C_FUNC_SMBUS_WORD_DATA
				     | I2C_FUNC_SMBUS_WRITE_BYTE))
		return -ENODEV;

	/* Now, we do the remaining detection. Simple for now. */
	/* We might need more guards to protect other i2c slaves */

	/* make sure the blinkM is balanced (read/writes) */
	while (count > 0) {
		ret = blinkm_write(client, BLM_GET_ADDR, NULL);
		if (ret)
			return ret;
		usleep_range(5000, 10000);
		ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
		if (ret)
			return ret;
		usleep_range(5000, 10000);
		if (tmpargs[0] == 0x09)
			count = 0;
		count--;
	}

	/* Step 1: Read BlinkM address back  -  cmd_char 'a' */
	ret = blinkm_write(client, BLM_GET_ADDR, NULL);
	if (ret < 0)
		return ret;
	usleep_range(20000, 30000);	/* allow a small delay */
	ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
	if (ret < 0)
		return ret;

	if (tmpargs[0] != 0x09) {
		dev_err(&client->dev, "enodev DEV ADDR = 0x%02X\n", tmpargs[0]);
		return -ENODEV;
	}

	strlcpy(info->type, "blinkm", I2C_NAME_SIZE);
	return 0;
}

static int blinkm_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct blinkm_data *data;
	struct blinkm_led *led[3];
	int err, i;
	char blinkm_led_name[28];

	data = devm_kzalloc(&client->dev,
			sizeof(struct blinkm_data), GFP_KERNEL);
	if (!data) {
		err = -ENOMEM;
		goto exit;
	}

	data->i2c_addr = 0x08;
	/* i2c addr  - use fake addr of 0x08 initially (real is 0x09) */
	data->fw_ver = 0xfe;
	/* firmware version - use fake until we read real value
	 * (currently broken - BlinkM confused!) */
	data->script_id = 0x01;
	data->i2c_client = client;

	i2c_set_clientdata(client, data);
	mutex_init(&data->update_lock);

	/* Register sysfs hooks */
	err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
	if (err < 0) {
		dev_err(&client->dev, "couldn't register sysfs group\n");
		goto exit;
	}

	for (i = 0; i < 3; i++) {
		/* RED = 0, GREEN = 1, BLUE = 2 */
		led[i] = &data->blinkm_leds[i];
		led[i]->i2c_client = client;
		led[i]->id = i;
		led[i]->led_cdev.max_brightness = 255;
		led[i]->led_cdev.flags = LED_CORE_SUSPENDRESUME;
		switch (i) {
		case RED:
			snprintf(blinkm_led_name, sizeof(blinkm_led_name),
					 "blinkm-%d-%d-red",
					 client->adapter->nr,
					 client->addr);
			led[i]->led_cdev.name = blinkm_led_name;
			led[i]->led_cdev.brightness_set_blocking =
							blinkm_led_red_set;
			err = led_classdev_register(&client->dev,
						    &led[i]->led_cdev);
			if (err < 0) {
				dev_err(&client->dev,
					"couldn't register LED %s\n",
					led[i]->led_cdev.name);
				goto failred;
			}
			break;
		case GREEN:
			snprintf(blinkm_led_name, sizeof(blinkm_led_name),
					 "blinkm-%d-%d-green",
					 client->adapter->nr,
					 client->addr);
			led[i]->led_cdev.name = blinkm_led_name;
			led[i]->led_cdev.brightness_set_blocking =
							blinkm_led_green_set;
			err = led_classdev_register(&client->dev,
						    &led[i]->led_cdev);
			if (err < 0) {
				dev_err(&client->dev,
					"couldn't register LED %s\n",
					led[i]->led_cdev.name);
				goto failgreen;
			}
			break;
		case BLUE:
			snprintf(blinkm_led_name, sizeof(blinkm_led_name),
					 "blinkm-%d-%d-blue",
					 client->adapter->nr,
					 client->addr);
			led[i]->led_cdev.name = blinkm_led_name;
			led[i]->led_cdev.brightness_set_blocking =
							blinkm_led_blue_set;
			err = led_classdev_register(&client->dev,
						    &led[i]->led_cdev);
			if (err < 0) {
				dev_err(&client->dev,
					"couldn't register LED %s\n",
					led[i]->led_cdev.name);
				goto failblue;
			}
			break;
		}		/* end switch */
	}			/* end for */

	/* Initialize the blinkm */
	blinkm_init_hw(client);

	return 0;

failblue:
	led_classdev_unregister(&led[GREEN]->led_cdev);

failgreen:
	led_classdev_unregister(&led[RED]->led_cdev);

failred:
	sysfs_remove_group(&client->dev.kobj, &blinkm_group);
exit:
	return err;
}

static int blinkm_remove(struct i2c_client *client)
{
	struct blinkm_data *data = i2c_get_clientdata(client);
	int ret = 0;
	int i;

	/* make sure no workqueue entries are pending */
	for (i = 0; i < 3; i++)
		led_classdev_unregister(&data->blinkm_leds[i].led_cdev);

	/* reset rgb */
	data->next_red = 0x00;
	data->next_green = 0x00;
	data->next_blue = 0x00;
	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
	if (ret < 0)
		dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");

	/* reset hsb */
	data->next_hue = 0x00;
	data->next_saturation = 0x00;
	data->next_brightness = 0x00;
	ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
	if (ret < 0)
		dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");

	/* red fade to off */
	data->next_red = 0xff;
	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
	if (ret < 0)
		dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");

	/* off */
	data->next_red = 0x00;
	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
	if (ret < 0)
		dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");

	sysfs_remove_group(&client->dev.kobj, &blinkm_group);
	return 0;
}

static const struct i2c_device_id blinkm_id[] = {
	{"blinkm", 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, blinkm_id);

  /* This is the driver that will be inserted */
static struct i2c_driver blinkm_driver = {
	.class = I2C_CLASS_HWMON,
	.driver = {
		   .name = "blinkm",
		   },
	.probe = blinkm_probe,
	.remove = blinkm_remove,
	.id_table = blinkm_id,
	.detect = blinkm_detect,
	.address_list = normal_i2c,
};

module_i2c_driver(blinkm_driver);

MODULE_AUTHOR("Jan-Simon Moeller <dl9pf@gmx.de>");
MODULE_DESCRIPTION("BlinkM RGB LED driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
74ba9207	1	// SPDX-License-Identifier: GPL-2.0-or-later
b54cf35a JSM	2	/*
	3	* leds-blinkm.c
	4	* (c) Jan-Simon Möller (dl9pf@gmx.de)
b54cf35a JSM	5	*/
	6
	7	#include <linux/module.h>
b54cf35a JSM	8	#include <linux/slab.h>
	9	#include <linux/jiffies.h>
	10	#include <linux/i2c.h>
	11	#include <linux/err.h>
	12	#include <linux/mutex.h>
	13	#include <linux/sysfs.h>
	14	#include <linux/printk.h>
	15	#include <linux/pm_runtime.h>
	16	#include <linux/leds.h>
	17	#include <linux/delay.h>
	18
	19	/* Addresses to scan - BlinkM is on 0x09 by default*/
	20	static const unsigned short normal_i2c[] = { 0x09, I2C_CLIENT_END };
	21
	22	static int blinkm_transfer_hw(struct i2c_client *client, int cmd);
	23	static int blinkm_test_run(struct i2c_client *client);
	24
	25	struct blinkm_led {
	26	struct i2c_client *i2c_client;
	27	struct led_classdev led_cdev;
	28	int id;
b54cf35a JSM	29	};
	30
	31	#define cdev_to_blmled(c) container_of(c, struct blinkm_led, led_cdev)
b54cf35a JSM	32
	33	struct blinkm_data {
	34	struct i2c_client *i2c_client;
	35	struct mutex update_lock;
	36	/* used for led class interface */
	37	struct blinkm_led blinkm_leds[3];
	38	/* used for "blinkm" sysfs interface */
	39	u8 red; /* color red */
	40	u8 green; /* color green */
	41	u8 blue; /* color blue */
	42	/* next values to use for transfer */
	43	u8 next_red; /* color red */
	44	u8 next_green; /* color green */
	45	u8 next_blue; /* color blue */
	46	/* internal use */
	47	u8 args[7]; /* set of args for transmission */
	48	u8 i2c_addr; /* i2c addr */
	49	u8 fw_ver; /* firmware version */
	50	/* used, but not from userspace */
	51	u8 hue; /* HSB hue */
	52	u8 saturation; /* HSB saturation */
	53	u8 brightness; /* HSB brightness */
	54	u8 next_hue; /* HSB hue */
	55	u8 next_saturation; /* HSB saturation */
	56	u8 next_brightness; /* HSB brightness */
	57	/* currently unused / todo */
	58	u8 fade_speed; /* fade speed 1 - 255 */
	59	s8 time_adjust; /* time adjust -128 - 127 */
	60	u8 fade:1; /* fade on = 1, off = 0 */
	61	u8 rand:1; /* rand fade mode on = 1 */
	62	u8 script_id; /* script ID */
	63	u8 script_repeats; /* repeats of script */
	64	u8 script_startline; /* line to start */
	65	};
	66
	67	/* Colors */
	68	#define RED 0
	69	#define GREEN 1
	70	#define BLUE 2
	71
	72	/* mapping command names to cmd chars - see datasheet */
	73	#define BLM_GO_RGB 0
	74	#define BLM_FADE_RGB 1
	75	#define BLM_FADE_HSB 2
	76	#define BLM_FADE_RAND_RGB 3
	77	#define BLM_FADE_RAND_HSB 4
	78	#define BLM_PLAY_SCRIPT 5
	79	#define BLM_STOP_SCRIPT 6
	80	#define BLM_SET_FADE_SPEED 7
	81	#define BLM_SET_TIME_ADJ 8
	82	#define BLM_GET_CUR_RGB 9
	83	#define BLM_WRITE_SCRIPT_LINE 10
	84	#define BLM_READ_SCRIPT_LINE 11
	85	#define BLM_SET_SCRIPT_LR 12 /* Length & Repeats */
	86	#define BLM_SET_ADDR 13
	87	#define BLM_GET_ADDR 14
	88	#define BLM_GET_FW_VER 15
	89	#define BLM_SET_STARTUP_PARAM 16
	90
	91	/* BlinkM Commands
	92	* as extracted out of the datasheet:
	93	*
	94	* cmdchar = command (ascii)
	95	* cmdbyte = command in hex
96	* nr_args = number of arguments (to send)
97	* nr_ret = number of return values (to read)
98	* dir = direction (0 = read, 1 = write, 2 = both)
99	*
100	*/
101	static const struct {
102	char cmdchar;
103	u8 cmdbyte;
104	u8 nr_args;
105	u8 nr_ret;
106	u8 dir:2;
107	} blinkm_cmds[17] = {
108	/* cmdchar, cmdbyte, nr_args, nr_ret, dir */
109	{ 'n', 0x6e, 3, 0, 1},
110	{ 'c', 0x63, 3, 0, 1},
111	{ 'h', 0x68, 3, 0, 1},
112	{ 'C', 0x43, 3, 0, 1},
113	{ 'H', 0x48, 3, 0, 1},
114	{ 'p', 0x70, 3, 0, 1},
115	{ 'o', 0x6f, 0, 0, 1},
116	{ 'f', 0x66, 1, 0, 1},
117	{ 't', 0x74, 1, 0, 1},
118	{ 'g', 0x67, 0, 3, 0},
119	{ 'W', 0x57, 7, 0, 1},
120	{ 'R', 0x52, 2, 5, 2},
121	{ 'L', 0x4c, 3, 0, 1},
122	{ 'A', 0x41, 4, 0, 1},
123	{ 'a', 0x61, 0, 1, 0},
124	{ 'Z', 0x5a, 0, 1, 0},
125	{ 'B', 0x42, 5, 0, 1},
126	};
127
128	static ssize_t show_color_common(struct device dev, char buf, int color)
129	{
130	struct i2c_client *client;
131	struct blinkm_data *data;
132	int ret;
133
134	client = to_i2c_client(dev);
135	data = i2c_get_clientdata(client);
136
137	ret = blinkm_transfer_hw(client, BLM_GET_CUR_RGB);
138	if (ret < 0)
139	return ret;
140	switch (color) {
141	case RED:
142	return scnprintf(buf, PAGE_SIZE, "%02X\n", data->red);
b54cf35a JSM	143	case GREEN:
b54cf35a JSM	144	return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green);
b54cf35a JSM	145	case BLUE:
b54cf35a JSM	146	return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue);
b54cf35a JSM	147	default:
	148	return -EINVAL;
	149	}
	150	return -EINVAL;
	151	}
	152
	153	static int store_color_common(struct device dev, const char buf, int color)
	154	{
	155	struct i2c_client *client;
	156	struct blinkm_data *data;
	157	int ret;
	158	u8 value;
	159
	160	client = to_i2c_client(dev);
	161	data = i2c_get_clientdata(client);
	162
	163	ret = kstrtou8(buf, 10, &value);
	164	if (ret < 0) {
	165	dev_err(dev, "BlinkM: value too large!\n");
	166	return ret;
	167	}
	168
	169	switch (color) {
	170	case RED:
	171	data->next_red = value;
	172	break;
	173	case GREEN:
	174	data->next_green = value;
	175	break;
	176	case BLUE:
	177	data->next_blue = value;
	178	break;
	179	default:
	180	return -EINVAL;
	181	}
	182
	183	dev_dbg(dev, "next_red = %d, next_green = %d, next_blue = %d\n",
	184	data->next_red, data->next_green, data->next_blue);
	185
	186	/* if mode ... */
	187	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
	188	if (ret < 0) {
	189	dev_err(dev, "BlinkM: can't set RGB\n");
	190	return ret;
	191	}
	192	return 0;
	193	}
	194
5ccfa39d	195	static ssize_t red_show(struct device dev, struct device_attribute attr,
b54cf35a JSM	196	char *buf)
	197	{
	198	return show_color_common(dev, buf, RED);
	199	}
	200
5ccfa39d	201	static ssize_t red_store(struct device dev, struct device_attribute attr,
b54cf35a JSM	202	const char *buf, size_t count)
	203	{
	204	int ret;
	205
	206	ret = store_color_common(dev, buf, RED);
	207	if (ret < 0)
	208	return ret;
	209	return count;
	210	}
	211
5ccfa39d	212	static DEVICE_ATTR_RW(red);
b54cf35a	213
5ccfa39d	214	static ssize_t green_show(struct device dev, struct device_attribute attr,
b54cf35a JSM	215	char *buf)
	216	{
	217	return show_color_common(dev, buf, GREEN);
	218	}
	219
5ccfa39d	220	static ssize_t green_store(struct device dev, struct device_attribute attr,
b54cf35a JSM	221	const char *buf, size_t count)
	222	{
	223
	224	int ret;
	225
	226	ret = store_color_common(dev, buf, GREEN);
	227	if (ret < 0)
	228	return ret;
	229	return count;
	230	}
	231
5ccfa39d	232	static DEVICE_ATTR_RW(green);
b54cf35a	233
5ccfa39d	234	static ssize_t blue_show(struct device dev, struct device_attribute attr,
b54cf35a JSM	235	char *buf)
	236	{
	237	return show_color_common(dev, buf, BLUE);
	238	}
	239
5ccfa39d	240	static ssize_t blue_store(struct device dev, struct device_attribute attr,
b54cf35a JSM	241	const char *buf, size_t count)
	242	{
	243	int ret;
	244
	245	ret = store_color_common(dev, buf, BLUE);
	246	if (ret < 0)
	247	return ret;
	248	return count;
	249	}
	250
5ccfa39d	251	static DEVICE_ATTR_RW(blue);
b54cf35a	252
5ccfa39d	253	static ssize_t test_show(struct device dev, struct device_attribute attr,
b54cf35a JSM	254	char *buf)
	255	{
	256	return scnprintf(buf, PAGE_SIZE,
	257	"#Write into test to start test sequence!#\n");
	258	}
	259
5ccfa39d	260	static ssize_t test_store(struct device dev, struct device_attribute attr,
b54cf35a JSM	261	const char *buf, size_t count)
	262	{
	263
	264	struct i2c_client *client;
	265	int ret;
	266	client = to_i2c_client(dev);
	267
	268	/test /
	269	ret = blinkm_test_run(client);
	270	if (ret < 0)
	271	return ret;
	272
	273	return count;
	274	}
	275
5ccfa39d	276	static DEVICE_ATTR_RW(test);
b54cf35a JSM	277
	278	/* TODO: HSB, fade, timeadj, script ... */
	279
	280	static struct attribute *blinkm_attrs[] = {
	281	&dev_attr_red.attr,
	282	&dev_attr_green.attr,
	283	&dev_attr_blue.attr,
	284	&dev_attr_test.attr,
	285	NULL,
	286	};
	287
7358df4d	288	static const struct attribute_group blinkm_group = {
b54cf35a JSM	289	.name = "blinkm",
	290	.attrs = blinkm_attrs,
	291	};
	292
	293	static int blinkm_write(struct i2c_client client, int cmd, u8 arg)
	294	{
	295	int result;
	296	int i;
	297	int arglen = blinkm_cmds[cmd].nr_args;
	298	/* write out cmd to blinkm - always / default step */
	299	result = i2c_smbus_write_byte(client, blinkm_cmds[cmd].cmdbyte);
	300	if (result < 0)
	301	return result;
	302	/* no args to write out */
	303	if (arglen == 0)
	304	return 0;
	305
	306	for (i = 0; i < arglen; i++) {
	307	/* repeat for arglen */
	308	result = i2c_smbus_write_byte(client, arg[i]);
	309	if (result < 0)
	310	return result;
	311	}
	312	return 0;
	313	}
	314
	315	static int blinkm_read(struct i2c_client client, int cmd, u8 arg)
	316	{
	317	int result;
	318	int i;
	319	int retlen = blinkm_cmds[cmd].nr_ret;
	320	for (i = 0; i < retlen; i++) {
	321	/* repeat for retlen */
	322	result = i2c_smbus_read_byte(client);
	323	if (result < 0)
	324	return result;
	325	arg[i] = result;
	326	}
	327
	328	return 0;
	329	}
	330
	331	static int blinkm_transfer_hw(struct i2c_client *client, int cmd)
	332	{
	333	/* the protocol is simple but non-standard:
	334	* e.g. cmd 'g' (= 0x67) for "get device address"
	335	* - which defaults to 0x09 - would be the sequence:
	336	* a) write 0x67 to the device (byte write)
	337	* b) read the value (0x09) back right after (byte read)
	338	*
	339	* Watch out for "unfinished" sequences (i.e. not enough reads
	340	* or writes after a command. It will make the blinkM misbehave.
	341	* Sequence is key here.
	342	*/
	343
	344	/* args / return are in private data struct */
	345	struct blinkm_data *data = i2c_get_clientdata(client);
	346
	347	/* We start hardware transfers which are not to be
	348	* mixed with other commands. Aquire a lock now. */
	349	if (mutex_lock_interruptible(&data->update_lock) < 0)
	350	return -EAGAIN;
	351
	352	/* switch cmd - usually write before reads */
353	switch (cmd) {
354	case BLM_FADE_RAND_RGB:
355	case BLM_GO_RGB:
356	case BLM_FADE_RGB:
357	data->args[0] = data->next_red;
358	data->args[1] = data->next_green;
359	data->args[2] = data->next_blue;
360	blinkm_write(client, cmd, data->args);
361	data->red = data->args[0];
362	data->green = data->args[1];
363	data->blue = data->args[2];
364	break;
365	case BLM_FADE_HSB:
366	case BLM_FADE_RAND_HSB:
367	data->args[0] = data->next_hue;
368	data->args[1] = data->next_saturation;
369	data->args[2] = data->next_brightness;
370	blinkm_write(client, cmd, data->args);
371	data->hue = data->next_hue;
372	data->saturation = data->next_saturation;
373	data->brightness = data->next_brightness;
374	break;
375	case BLM_PLAY_SCRIPT:
376	data->args[0] = data->script_id;
377	data->args[1] = data->script_repeats;
378	data->args[2] = data->script_startline;
379	blinkm_write(client, cmd, data->args);
380	break;
381	case BLM_STOP_SCRIPT:
382	blinkm_write(client, cmd, NULL);
383	break;
384	case BLM_GET_CUR_RGB:
385	data->args[0] = data->red;
386	data->args[1] = data->green;
387	data->args[2] = data->blue;
388	blinkm_write(client, cmd, NULL);
389	blinkm_read(client, cmd, data->args);
390	data->red = data->args[0];
391	data->green = data->args[1];
392	data->blue = data->args[2];
393	break;
394	case BLM_GET_ADDR:
395	data->args[0] = data->i2c_addr;
396	blinkm_write(client, cmd, NULL);
397	blinkm_read(client, cmd, data->args);
398	data->i2c_addr = data->args[0];
399	break;
400	case BLM_SET_TIME_ADJ:
401	case BLM_SET_FADE_SPEED:
402	case BLM_READ_SCRIPT_LINE:
403	case BLM_WRITE_SCRIPT_LINE:
404	case BLM_SET_SCRIPT_LR:
405	case BLM_SET_ADDR:
406	case BLM_GET_FW_VER:
407	case BLM_SET_STARTUP_PARAM:
408	dev_err(&client->dev,
409	"BlinkM: cmd %d not implemented yet.\n", cmd);
410	break;
411	default:
412	dev_err(&client->dev, "BlinkM: unknown command %d\n", cmd);
413	mutex_unlock(&data->update_lock);
414	return -EINVAL;
415	} /* end switch(cmd) */
416
417	/* transfers done, unlock */
418	mutex_unlock(&data->update_lock);
419	return 0;
420	}
421
b54cf35a JSM	422	static int blinkm_led_common_set(struct led_classdev *led_cdev,
	423	enum led_brightness value, int color)
	424	{
	425	/* led_brightness is 0, 127 or 255 - we just use it here as-is */
	426	struct blinkm_led *led = cdev_to_blmled(led_cdev);
	427	struct blinkm_data *data = i2c_get_clientdata(led->i2c_client);
b54cf35a JSM	428
	429	switch (color) {
	430	case RED:
	431	/* bail out if there's no change */
	432	if (data->next_red == (u8) value)
	433	return 0;
b54cf35a JSM	434	data->next_red = (u8) value;
	435	break;
	436	case GREEN:
	437	/* bail out if there's no change */
	438	if (data->next_green == (u8) value)
	439	return 0;
b54cf35a JSM	440	data->next_green = (u8) value;
	441	break;
	442	case BLUE:
	443	/* bail out if there's no change */
	444	if (data->next_blue == (u8) value)
	445	return 0;
b54cf35a JSM	446	data->next_blue = (u8) value;
	447	break;
	448
	449	default:
	450	dev_err(&led->i2c_client->dev, "BlinkM: unknown color.\n");
	451	return -EINVAL;
	452	}
	453
7e1761b0	454	blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB);
b54cf35a	455	dev_dbg(&led->i2c_client->dev,
7e1761b0 AL	456	"# DONE # next_red = %d, next_green = %d,"
7e1761b0 AL	457	" next_blue = %d\n",
b54cf35a	458	data->next_red, data->next_green,
7e1761b0	459	data->next_blue);
b54cf35a JSM	460	return 0;
	461	}
	462
7e1761b0	463	static int blinkm_led_red_set(struct led_classdev *led_cdev,
b54cf35a JSM	464	enum led_brightness value)
b54cf35a JSM	465	{
7e1761b0	466	return blinkm_led_common_set(led_cdev, value, RED);
b54cf35a JSM	467	}
b54cf35a JSM	468
7e1761b0	469	static int blinkm_led_green_set(struct led_classdev *led_cdev,
b54cf35a JSM	470	enum led_brightness value)
b54cf35a JSM	471	{
7e1761b0	472	return blinkm_led_common_set(led_cdev, value, GREEN);
b54cf35a JSM	473	}
b54cf35a JSM	474
7e1761b0	475	static int blinkm_led_blue_set(struct led_classdev *led_cdev,
b54cf35a JSM	476	enum led_brightness value)
b54cf35a JSM	477	{
7e1761b0	478	return blinkm_led_common_set(led_cdev, value, BLUE);
b54cf35a JSM	479	}
	480
	481	static void blinkm_init_hw(struct i2c_client *client)
	482	{
69f0027e LJ	483	blinkm_transfer_hw(client, BLM_STOP_SCRIPT);
69f0027e LJ	484	blinkm_transfer_hw(client, BLM_GO_RGB);
b54cf35a JSM	485	}
	486
	487	static int blinkm_test_run(struct i2c_client *client)
	488	{
	489	int ret;
	490	struct blinkm_data *data = i2c_get_clientdata(client);
	491
	492	data->next_red = 0x01;
	493	data->next_green = 0x05;
	494	data->next_blue = 0x10;
	495	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
	496	if (ret < 0)
	497	return ret;
	498	msleep(2000);
	499
	500	data->next_red = 0x25;
	501	data->next_green = 0x10;
	502	data->next_blue = 0x31;
	503	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
	504	if (ret < 0)
	505	return ret;
	506	msleep(2000);
	507
	508	data->next_hue = 0x50;
	509	data->next_saturation = 0x10;
	510	data->next_brightness = 0x20;
	511	ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
	512	if (ret < 0)
	513	return ret;
	514	msleep(2000);
	515
	516	return 0;
	517	}
	518
	519	/* Return 0 if detection is successful, -ENODEV otherwise */
	520	static int blinkm_detect(struct i2c_client client, struct i2c_board_info info)
	521	{
	522	struct i2c_adapter *adapter = client->adapter;
	523	int ret;
	524	int count = 99;
	525	u8 tmpargs[7];
	526
	527	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
	528	\| I2C_FUNC_SMBUS_WORD_DATA
	529	\| I2C_FUNC_SMBUS_WRITE_BYTE))
	530	return -ENODEV;
	531
	532	/* Now, we do the remaining detection. Simple for now. */
	533	/* We might need more guards to protect other i2c slaves */
	534
	535	/* make sure the blinkM is balanced (read/writes) */
	536	while (count > 0) {
	537	ret = blinkm_write(client, BLM_GET_ADDR, NULL);
e0d42298 AB	538	if (ret)
e0d42298 AB	539	return ret;
b54cf35a JSM	540	usleep_range(5000, 10000);
b54cf35a JSM	541	ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
e0d42298 AB	542	if (ret)
e0d42298 AB	543	return ret;
b54cf35a JSM	544	usleep_range(5000, 10000);
	545	if (tmpargs[0] == 0x09)
	546	count = 0;
	547	count--;
	548	}
	549
	550	/* Step 1: Read BlinkM address back - cmd_char 'a' */
	551	ret = blinkm_write(client, BLM_GET_ADDR, NULL);
	552	if (ret < 0)
18d4a06f	553	return ret;
b54cf35a JSM	554	usleep_range(20000, 30000); /* allow a small delay */
	555	ret = blinkm_read(client, BLM_GET_ADDR, tmpargs);
	556	if (ret < 0)
18d4a06f	557	return ret;
b54cf35a JSM	558
	559	if (tmpargs[0] != 0x09) {
	560	dev_err(&client->dev, "enodev DEV ADDR = 0x%02X\n", tmpargs[0]);
	561	return -ENODEV;
	562	}
	563
	564	strlcpy(info->type, "blinkm", I2C_NAME_SIZE);
	565	return 0;
	566	}
	567
98ea1ea2	568	static int blinkm_probe(struct i2c_client *client,
b54cf35a JSM	569	const struct i2c_device_id *id)
	570	{
	571	struct blinkm_data *data;
	572	struct blinkm_led *led[3];
	573	int err, i;
	574	char blinkm_led_name[28];
	575
	576	data = devm_kzalloc(&client->dev,
	577	sizeof(struct blinkm_data), GFP_KERNEL);
	578	if (!data) {
	579	err = -ENOMEM;
	580	goto exit;
	581	}
	582
b54cf35a JSM	583	data->i2c_addr = 0x08;
	584	/* i2c addr - use fake addr of 0x08 initially (real is 0x09) */
	585	data->fw_ver = 0xfe;
	586	/* firmware version - use fake until we read real value
	587	* (currently broken - BlinkM confused!) */
	588	data->script_id = 0x01;
	589	data->i2c_client = client;
	590
	591	i2c_set_clientdata(client, data);
	592	mutex_init(&data->update_lock);
	593
	594	/* Register sysfs hooks */
	595	err = sysfs_create_group(&client->dev.kobj, &blinkm_group);
	596	if (err < 0) {
	597	dev_err(&client->dev, "couldn't register sysfs group\n");
	598	goto exit;
	599	}
	600
	601	for (i = 0; i < 3; i++) {
	602	/* RED = 0, GREEN = 1, BLUE = 2 */
	603	led[i] = &data->blinkm_leds[i];
	604	led[i]->i2c_client = client;
	605	led[i]->id = i;
	606	led[i]->led_cdev.max_brightness = 255;
	607	led[i]->led_cdev.flags = LED_CORE_SUSPENDRESUME;
b54cf35a JSM	608	switch (i) {
	609	case RED:
	610	snprintf(blinkm_led_name, sizeof(blinkm_led_name),
	611	"blinkm-%d-%d-red",
	612	client->adapter->nr,
	613	client->addr);
	614	led[i]->led_cdev.name = blinkm_led_name;
7e1761b0 AL	615	led[i]->led_cdev.brightness_set_blocking =
7e1761b0 AL	616	blinkm_led_red_set;
b54cf35a JSM	617	err = led_classdev_register(&client->dev,
	618	&led[i]->led_cdev);
	619	if (err < 0) {
	620	dev_err(&client->dev,
	621	"couldn't register LED %s\n",
	622	led[i]->led_cdev.name);
	623	goto failred;
	624	}
	625	break;
	626	case GREEN:
	627	snprintf(blinkm_led_name, sizeof(blinkm_led_name),
	628	"blinkm-%d-%d-green",
	629	client->adapter->nr,
	630	client->addr);
	631	led[i]->led_cdev.name = blinkm_led_name;
7e1761b0 AL	632	led[i]->led_cdev.brightness_set_blocking =
7e1761b0 AL	633	blinkm_led_green_set;
b54cf35a JSM	634	err = led_classdev_register(&client->dev,
	635	&led[i]->led_cdev);
	636	if (err < 0) {
	637	dev_err(&client->dev,
	638	"couldn't register LED %s\n",
	639	led[i]->led_cdev.name);
	640	goto failgreen;
	641	}
	642	break;
	643	case BLUE:
	644	snprintf(blinkm_led_name, sizeof(blinkm_led_name),
	645	"blinkm-%d-%d-blue",
	646	client->adapter->nr,
	647	client->addr);
	648	led[i]->led_cdev.name = blinkm_led_name;
7e1761b0 AL	649	led[i]->led_cdev.brightness_set_blocking =
7e1761b0 AL	650	blinkm_led_blue_set;
b54cf35a JSM	651	err = led_classdev_register(&client->dev,
	652	&led[i]->led_cdev);
	653	if (err < 0) {
	654	dev_err(&client->dev,
	655	"couldn't register LED %s\n",
	656	led[i]->led_cdev.name);
	657	goto failblue;
	658	}
	659	break;
	660	} /* end switch */
	661	} /* end for */
	662
	663	/* Initialize the blinkm */
	664	blinkm_init_hw(client);
	665
	666	return 0;
	667
	668	failblue:
	669	led_classdev_unregister(&led[GREEN]->led_cdev);
	670
	671	failgreen:
	672	led_classdev_unregister(&led[RED]->led_cdev);
	673
	674	failred:
	675	sysfs_remove_group(&client->dev.kobj, &blinkm_group);
	676	exit:
	677	return err;
	678	}
	679
678e8a6b	680	static int blinkm_remove(struct i2c_client *client)
b54cf35a JSM	681	{
	682	struct blinkm_data *data = i2c_get_clientdata(client);
	683	int ret = 0;
	684	int i;
	685
	686	/* make sure no workqueue entries are pending */
7e1761b0	687	for (i = 0; i < 3; i++)
b54cf35a	688	led_classdev_unregister(&data->blinkm_leds[i].led_cdev);
b54cf35a JSM	689
	690	/* reset rgb */
	691	data->next_red = 0x00;
	692	data->next_green = 0x00;
	693	data->next_blue = 0x00;
	694	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
	695	if (ret < 0)
	696	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
	697
	698	/* reset hsb */
	699	data->next_hue = 0x00;
	700	data->next_saturation = 0x00;
	701	data->next_brightness = 0x00;
	702	ret = blinkm_transfer_hw(client, BLM_FADE_HSB);
	703	if (ret < 0)
	704	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
	705
	706	/* red fade to off */
	707	data->next_red = 0xff;
	708	ret = blinkm_transfer_hw(client, BLM_GO_RGB);
	709	if (ret < 0)
	710	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
	711
	712	/* off */
	713	data->next_red = 0x00;
	714	ret = blinkm_transfer_hw(client, BLM_FADE_RGB);
	715	if (ret < 0)
	716	dev_err(&client->dev, "Failure in blinkm_remove ignored. Continuing.\n");
	717
	718	sysfs_remove_group(&client->dev.kobj, &blinkm_group);
	719	return 0;
	720	}
	721
	722	static const struct i2c_device_id blinkm_id[] = {
	723	{"blinkm", 0},
	724	{}
	725	};
	726
	727	MODULE_DEVICE_TABLE(i2c, blinkm_id);
	728
	729	/* This is the driver that will be inserted */
	730	static struct i2c_driver blinkm_driver = {
	731	.class = I2C_CLASS_HWMON,
	732	.driver = {
	733	.name = "blinkm",
	734	},
	735	.probe = blinkm_probe,
df07cf81	736	.remove = blinkm_remove,
b54cf35a JSM	737	.id_table = blinkm_id,
	738	.detect = blinkm_detect,
	739	.address_list = normal_i2c,
	740	};
	741
	742	module_i2c_driver(blinkm_driver);
	743
	744	MODULE_AUTHOR("Jan-Simon Moeller <dl9pf@gmx.de>");
	745	MODULE_DESCRIPTION("BlinkM RGB LED driver");
	746	MODULE_LICENSE("GPL");
	747