/* * test_blinkm.c Jan-Simon Moeller (dl9pf@gmx.de) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include #include #include #include #include #include /* 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; atomic_t active; }; struct blinkm_work { struct blinkm_led *blinkm_led; struct work_struct work; }; #define cdev_to_blmled(c) container_of(c, struct blinkm_led, led_cdev) #define work_to_blmwork(c) container_of(c, struct blinkm_work, work) 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; /* c_r - color red */ u8 green; /* c_g - color green */ u8 blue; /* c_b - 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; /* c_h - HSB hue */ u8 saturation; /* c_s - HSB saturation */ u8 brightness; /* c_br - 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 */ }; #define BLM_DIR_READ 0 #define BLM_DIR_WRITE 1 #define BLM_DIR_WRITE_READ 2 #define BLM_DIR_READ_WRITE 3 /* 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*/ /* cmdchar = command (ascii) cmdbyte = command in hex nr_args = number of arguments to send nr_ret = number of return values dir = direction (0 = read, 1 = write) */ static const struct { int cmd; char cmdchar; u8 cmdbyte; u8 nr_args; u8 nr_ret; u8 dir:2; } blinkm_cmds[17] = { /* cmdchar, cmdbyte, nr_args, nr_ret, dir */ { 0, 'n', 0x6e, 3, 0, 1}, { 1, 'c', 0x63, 3, 0, 1}, { 2, 'h', 0x68, 3, 0, 1}, { 3, 'C', 0x43, 3, 0, 1}, { 4, 'H', 0x48, 3, 0, 1}, { 5, 'p', 0x70, 3, 0, 1}, { 6, 'o', 0x6f, 0, 0, 1}, { 7, 'f', 0x66, 1, 0, 1}, { 8, 't', 0x74, 1, 0, 1}, { 9, 'g', 0x67, 0, 3, 0}, { 10, 'W', 0x57, 7, 0, 1}, { 11, 'R', 0x52, 2, 5, 2}, { 12, 'L', 0x4c, 3, 0, 1}, { 13, 'A', 0x41, 4, 0, 1}, { 14, 'a', 0x61, 0, 1, 0}, { 15, 'Z', 0x5a, 0, 1, 0}, { 16, 'B', 0x42, 5, 0, 1},}; static ssize_t show_red(struct device *dev, struct device_attribute *attr, char *buf) { 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 -1; return scnprintf(buf, PAGE_SIZE, "%02X\n", data->red); } static ssize_t store_red(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { 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; } data->red = value; /* 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 count; } static DEVICE_ATTR(red, S_IRUGO | S_IWUGO, show_red, store_red); static ssize_t show_green(struct device *dev, struct device_attribute *attr, char *buf) { 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 -1; return scnprintf(buf, PAGE_SIZE, "%02X\n", data->green); } static ssize_t store_green(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { 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; } data->green = value; /* if mode ... (todo: fading ?) */ ret = blinkm_transfer_hw(client, BLM_GO_RGB); if (ret < 0) { dev_err(dev, "BlinkM: can't set RGB\n"); return ret; } return count; } static DEVICE_ATTR(green, S_IRUGO | S_IWUGO, show_green, store_green); static ssize_t show_blue(struct device *dev, struct device_attribute *attr, char *buf) { 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 -1; return scnprintf(buf, PAGE_SIZE, "%02X\n", data->blue); } static ssize_t store_blue(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { 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; } data->blue = value; /* if mode ... (todo:fading ?) */ ret = blinkm_transfer_hw(client, BLM_GO_RGB); if (ret < 0) { dev_err(dev, "BlinkM: can't set RGB\n"); return ret; } return count; } static DEVICE_ATTR(blue, S_IRUGO | S_IWUGO, show_blue, store_blue); static ssize_t show_test(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 store_test(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(test, S_IRUGO | S_IWUGO, show_test, store_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 struct attribute_group blinkm_group = { .name = "blinkm", .attrs = blinkm_attrs, }; static int blinkm_write(struct i2c_client *client, int cmd, u8 *arg) { int result = 0; int i = 0; 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 = 0; int i = 0; 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 of "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_GO_RGB: data->args[0] = data->red; data->args[1] = data->green; data->args[2] = data->blue; blinkm_write(client, cmd, data->args); break; case BLM_FADE_RGB: data->args[0] = data->red; data->args[1] = data->green; data->args[2] = data->blue; blinkm_write(client, cmd, data->args); break; case BLM_FADE_HSB: data->args[0] = data->hue; data->args[1] = data->saturation; data->args[2] = data->brightness; blinkm_write(client, cmd, data->args); break; case BLM_FADE_RAND_RGB: data->args[0] = data->red; data->args[1] = data->green; data->args[2] = data->blue; blinkm_write(client, cmd, data->args); break; case BLM_FADE_RAND_HSB: data->args[0] = data->hue; data->args[1] = data->saturation; data->args[2] = data->brightness; blinkm_write(client, cmd, data->args); 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_SET_FADE_SPEED: blinkm_write(client, cmd, NULL); break; case BLM_SET_TIME_ADJ: 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_WRITE_SCRIPT_LINE: /* blinkm_write(client, cmd, NULL); */ break; case BLM_READ_SCRIPT_LINE: /*blinkm_write(client, cmd, NULL); blinkm_read(client, cmd, NULL); */ break; case BLM_SET_SCRIPT_LR: /*blinkm_write(client, cmd, NULL);*/ break; case BLM_SET_ADDR: /*blinkm_write(client, cmd, NULL);*/ 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_GET_FW_VER: blinkm_write(client, cmd, data->args); blinkm_read(client, cmd, data->args); break; case BLM_SET_STARTUP_PARAM: blinkm_write(client, cmd, data->args); break; default: return -1; } /* end switch(cmd) */ /* transfers done, unlock */ mutex_unlock(&data->update_lock); return 0; } static void led_work(struct work_struct *work) { int ret; struct blinkm_led *led; struct blinkm_work *blm_work = work_to_blmwork(work); led = blm_work->blinkm_led; ret = blinkm_transfer_hw(led->i2c_client, BLM_GO_RGB); atomic_dec(&led->active); kfree(blm_work); } static void blinkm_led_red_set(struct led_classdev *led_cdev, enum led_brightness value) { /* 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); struct blinkm_work *bl_work_r = kzalloc(sizeof(struct blinkm_work), GFP_ATOMIC); switch (value) { case 0: data->red = 0; break; case 127: data->red = 0x88; break; case 255: data->red = 0xFF; break; default: data->red = 0; } /* data->red=(u8)value; we know it fits ... 0..255 */ atomic_inc(&led->active); bl_work_r->blinkm_led = led; INIT_WORK(&bl_work_r->work, led_work); schedule_work(&bl_work_r->work); } static void blinkm_led_green_set(struct led_classdev *led_cdev, enum led_brightness value) { /* 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); struct blinkm_work *bl_work_g = kzalloc(sizeof(struct blinkm_work), GFP_ATOMIC); switch (value) { case 0: data->green = 0; break; case 127: data->green = 0x88; break; case 255: data->green = 0xFF; break; default: data->green = 0; } /* data->green=(u8)value; we know it fits ... 0..255 */ atomic_inc(&led->active); bl_work_g->blinkm_led = led; INIT_WORK(&bl_work_g->work, led_work); schedule_work(&bl_work_g->work); } static void blinkm_led_blue_set(struct led_classdev *led_cdev, enum led_brightness value) { /* 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); struct blinkm_work *bl_work_b = kmalloc(sizeof(struct blinkm_work), GFP_ATOMIC); switch (value) { case 0: data->blue = 0; break; case 127: data->blue = 0x88; break; case 255: data->blue = 0xFF; break; default: data->blue = 0; } /* data->blue=(u8)value; // we know it fits ... 0..255 */ atomic_inc(&led->active); bl_work_b->blinkm_led = led; INIT_WORK(&bl_work_b->work, led_work); schedule_work(&bl_work_b->work); } static void blinkm_init_hw(struct i2c_client *client) { int ret; ret = blinkm_transfer_hw(client, BLM_STOP_SCRIPT); ret = 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->red = 0x01; data->green = 0x05; data->blue = 0x10; ret = blinkm_transfer_hw(client, BLM_GO_RGB); if (ret < 0) return -1; msleep(2000); data->red = 0x25; data->green = 0x10; data->blue = 0x31; ret = blinkm_transfer_hw(client, BLM_FADE_RGB); if (ret < 0) return -1; msleep(2000); data->hue = 0x50; data->saturation = 0x10; data->brightness = 0x20; ret = blinkm_transfer_hw(client, BLM_FADE_HSB); if (ret < 0) return -1; 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 = 0; int count = 99; u8 tmpargs[7] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 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); usleep_range(5000, 10000); ret = blinkm_read(client, BLM_GET_ADDR, tmpargs); 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 -ENODEV; usleep_range(20000, 30000); /* allow a small delay */ ret = blinkm_read(client, BLM_GET_ADDR, tmpargs); if (ret < 0) return -ENODEV; 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 *ledr; struct blinkm_led *ledg; struct blinkm_led *ledb; int err; data = kzalloc(sizeof(struct blinkm_data), GFP_KERNEL); if (!data) { err = -ENOMEM; goto exit; } data->i2c_addr = 0x09; data->red = 0x01; data->green = 0x01; data->blue = 0x01; data->hue = 0x01; data->saturation = 0x01; data->brightness = 0x01; data->fade = 0x01; data->rand = 0x00; data->fade_speed = 0x01; data->time_adjust = 0x01; data->i2c_addr = 0x08; /* i2c addr - use fake addr of 0x08 initially (0x09)*/ data->fw_ver = 0xfe; /* firmware version - use fake until we read real value (currently broken!)*/ data->args[0] = 0x00; data->script_id = 0x01; data->script_repeats = 0x00; data->script_startline = 0x00; 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; } /* red, id = 0 */ ledr = &data->blinkm_leds[0]; ledr->i2c_client = client; ledr->id = 0; ledr->led_cdev.name = "blinkm_red"; ledr->led_cdev.max_brightness = 255; ledr->led_cdev.brightness_set = blinkm_led_red_set; ledr->led_cdev.flags = LED_CORE_SUSPENDRESUME; atomic_set(&ledr->active, 0); err = led_classdev_register(&client->dev, &ledr->led_cdev); if (err < 0) { dev_err(&client->dev, "couldn't register LED %s\n", ledr->led_cdev.name); goto failred; } /* green, id = 1 */ ledg = &data->blinkm_leds[1]; ledg->i2c_client = client; ledg->id = 1; ledg->led_cdev.name = "blinkm_green"; ledg->led_cdev.max_brightness = 255; ledg->led_cdev.brightness_set = blinkm_led_green_set; ledg->led_cdev.flags = LED_CORE_SUSPENDRESUME; err = led_classdev_register(&client->dev, &ledg->led_cdev); atomic_set(&ledg->active, 0); if (err < 0) { dev_err(&client->dev, "couldn't register LED %s\n", ledg->led_cdev.name); goto failgreen; } /* blue, id = 2 */ ledb = &data->blinkm_leds[2]; ledb->i2c_client = client; ledb->id = 2; ledb->led_cdev.name = "blinkm_blue"; ledb->led_cdev.max_brightness = 255; ledb->led_cdev.brightness_set = blinkm_led_blue_set; ledb->led_cdev.flags = LED_CORE_SUSPENDRESUME; err = led_classdev_register(&client->dev, &ledb->led_cdev); atomic_set(&ledb->active, 0); if (err < 0) { dev_err(&client->dev, "couldn't register LED %s\n", ledb->led_cdev.name); goto failblue; } /* Initialize the blinkm */ blinkm_init_hw(client); return 0; failblue: led_classdev_unregister(&ledg->led_cdev); failgreen: led_classdev_unregister(&ledr->led_cdev); failred: sysfs_remove_group(&client->dev.kobj, &blinkm_group); exit: kfree(data); return err; } static int blinkm_remove(struct i2c_client *client) { struct blinkm_data *data = i2c_get_clientdata(client); int ret = 0; int maxcount; int i; for (i = 0; i < 3; i++) { maxcount=99; led_classdev_unregister(&data->blinkm_leds[i].led_cdev); while (atomic_read(&data->blinkm_leds[i].active) > 0){ if (maxcount == 0) break; msleep(100); maxcount--; } } /* reset rgb */ data->red = 0x05; data->green = 0x05; data->blue = 0x05; ret = blinkm_transfer_hw(client, BLM_FADE_RGB); if (ret < 0) printk(KERN_INFO "Failure in blinkm_remove ignored. Continuing.\n"); /* reset hsb */ data->hue = 0x00; data->saturation = 0x00; data->brightness = 0x00; ret = blinkm_transfer_hw(client, BLM_FADE_HSB); if (ret < 0) printk(KERN_INFO "Failure in blinkm_remove ignored. Continuing.\n"); /* red fade to off */ data->red = 0xff; ret = blinkm_transfer_hw(client, BLM_GO_RGB); if (ret < 0) printk(KERN_INFO "Failure in blinkm_remove ignored. Continuing.\n"); /* off */ data->red = 0x00; data->green = 0x00; data->blue = 0x00; ret = blinkm_transfer_hw(client, BLM_FADE_RGB); if (ret < 0) printk(KERN_INFO "Failure in blinkm_remove ignored. Continuing.\n"); sysfs_remove_group(&client->dev.kobj, &blinkm_group); kfree(data); 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, }; static int __init blinkm_init(void) { return i2c_add_driver(&blinkm_driver); } static void __exit blinkm_exit(void) { i2c_del_driver(&blinkm_driver); } MODULE_AUTHOR("Jan-Simon Moeller "); MODULE_DESCRIPTION("BlinkM"); MODULE_LICENSE("GPL"); module_init(blinkm_init); module_exit(blinkm_exit);