--- /dev/null
+--- 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 <linux/module.h>
++#include <linux/delay.h>
++#include <linux/string.h>
++#include <linux/ctype.h>
++#include <linux/leds.h>
++#include <linux/err.h>
++#include <linux/i2c.h>
++#include <linux/workqueue.h>
++
++/* 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");
projects / openwrt.git / blobdiff