From d775e4ef00e08c839a41e101552be171ff638d3d Mon Sep 17 00:00:00 2001 From: Imre Kaloz Date: Tue, 17 Jun 2014 15:13:10 +0000 Subject: preliminary support for the WRT1900AC (work in progress) SVN-Revision: 41232 --- .../003-add_leds_tlc59116_driver.patch | 529 +++++++++++++++++++++ 1 file changed, 529 insertions(+) create mode 100644 target/linux/mvebu/patches-3.14/003-add_leds_tlc59116_driver.patch (limited to 'target/linux/mvebu/patches-3.14/003-add_leds_tlc59116_driver.patch') diff --git a/target/linux/mvebu/patches-3.14/003-add_leds_tlc59116_driver.patch b/target/linux/mvebu/patches-3.14/003-add_leds_tlc59116_driver.patch new file mode 100644 index 0000000..fea668d --- /dev/null +++ b/target/linux/mvebu/patches-3.14/003-add_leds_tlc59116_driver.patch @@ -0,0 +1,529 @@ +--- a/drivers/leds/Kconfig ++++ b/drivers/leds/Kconfig +@@ -487,6 +487,15 @@ config LEDS_BLINKM + This option enables support for the BlinkM RGB LED connected + through I2C. Say Y to enable support for the BlinkM LED. + ++config LEDS_TLC59116 ++ tristate "LED driver for TLC59116F dimmer" ++ depends on LEDS_CLASS ++ depends on I2C ++ help ++ This option enables support for Texas Instruments TLC59116F ++ LED controller. It is generally only useful ++ as a platform driver ++ + comment "LED Triggers" + source "drivers/leds/trigger/Kconfig" + +--- a/drivers/leds/Makefile ++++ b/drivers/leds/Makefile +@@ -54,6 +54,7 @@ obj-$(CONFIG_LEDS_ASIC3) += leds-asic3. + obj-$(CONFIG_LEDS_MAX8997) += leds-max8997.o + obj-$(CONFIG_LEDS_LM355x) += leds-lm355x.o + obj-$(CONFIG_LEDS_BLINKM) += leds-blinkm.o ++obj-$(CONFIG_LEDS_TLC59116) += leds-tlc59116.o + + # LED SPI Drivers + obj-$(CONFIG_LEDS_DAC124S085) += leds-dac124s085.o +--- /dev/null ++++ b/drivers/leds/leds-tlc59116.c +@@ -0,0 +1,498 @@ ++/* ++ * Copyright 2014 Belkin Inc. ++ * ++ * Author: Belkin Inc. ++ * ++ * This file is subject to the terms and conditions of version 2 of ++ * the GNU General Public License. See the file COPYING in the main ++ * directory of this archive for more details. ++ * ++ * LED driver for various TLC59116 I2C LED drivers ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++/* LED select registers determine the source that drives LED outputs */ ++#define TLC59116_LED_OFF 0x0 /* Output LOW */ ++#define TLC59116_LED_ON 0x1 /* Output HI-Z */ ++#define TLC59116_DIM 0x2 /* Dimming */ ++#define TLC59116_BLINK 0x3 /* Blinking */ ++ ++#define TLC59116_PINS 16 ++#define TLC59116_REG_MODE1 0x00 /* Mode register 0 */ ++#define MODE1_RESPON_ADDR_MASK 0xF0 ++#define MODE1_NORMAL_MODE (0 << 4) ++#define MODE1_SPEED_MODE (1 << 4) ++ ++#define TLC59116_REG_MODE2 0x01 /* Mode register 1 */ ++#define MODE2_DIM (0 << 5) ++#define MODE2_BLINK (1 << 5) ++#define MODE2_OCH_STOP (0 << 3) ++#define MODE2_OCH_ACK (1 << 3) ++ ++#define TLC59116_REG_PWM0 0x02 ++#define TLC59116_REG_PWM1 0x03 ++#define TLC59116_REG_PWM2 0x04 ++#define TLC59116_REG_PWM3 0x05 ++#define TLC59116_REG_PWM4 0x06 ++#define TLC59116_REG_PWM5 0x07 ++#define TLC59116_REG_PWM6 0x08 ++#define TLC59116_REG_PWM7 0x09 ++#define TLC59116_REG_PWM8 0x0a ++#define TLC59116_REG_PWM9 0x0b ++#define TLC59116_REG_PWM10 0x0c ++#define TLC59116_REG_PWM11 0x0d ++#define TLC59116_REG_PWM12 0x0e ++#define TLC59116_REG_PWM13 0x0f ++#define TLC59116_REG_PWM14 0x10 ++#define TLC59116_REG_PWM15 0x01 ++ ++#define TLC59116_REG_GRPPWM 0x12 ++#define TLC59116_REG_GRPFREQ 0x13 ++ ++#define TLC59116_PERIOD_MIN 41 /* 41ms */ ++#define TLC59116_PERIOD_MAX 10730 /* 10.73s */ ++ ++#define TLC59116_REG_LEDOUT0 0x14 /* LED [3:0] driver output state registers */ ++#define TLC59116_REG_LEDOUT1 0x15 /* LED [7:4] driver output state registers */ ++#define TLC59116_REG_LEDOUT2 0x16 /* LED [11:8] driver output state registers */ ++#define TLC59116_REG_LEDOUT3 0x17 /* LED [15:12] driver output state registers */ ++ ++#define GPIO0_MASK 0x3 ++ ++#define DEBUG 0 ++ ++#if DEBUG > 1 ++#define led_dbg(fmt, arg...) printk(KERN_DEBUG "tlc59116:%s " fmt "\n", __func__ , ## arg) ++#else ++#define led_dbg(fmt, arg...) ++#endif ++ ++ ++#if DEBUG > 0 ++#define led_info(fmt, arg...) printk("tlc59116:%s " fmt "\n", __func__ , ## arg) ++#else ++#define led_info(fmt, arg...) ++#endif ++ ++enum tlc59116_type { ++ tlc59116, ++}; ++ ++struct tlc59116_chipdef { ++ int bits; ++ u8 slv_addr; /* 7-bit slave address mask */ ++ int slv_addr_shift; /* Number of bits to ignore */ ++}; ++ ++static struct tlc59116_chipdef tlc59116_chipdefs[] = { ++ [tlc59116] = { ++ .bits = 16, ++ .slv_addr = /* 1100xxx */ 0x68, ++ .slv_addr_shift = 3, ++ }, ++}; ++ ++static const struct i2c_device_id tlc59116_id[] = { ++ { "tlc59116", tlc59116 }, ++ { } ++}; ++MODULE_DEVICE_TABLE(i2c, tlc59116_id); ++ ++struct tlc59116_led { ++ struct tlc59116_chipdef *chipdef; ++ struct i2c_client *client; ++ struct work_struct work; ++ spinlock_t lock; ++ enum led_brightness brightness; ++ struct led_classdev led_cdev; ++ int led_num; /* 0 .. 8 potentially */ ++ char name[32]; ++}; ++ ++//#define DUMP_REGS ++ ++#ifdef DUMP_REGS ++void dump_regs(struct i2c_client *client) ++{ ++ int i, j = 0; ++ u8 data; ++ printk ("\n-------------------------------------\n"); ++ for (i = 0; i< 0x20; i++) ++ { ++ data = i2c_smbus_read_byte_data(client, i); ++ printk ("[0x%x] = 0x%x ",i, data); ++ j++; ++ if (j == 5) ++ { ++ printk ("\n"); ++ j = 0; ++ } ++ } ++ printk ("\n"); ++} ++#endif ++ ++static int tlc59116_set_mode(struct i2c_client *client, uint8_t mode) ++{ ++ uint8_t val = 0; ++ ++ if ((mode != MODE2_DIM) && (mode != MODE2_BLINK)) ++ mode = MODE2_DIM; ++ ++ /* Configure MODE1 register */ ++ val &= 0x0; ++ val &= MODE1_RESPON_ADDR_MASK; ++ val |= MODE1_NORMAL_MODE; ++ i2c_smbus_write_byte_data(client, TLC59116_REG_MODE1, val); ++ ++ /* Configure MODE2 Reg */ ++ val &= 0x00; ++ val |= MODE2_OCH_STOP; ++ ++ val |= mode; ++ ++ i2c_smbus_write_byte_data(client, TLC59116_REG_MODE2, val); ++ mdelay(100); ++ ++ return 0; ++} ++ ++static int tlc59116_set_gpio_act(struct i2c_client *client, u8 gpio_no, u8 act_mode) ++{ ++ char data, addr = 0, i; ++ ++ if ((gpio_no >= 0) && (gpio_no < 4)) ++ addr = TLC59116_REG_LEDOUT0; ++ else if ((gpio_no >= 4) && (gpio_no < 8)) ++ addr = TLC59116_REG_LEDOUT1; ++ else if ((gpio_no >= 8) && (gpio_no < 12)) ++ addr = TLC59116_REG_LEDOUT2; ++ else if ((gpio_no >=12 ) && (gpio_no < 16)) ++ addr = TLC59116_REG_LEDOUT3; ++ ++ data = i2c_smbus_read_byte_data(client, addr); ++ ++ i = (gpio_no % 4) * 2; ++ ++ data &= ~(GPIO0_MASK << i); ++ act_mode = act_mode << i; ++ data |= act_mode; ++ ++ if(i2c_smbus_write_byte_data(client, addr, data) != 0) { ++ return -1; ++ } ++ return 0; ++} ++ ++static int tlc59116_set_gpio(struct i2c_client *client, uint8_t gpio_no, uint8_t val) ++{ ++ val &= 0x03; ++ tlc59116_set_gpio_act(client, gpio_no, val); ++#ifdef DUMP_REGS ++ dump_regs(client); ++#endif ++ return 0; ++} ++ ++static int tlc59116_get_gpio(struct i2c_client *client, uint8_t gpio_no) ++{ ++ uint8_t val, reg, data; ++ ++ led_dbg("gpio = %d\n", gpio_no); ++ reg = TLC59116_REG_LEDOUT0; ++ ++ if ((gpio_no >= 0) && (gpio_no < 4)) ++ reg = TLC59116_REG_LEDOUT0; ++ else if ((gpio_no >= 4) && (gpio_no < 8)) { ++ reg = TLC59116_REG_LEDOUT1; ++ gpio_no = gpio_no - 4; ++ } ++ else if ((gpio_no >= 8) && (gpio_no < 12)) { ++ reg = TLC59116_REG_LEDOUT2; ++ gpio_no = gpio_no - 8; ++ } ++ else if ((gpio_no >=12 ) && (gpio_no < 16)) { ++ reg = TLC59116_REG_LEDOUT3; ++ gpio_no = gpio_no - 12; ++ } ++ ++ val = i2c_smbus_read_byte_data(client, reg); ++ ++ data = (val >> (gpio_no * 2)) & 0x03; ++ return data; ++} ++ ++/* ++ * gpio_no [0..7] ++ * duty_cycle [0..99]% ++ * ++ * */ ++static int tlc59116_individual_brighness_control(struct i2c_client *client, uint8_t gpio_no, uint8_t brightness) ++{ ++ uint8_t pwm; ++ ++ pwm = gpio_no + TLC59116_REG_PWM0; ++ i2c_smbus_write_byte_data(client, pwm, brightness); ++ ++ return 0; ++} ++ ++static void tlc59116_led_work(struct work_struct *work) ++{ ++ struct tlc59116_led *tlc59116; ++ ++ tlc59116 = container_of(work, struct tlc59116_led, work); ++ ++ led_dbg("\nbrighness = %d \n", tlc59116->brightness); ++ switch (tlc59116->brightness) { ++ case LED_OFF: ++ led_info("\nLed off\n"); ++ tlc59116_set_gpio(tlc59116->client, tlc59116->led_num, TLC59116_LED_OFF); ++ break; ++ ++ case LED_FULL: ++ led_info("\nLed on\n"); ++ tlc59116_set_gpio(tlc59116->client, tlc59116->led_num, TLC59116_LED_ON); ++ break; ++ default: ++ led_info("\nBrightness is %d\n", tlc59116->brightness); ++ if (TLC59116_BLINK != tlc59116_get_gpio(tlc59116->client, tlc59116->led_num)) ++ tlc59116_set_gpio(tlc59116->client, tlc59116->led_num, TLC59116_DIM); ++ ++ tlc59116_individual_brighness_control(tlc59116->client, tlc59116->led_num, tlc59116->brightness); ++ break; ++ } ++ ++} ++ ++static void tlc59116_led_set(struct led_classdev *led_cdev, enum led_brightness value) ++{ ++ struct tlc59116_led *tlc59116; ++ ++ tlc59116 = container_of(led_cdev, struct tlc59116_led, led_cdev); ++ ++ spin_lock(&tlc59116->lock); ++ tlc59116->brightness = value; ++ ++ /* ++ * Must use workqueue for the actual I/O since I2C operations ++ * can sleep. ++ */ ++ schedule_work(&tlc59116->work); ++ ++ spin_unlock(&tlc59116->lock); ++} ++ ++/* ++ * delay_on, delay_off: units are in ms ++ * ++ */ ++ ++static int tlc59116_set_blink(struct led_classdev *led_cdev, ++ unsigned long *delay_on, ++ unsigned long *delay_off) ++{ ++ struct tlc59116_led *tlc59116; ++ uint16_t period; ++ uint16_t duty_cycle; ++ uint8_t gdc; ++ uint8_t gfrq; ++ ++ tlc59116 = container_of(led_cdev, struct tlc59116_led, led_cdev); ++ led_info ("Blinking: delay_on = %ldms, delay_off = %ldms, brightness = %d\n", ++ *delay_on, *delay_off, tlc59116->brightness); ++ ++ // Hardware blinking only for tricolor leds . The rest will have software blinking ++ if (tlc59116->led_num > 2) ++ return 1; ++ ++ if ((*delay_on == 0) && (*delay_off ==0)) { ++ spin_lock(&tlc59116->lock); ++ ++ /* MODE2[DMBLNK] = 1 */ ++ tlc59116_set_mode(tlc59116->client, MODE2_BLINK); ++ ++ /* Set LDRx = 11 */ ++ tlc59116_set_gpio(tlc59116->client, tlc59116->led_num, TLC59116_BLINK); ++ ++ tlc59116_individual_brighness_control(tlc59116->client, tlc59116->led_num, tlc59116->brightness); ++ spin_unlock(&tlc59116->lock); ++ return 0; ++ } ++ ++ ++ if ((*delay_on + *delay_off) > TLC59116_PERIOD_MAX) ++ { ++ led_dbg ("Max period is %dms\n", TLC59116_PERIOD_MAX); ++ return -EINVAL; ++ } ++ ++ if ((*delay_on + *delay_off) < TLC59116_PERIOD_MIN) ++ { ++ *delay_on = TLC59116_PERIOD_MIN/2 + 1; ++ *delay_off = TLC59116_PERIOD_MIN/2 + 1; ++ } ++ period = (*delay_on) + (*delay_off); ++ ++ duty_cycle = (100 * (*delay_on)) / period; ++ ++ spin_lock(&tlc59116->lock); ++ ++ /* MODE2[DMBLNK] = 1 */ ++ tlc59116_set_mode(tlc59116->client, MODE2_BLINK); ++ ++ /* Set LDRx = 11 */ ++ tlc59116_set_gpio(tlc59116->client, tlc59116->led_num, TLC59116_BLINK); ++ ++ tlc59116_individual_brighness_control(tlc59116->client, tlc59116->led_num, tlc59116->brightness); ++ ++ gdc = (duty_cycle * 256)/100; ++ i2c_smbus_write_byte_data(tlc59116->client, TLC59116_REG_GRPPWM, gdc); ++ ++ gfrq = (24 * period)/1000 - 1; /* unit is in second (convert from ms to second) */ ++ i2c_smbus_write_byte_data(tlc59116->client, TLC59116_REG_GRPFREQ, gfrq); ++ ++ ++#ifdef DUMP_REGS ++ dump_regs(tlc59116->client); ++#endif ++ ++ spin_unlock(&tlc59116->lock); ++ return 0; ++} ++ ++static int tlc59116_probe(struct i2c_client *client, ++ const struct i2c_device_id *id) ++{ ++ struct tlc59116_led *tlc59116; ++ struct tlc59116_chipdef *chip; ++ struct i2c_adapter *adapter; ++ struct led_platform_data *pdata; ++ int i, err; ++ ++ chip = &tlc59116_chipdefs[id->driver_data]; ++ adapter = to_i2c_adapter(client->dev.parent); ++ pdata = client->dev.platform_data; ++ ++ /* Make sure the slave address / chip type combo given is possible */ ++ if ((client->addr & ~((1 << chip->slv_addr_shift) - 1)) != ++ chip->slv_addr) { ++ dev_err(&client->dev, "invalid slave address %02x\n", ++ client->addr); ++ return -ENODEV; ++ } ++ ++ printk(KERN_INFO "leds-tlc59116: Using %s %d-bit LED driver at " ++ "slave address 0x%02x\n", ++ id->name, chip->bits, client->addr); ++ ++ if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) ++ return -EIO; ++ ++ if (pdata) { ++ if (pdata->num_leds != chip->bits) { ++ dev_err(&client->dev, "board info claims %d LEDs" ++ " on a %d-bit chip\n", ++ pdata->num_leds, chip->bits); ++ return -ENODEV; ++ } ++ } ++ ++ tlc59116 = devm_kzalloc(&client->dev, sizeof(*tlc59116) * chip->bits, GFP_KERNEL); ++ if (!tlc59116) ++ return -ENOMEM; ++ ++ i2c_set_clientdata(client, tlc59116); ++ ++ for (i = 0; i < chip->bits; i++) { ++ tlc59116[i].chipdef = chip; ++ tlc59116[i].client = client; ++ tlc59116[i].led_num = i; ++ ++ /* Platform data can specify LED names and default triggers */ ++ if (pdata) { ++ if (pdata->leds[i].name) ++ snprintf(tlc59116[i].name, ++ sizeof(tlc59116[i].name), "tlc59116:%s", ++ pdata->leds[i].name); ++ if (pdata->leds[i].default_trigger) ++ tlc59116[i].led_cdev.default_trigger = ++ pdata->leds[i].default_trigger; ++ } else { ++ snprintf(tlc59116[i].name, sizeof(tlc59116[i].name), ++ "tlc59116:%d", i); ++ } ++ ++ spin_lock_init(&tlc59116[i].lock); ++ ++ tlc59116[i].led_cdev.name = tlc59116[i].name; ++ tlc59116[i].led_cdev.brightness_set = tlc59116_led_set; ++ tlc59116[i].led_cdev.blink_set = tlc59116_set_blink; ++ tlc59116[i].led_cdev.brightness = 0; ++ ++ INIT_WORK(&tlc59116[i].work, tlc59116_led_work); ++ ++ err = led_classdev_register(&client->dev, &tlc59116[i].led_cdev); ++ if (err < 0) ++ goto exit; ++ } ++ ++ tlc59116_set_mode(client, MODE2_DIM); ++ ++ /* Turn off LEDs */ ++ for (i = 0; i < chip->bits; i++) ++ tlc59116_set_gpio(client, i, TLC59116_LED_OFF); ++ ++ return 0; ++ ++exit: ++ while (i--) { ++ led_classdev_unregister(&tlc59116[i].led_cdev); ++ cancel_work_sync(&tlc59116[i].work); ++ } ++ ++ devm_kfree(&client->dev, tlc59116); ++ i2c_set_clientdata(client, NULL); ++ ++ return err; ++} ++ ++static int tlc59116_remove(struct i2c_client *client) ++{ ++ struct tlc59116_led *tlc59116 = i2c_get_clientdata(client); ++ int i; ++ ++ for (i = 0; i < tlc59116->chipdef->bits; i++) { ++ led_classdev_unregister(&tlc59116[i].led_cdev); ++ cancel_work_sync(&tlc59116[i].work); ++ } ++ ++ devm_kfree(&client->dev, tlc59116); ++ i2c_set_clientdata(client, NULL); ++ ++ return 0; ++} ++ ++static struct i2c_driver tlc59116_driver = { ++ .driver = { ++ .name = "leds-tlc59116", ++ .owner = THIS_MODULE, ++ }, ++ .probe = tlc59116_probe, ++ .remove = tlc59116_remove, ++ .id_table = tlc59116_id, ++}; ++ ++module_i2c_driver(tlc59116_driver); ++ ++MODULE_AUTHOR("Belkin Inc."); ++MODULE_DESCRIPTION("TLC59116 LED driver"); ++MODULE_LICENSE("GPL v2"); -- cgit v1.1