mirror of
https://github.com/torvalds/linux.git
synced 2024-11-14 08:02:07 +00:00
ed5c2f5fd1
The value returned by an i2c driver's remove function is mostly ignored. (Only an error message is printed if the value is non-zero that the error is ignored.) So change the prototype of the remove function to return no value. This way driver authors are not tempted to assume that passing an error to the upper layer is a good idea. All drivers are adapted accordingly. There is no intended change of behaviour, all callbacks were prepared to return 0 before. Reviewed-by: Peter Senna Tschudin <peter.senna@gmail.com> Reviewed-by: Jeremy Kerr <jk@codeconstruct.com.au> Reviewed-by: Benjamin Mugnier <benjamin.mugnier@foss.st.com> Reviewed-by: Javier Martinez Canillas <javierm@redhat.com> Reviewed-by: Crt Mori <cmo@melexis.com> Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com> Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> Acked-by: Marek Behún <kabel@kernel.org> # for leds-turris-omnia Acked-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Reviewed-by: Petr Machata <petrm@nvidia.com> # for mlxsw Reviewed-by: Maximilian Luz <luzmaximilian@gmail.com> # for surface3_power Acked-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com> # for bmc150-accel-i2c + kxcjk-1013 Reviewed-by: Hans Verkuil <hverkuil-cisco@xs4all.nl> # for media/* + staging/media/* Acked-by: Miguel Ojeda <ojeda@kernel.org> # for auxdisplay/ht16k33 + auxdisplay/lcd2s Reviewed-by: Luca Ceresoli <luca.ceresoli@bootlin.com> # for versaclock5 Reviewed-by: Ajay Gupta <ajayg@nvidia.com> # for ucsi_ccg Acked-by: Jonathan Cameron <Jonathan.Cameron@huawei.com> # for iio Acked-by: Peter Rosin <peda@axentia.se> # for i2c-mux-*, max9860 Acked-by: Adrien Grassein <adrien.grassein@gmail.com> # for lontium-lt8912b Reviewed-by: Jean Delvare <jdelvare@suse.de> # for hwmon, i2c-core and i2c/muxes Acked-by: Corey Minyard <cminyard@mvista.com> # for IPMI Reviewed-by: Vladimir Oltean <olteanv@gmail.com> Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> Acked-by: Sebastian Reichel <sebastian.reichel@collabora.com> # for drivers/power Acked-by: Krzysztof Hałasa <khalasa@piap.pl> Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Signed-off-by: Wolfram Sang <wsa@kernel.org>
747 lines
18 KiB
C
747 lines
18 KiB
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 void 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);
|
|
}
|
|
|
|
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");
|
|
|