678e8a6be9
CONFIG_HOTPLUG is going away as an option so __devexit is no longer needed. Signed-off-by: Bill Pemberton <wfp5p@virginia.edu> Cc: Richard Purdie <rpurdie@rpsys.net> Cc: Jan-Simon Moeller <jansimon.moeller@gmx.de> Acked-by: Bryan Wu <cooloney@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
763 lines
20 KiB
C
763 lines
20 KiB
C
/*
|
|
* leds-tca6507
|
|
*
|
|
* The TCA6507 is a programmable LED controller that can drive 7
|
|
* separate lines either by holding them low, or by pulsing them
|
|
* with modulated width.
|
|
* The modulation can be varied in a simple pattern to produce a blink or
|
|
* double-blink.
|
|
*
|
|
* This driver can configure each line either as a 'GPIO' which is out-only
|
|
* (no pull-up) or as an LED with variable brightness and hardware-assisted
|
|
* blinking.
|
|
*
|
|
* Apart from OFF and ON there are three programmable brightness levels which
|
|
* can be programmed from 0 to 15 and indicate how many 500usec intervals in
|
|
* each 8msec that the led is 'on'. The levels are named MASTER, BANK0 and
|
|
* BANK1.
|
|
*
|
|
* There are two different blink rates that can be programmed, each with
|
|
* separate time for rise, on, fall, off and second-off. Thus if 3 or more
|
|
* different non-trivial rates are required, software must be used for the extra
|
|
* rates. The two different blink rates must align with the two levels BANK0 and
|
|
* BANK1.
|
|
* This driver does not support double-blink so 'second-off' always matches
|
|
* 'off'.
|
|
*
|
|
* Only 16 different times can be programmed in a roughly logarithmic scale from
|
|
* 64ms to 16320ms. To be precise the possible times are:
|
|
* 0, 64, 128, 192, 256, 384, 512, 768,
|
|
* 1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
|
|
*
|
|
* Times that cannot be closely matched with these must be
|
|
* handled in software. This driver allows 12.5% error in matching.
|
|
*
|
|
* This driver does not allow rise/fall rates to be set explicitly. When trying
|
|
* to match a given 'on' or 'off' period, an appropriate pair of 'change' and
|
|
* 'hold' times are chosen to get a close match. If the target delay is even,
|
|
* the 'change' number will be the smaller; if odd, the 'hold' number will be
|
|
* the smaller.
|
|
|
|
* Choosing pairs of delays with 12.5% errors allows us to match delays in the
|
|
* ranges: 56-72, 112-144, 168-216, 224-27504, 28560-36720.
|
|
* 26% of the achievable sums can be matched by multiple pairings. For example
|
|
* 1536 == 1536+0, 1024+512, or 768+768. This driver will always choose the
|
|
* pairing with the least maximum - 768+768 in this case. Other pairings are
|
|
* not available.
|
|
*
|
|
* Access to the 3 levels and 2 blinks are on a first-come, first-served basis.
|
|
* Access can be shared by multiple leds if they have the same level and
|
|
* either same blink rates, or some don't blink.
|
|
* When a led changes, it relinquishes access and tries again, so it might
|
|
* lose access to hardware blink.
|
|
* If a blink engine cannot be allocated, software blink is used.
|
|
* If the desired brightness cannot be allocated, the closest available non-zero
|
|
* brightness is used. As 'full' is always available, the worst case would be
|
|
* to have two different blink rates at '1', with Max at '2', then other leds
|
|
* will have to choose between '2' and '16'. Hopefully this is not likely.
|
|
*
|
|
* Each bank (BANK0 and BANK1) has two usage counts - LEDs using the brightness
|
|
* and LEDs using the blink. It can only be reprogrammed when the appropriate
|
|
* counter is zero. The MASTER level has a single usage count.
|
|
*
|
|
* Each Led has programmable 'on' and 'off' time as milliseconds. With each
|
|
* there is a flag saying if it was explicitly requested or defaulted.
|
|
* Similarly the banks know if each time was explicit or a default. Defaults
|
|
* are permitted to be changed freely - they are not recognised when matching.
|
|
*
|
|
*
|
|
* An led-tca6507 device must be provided with platform data. This data
|
|
* lists for each output: the name, default trigger, and whether the signal
|
|
* is being used as a GPiO rather than an led. 'struct led_plaform_data'
|
|
* is used for this. If 'name' is NULL, the output isn't used. If 'flags'
|
|
* is TCA6507_MAKE_CPIO, the output is a GPO.
|
|
* The "struct led_platform_data" can be embedded in a
|
|
* "struct tca6507_platform_data" which adds a 'gpio_base' for the GPiOs,
|
|
* and a 'setup' callback which is called once the GPiOs are available.
|
|
*
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/leds.h>
|
|
#include <linux/err.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/leds-tca6507.h>
|
|
|
|
/* LED select registers determine the source that drives LED outputs */
|
|
#define TCA6507_LS_LED_OFF 0x0 /* Output HI-Z (off) */
|
|
#define TCA6507_LS_LED_OFF1 0x1 /* Output HI-Z (off) - not used */
|
|
#define TCA6507_LS_LED_PWM0 0x2 /* Output LOW with Bank0 rate */
|
|
#define TCA6507_LS_LED_PWM1 0x3 /* Output LOW with Bank1 rate */
|
|
#define TCA6507_LS_LED_ON 0x4 /* Output LOW (on) */
|
|
#define TCA6507_LS_LED_MIR 0x5 /* Output LOW with Master Intensity */
|
|
#define TCA6507_LS_BLINK0 0x6 /* Blink at Bank0 rate */
|
|
#define TCA6507_LS_BLINK1 0x7 /* Blink at Bank1 rate */
|
|
|
|
enum {
|
|
BANK0,
|
|
BANK1,
|
|
MASTER,
|
|
};
|
|
static int bank_source[3] = {
|
|
TCA6507_LS_LED_PWM0,
|
|
TCA6507_LS_LED_PWM1,
|
|
TCA6507_LS_LED_MIR,
|
|
};
|
|
static int blink_source[2] = {
|
|
TCA6507_LS_BLINK0,
|
|
TCA6507_LS_BLINK1,
|
|
};
|
|
|
|
/* PWM registers */
|
|
#define TCA6507_REG_CNT 11
|
|
|
|
/*
|
|
* 0x00, 0x01, 0x02 encode the TCA6507_LS_* values, each output
|
|
* owns one bit in each register
|
|
*/
|
|
#define TCA6507_FADE_ON 0x03
|
|
#define TCA6507_FULL_ON 0x04
|
|
#define TCA6507_FADE_OFF 0x05
|
|
#define TCA6507_FIRST_OFF 0x06
|
|
#define TCA6507_SECOND_OFF 0x07
|
|
#define TCA6507_MAX_INTENSITY 0x08
|
|
#define TCA6507_MASTER_INTENSITY 0x09
|
|
#define TCA6507_INITIALIZE 0x0A
|
|
|
|
#define INIT_CODE 0x8
|
|
|
|
#define TIMECODES 16
|
|
static int time_codes[TIMECODES] = {
|
|
0, 64, 128, 192, 256, 384, 512, 768,
|
|
1024, 1536, 2048, 3072, 4096, 5760, 8128, 16320
|
|
};
|
|
|
|
/* Convert an led.brightness level (0..255) to a TCA6507 level (0..15) */
|
|
static inline int TO_LEVEL(int brightness)
|
|
{
|
|
return brightness >> 4;
|
|
}
|
|
|
|
/* ...and convert back */
|
|
static inline int TO_BRIGHT(int level)
|
|
{
|
|
if (level)
|
|
return (level << 4) | 0xf;
|
|
return 0;
|
|
}
|
|
|
|
#define NUM_LEDS 7
|
|
struct tca6507_chip {
|
|
int reg_set; /* One bit per register where
|
|
* a '1' means the register
|
|
* should be written */
|
|
u8 reg_file[TCA6507_REG_CNT];
|
|
/* Bank 2 is Master Intensity and doesn't use times */
|
|
struct bank {
|
|
int level;
|
|
int ontime, offtime;
|
|
int on_dflt, off_dflt;
|
|
int time_use, level_use;
|
|
} bank[3];
|
|
struct i2c_client *client;
|
|
struct work_struct work;
|
|
spinlock_t lock;
|
|
|
|
struct tca6507_led {
|
|
struct tca6507_chip *chip;
|
|
struct led_classdev led_cdev;
|
|
int num;
|
|
int ontime, offtime;
|
|
int on_dflt, off_dflt;
|
|
int bank; /* Bank used, or -1 */
|
|
int blink; /* Set if hardware-blinking */
|
|
} leds[NUM_LEDS];
|
|
#ifdef CONFIG_GPIOLIB
|
|
struct gpio_chip gpio;
|
|
const char *gpio_name[NUM_LEDS];
|
|
int gpio_map[NUM_LEDS];
|
|
#endif
|
|
};
|
|
|
|
static const struct i2c_device_id tca6507_id[] = {
|
|
{ "tca6507" },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, tca6507_id);
|
|
|
|
static int choose_times(int msec, int *c1p, int *c2p)
|
|
{
|
|
/*
|
|
* Choose two timecodes which add to 'msec' as near as possible.
|
|
* The first returned is the 'on' or 'off' time. The second is to be
|
|
* used as a 'fade-on' or 'fade-off' time. If 'msec' is even,
|
|
* the first will not be smaller than the second. If 'msec' is odd,
|
|
* the first will not be larger than the second.
|
|
* If we cannot get a sum within 1/8 of 'msec' fail with -EINVAL,
|
|
* otherwise return the sum that was achieved, plus 1 if the first is
|
|
* smaller.
|
|
* If two possibilities are equally good (e.g. 512+0, 256+256), choose
|
|
* the first pair so there is more change-time visible (i.e. it is
|
|
* softer).
|
|
*/
|
|
int c1, c2;
|
|
int tmax = msec * 9 / 8;
|
|
int tmin = msec * 7 / 8;
|
|
int diff = 65536;
|
|
|
|
/* We start at '1' to ensure we never even think of choosing a
|
|
* total time of '0'.
|
|
*/
|
|
for (c1 = 1; c1 < TIMECODES; c1++) {
|
|
int t = time_codes[c1];
|
|
if (t*2 < tmin)
|
|
continue;
|
|
if (t > tmax)
|
|
break;
|
|
for (c2 = 0; c2 <= c1; c2++) {
|
|
int tt = t + time_codes[c2];
|
|
int d;
|
|
if (tt < tmin)
|
|
continue;
|
|
if (tt > tmax)
|
|
break;
|
|
/* This works! */
|
|
d = abs(msec - tt);
|
|
if (d >= diff)
|
|
continue;
|
|
/* Best yet */
|
|
*c1p = c1;
|
|
*c2p = c2;
|
|
diff = d;
|
|
if (d == 0)
|
|
return msec;
|
|
}
|
|
}
|
|
if (diff < 65536) {
|
|
int actual;
|
|
if (msec & 1) {
|
|
c1 = *c2p;
|
|
*c2p = *c1p;
|
|
*c1p = c1;
|
|
}
|
|
actual = time_codes[*c1p] + time_codes[*c2p];
|
|
if (*c1p < *c2p)
|
|
return actual + 1;
|
|
else
|
|
return actual;
|
|
}
|
|
/* No close match */
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* Update the register file with the appropriate 3-bit state for
|
|
* the given led.
|
|
*/
|
|
static void set_select(struct tca6507_chip *tca, int led, int val)
|
|
{
|
|
int mask = (1 << led);
|
|
int bit;
|
|
|
|
for (bit = 0; bit < 3; bit++) {
|
|
int n = tca->reg_file[bit] & ~mask;
|
|
if (val & (1 << bit))
|
|
n |= mask;
|
|
if (tca->reg_file[bit] != n) {
|
|
tca->reg_file[bit] = n;
|
|
tca->reg_set |= (1 << bit);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Update the register file with the appropriate 4-bit code for
|
|
* one bank or other. This can be used for timers, for levels, or
|
|
* for initialisation.
|
|
*/
|
|
static void set_code(struct tca6507_chip *tca, int reg, int bank, int new)
|
|
{
|
|
int mask = 0xF;
|
|
int n;
|
|
if (bank) {
|
|
mask <<= 4;
|
|
new <<= 4;
|
|
}
|
|
n = tca->reg_file[reg] & ~mask;
|
|
n |= new;
|
|
if (tca->reg_file[reg] != n) {
|
|
tca->reg_file[reg] = n;
|
|
tca->reg_set |= 1 << reg;
|
|
}
|
|
}
|
|
|
|
/* Update brightness level. */
|
|
static void set_level(struct tca6507_chip *tca, int bank, int level)
|
|
{
|
|
switch (bank) {
|
|
case BANK0:
|
|
case BANK1:
|
|
set_code(tca, TCA6507_MAX_INTENSITY, bank, level);
|
|
break;
|
|
case MASTER:
|
|
set_code(tca, TCA6507_MASTER_INTENSITY, 0, level);
|
|
break;
|
|
}
|
|
tca->bank[bank].level = level;
|
|
}
|
|
|
|
/* Record all relevant time code for a given bank */
|
|
static void set_times(struct tca6507_chip *tca, int bank)
|
|
{
|
|
int c1, c2;
|
|
int result;
|
|
|
|
result = choose_times(tca->bank[bank].ontime, &c1, &c2);
|
|
dev_dbg(&tca->client->dev,
|
|
"Chose on times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1],
|
|
c2, time_codes[c2], tca->bank[bank].ontime);
|
|
set_code(tca, TCA6507_FADE_ON, bank, c2);
|
|
set_code(tca, TCA6507_FULL_ON, bank, c1);
|
|
tca->bank[bank].ontime = result;
|
|
|
|
result = choose_times(tca->bank[bank].offtime, &c1, &c2);
|
|
dev_dbg(&tca->client->dev,
|
|
"Chose off times %d(%d) %d(%d) for %dms\n", c1, time_codes[c1],
|
|
c2, time_codes[c2], tca->bank[bank].offtime);
|
|
set_code(tca, TCA6507_FADE_OFF, bank, c2);
|
|
set_code(tca, TCA6507_FIRST_OFF, bank, c1);
|
|
set_code(tca, TCA6507_SECOND_OFF, bank, c1);
|
|
tca->bank[bank].offtime = result;
|
|
|
|
set_code(tca, TCA6507_INITIALIZE, bank, INIT_CODE);
|
|
}
|
|
|
|
/* Write all needed register of tca6507 */
|
|
|
|
static void tca6507_work(struct work_struct *work)
|
|
{
|
|
struct tca6507_chip *tca = container_of(work, struct tca6507_chip,
|
|
work);
|
|
struct i2c_client *cl = tca->client;
|
|
int set;
|
|
u8 file[TCA6507_REG_CNT];
|
|
int r;
|
|
|
|
spin_lock_irq(&tca->lock);
|
|
set = tca->reg_set;
|
|
memcpy(file, tca->reg_file, TCA6507_REG_CNT);
|
|
tca->reg_set = 0;
|
|
spin_unlock_irq(&tca->lock);
|
|
|
|
for (r = 0; r < TCA6507_REG_CNT; r++)
|
|
if (set & (1<<r))
|
|
i2c_smbus_write_byte_data(cl, r, file[r]);
|
|
}
|
|
|
|
static void led_release(struct tca6507_led *led)
|
|
{
|
|
/* If led owns any resource, release it. */
|
|
struct tca6507_chip *tca = led->chip;
|
|
if (led->bank >= 0) {
|
|
struct bank *b = tca->bank + led->bank;
|
|
if (led->blink)
|
|
b->time_use--;
|
|
b->level_use--;
|
|
}
|
|
led->blink = 0;
|
|
led->bank = -1;
|
|
}
|
|
|
|
static int led_prepare(struct tca6507_led *led)
|
|
{
|
|
/* Assign this led to a bank, configuring that bank if necessary. */
|
|
int level = TO_LEVEL(led->led_cdev.brightness);
|
|
struct tca6507_chip *tca = led->chip;
|
|
int c1, c2;
|
|
int i;
|
|
struct bank *b;
|
|
int need_init = 0;
|
|
|
|
led->led_cdev.brightness = TO_BRIGHT(level);
|
|
if (level == 0) {
|
|
set_select(tca, led->num, TCA6507_LS_LED_OFF);
|
|
return 0;
|
|
}
|
|
|
|
if (led->ontime == 0 || led->offtime == 0) {
|
|
/*
|
|
* Just set the brightness, choosing first usable bank.
|
|
* If none perfect, choose best.
|
|
* Count backwards so we check MASTER bank first
|
|
* to avoid wasting a timer.
|
|
*/
|
|
int best = -1;/* full-on */
|
|
int diff = 15-level;
|
|
|
|
if (level == 15) {
|
|
set_select(tca, led->num, TCA6507_LS_LED_ON);
|
|
return 0;
|
|
}
|
|
|
|
for (i = MASTER; i >= BANK0; i--) {
|
|
int d;
|
|
if (tca->bank[i].level == level ||
|
|
tca->bank[i].level_use == 0) {
|
|
best = i;
|
|
break;
|
|
}
|
|
d = abs(level - tca->bank[i].level);
|
|
if (d < diff) {
|
|
diff = d;
|
|
best = i;
|
|
}
|
|
}
|
|
if (best == -1) {
|
|
/* Best brightness is full-on */
|
|
set_select(tca, led->num, TCA6507_LS_LED_ON);
|
|
led->led_cdev.brightness = LED_FULL;
|
|
return 0;
|
|
}
|
|
|
|
if (!tca->bank[best].level_use)
|
|
set_level(tca, best, level);
|
|
|
|
tca->bank[best].level_use++;
|
|
led->bank = best;
|
|
set_select(tca, led->num, bank_source[best]);
|
|
led->led_cdev.brightness = TO_BRIGHT(tca->bank[best].level);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* We have on/off time so we need to try to allocate a timing bank.
|
|
* First check if times are compatible with hardware and give up if
|
|
* not.
|
|
*/
|
|
if (choose_times(led->ontime, &c1, &c2) < 0)
|
|
return -EINVAL;
|
|
if (choose_times(led->offtime, &c1, &c2) < 0)
|
|
return -EINVAL;
|
|
|
|
for (i = BANK0; i <= BANK1; i++) {
|
|
if (tca->bank[i].level_use == 0)
|
|
/* not in use - it is ours! */
|
|
break;
|
|
if (tca->bank[i].level != level)
|
|
/* Incompatible level - skip */
|
|
/* FIX: if timer matches we maybe should consider
|
|
* this anyway...
|
|
*/
|
|
continue;
|
|
|
|
if (tca->bank[i].time_use == 0)
|
|
/* Timer not in use, and level matches - use it */
|
|
break;
|
|
|
|
if (!(tca->bank[i].on_dflt ||
|
|
led->on_dflt ||
|
|
tca->bank[i].ontime == led->ontime))
|
|
/* on time is incompatible */
|
|
continue;
|
|
|
|
if (!(tca->bank[i].off_dflt ||
|
|
led->off_dflt ||
|
|
tca->bank[i].offtime == led->offtime))
|
|
/* off time is incompatible */
|
|
continue;
|
|
|
|
/* looks like a suitable match */
|
|
break;
|
|
}
|
|
|
|
if (i > BANK1)
|
|
/* Nothing matches - how sad */
|
|
return -EINVAL;
|
|
|
|
b = &tca->bank[i];
|
|
if (b->level_use == 0)
|
|
set_level(tca, i, level);
|
|
b->level_use++;
|
|
led->bank = i;
|
|
|
|
if (b->on_dflt ||
|
|
!led->on_dflt ||
|
|
b->time_use == 0) {
|
|
b->ontime = led->ontime;
|
|
b->on_dflt = led->on_dflt;
|
|
need_init = 1;
|
|
}
|
|
|
|
if (b->off_dflt ||
|
|
!led->off_dflt ||
|
|
b->time_use == 0) {
|
|
b->offtime = led->offtime;
|
|
b->off_dflt = led->off_dflt;
|
|
need_init = 1;
|
|
}
|
|
|
|
if (need_init)
|
|
set_times(tca, i);
|
|
|
|
led->ontime = b->ontime;
|
|
led->offtime = b->offtime;
|
|
|
|
b->time_use++;
|
|
led->blink = 1;
|
|
led->led_cdev.brightness = TO_BRIGHT(b->level);
|
|
set_select(tca, led->num, blink_source[i]);
|
|
return 0;
|
|
}
|
|
|
|
static int led_assign(struct tca6507_led *led)
|
|
{
|
|
struct tca6507_chip *tca = led->chip;
|
|
int err;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tca->lock, flags);
|
|
led_release(led);
|
|
err = led_prepare(led);
|
|
if (err) {
|
|
/*
|
|
* Can only fail on timer setup. In that case we need to
|
|
* re-establish as steady level.
|
|
*/
|
|
led->ontime = 0;
|
|
led->offtime = 0;
|
|
led_prepare(led);
|
|
}
|
|
spin_unlock_irqrestore(&tca->lock, flags);
|
|
|
|
if (tca->reg_set)
|
|
schedule_work(&tca->work);
|
|
return err;
|
|
}
|
|
|
|
static void tca6507_brightness_set(struct led_classdev *led_cdev,
|
|
enum led_brightness brightness)
|
|
{
|
|
struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
|
|
led_cdev);
|
|
led->led_cdev.brightness = brightness;
|
|
led->ontime = 0;
|
|
led->offtime = 0;
|
|
led_assign(led);
|
|
}
|
|
|
|
static int tca6507_blink_set(struct led_classdev *led_cdev,
|
|
unsigned long *delay_on,
|
|
unsigned long *delay_off)
|
|
{
|
|
struct tca6507_led *led = container_of(led_cdev, struct tca6507_led,
|
|
led_cdev);
|
|
|
|
if (*delay_on == 0)
|
|
led->on_dflt = 1;
|
|
else if (delay_on != &led_cdev->blink_delay_on)
|
|
led->on_dflt = 0;
|
|
led->ontime = *delay_on;
|
|
|
|
if (*delay_off == 0)
|
|
led->off_dflt = 1;
|
|
else if (delay_off != &led_cdev->blink_delay_off)
|
|
led->off_dflt = 0;
|
|
led->offtime = *delay_off;
|
|
|
|
if (led->ontime == 0)
|
|
led->ontime = 512;
|
|
if (led->offtime == 0)
|
|
led->offtime = 512;
|
|
|
|
if (led->led_cdev.brightness == LED_OFF)
|
|
led->led_cdev.brightness = LED_FULL;
|
|
if (led_assign(led) < 0) {
|
|
led->ontime = 0;
|
|
led->offtime = 0;
|
|
led->led_cdev.brightness = LED_OFF;
|
|
return -EINVAL;
|
|
}
|
|
*delay_on = led->ontime;
|
|
*delay_off = led->offtime;
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_GPIOLIB
|
|
static void tca6507_gpio_set_value(struct gpio_chip *gc,
|
|
unsigned offset, int val)
|
|
{
|
|
struct tca6507_chip *tca = container_of(gc, struct tca6507_chip, gpio);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&tca->lock, flags);
|
|
/*
|
|
* 'OFF' is floating high, and 'ON' is pulled down, so it has the
|
|
* inverse sense of 'val'.
|
|
*/
|
|
set_select(tca, tca->gpio_map[offset],
|
|
val ? TCA6507_LS_LED_OFF : TCA6507_LS_LED_ON);
|
|
spin_unlock_irqrestore(&tca->lock, flags);
|
|
if (tca->reg_set)
|
|
schedule_work(&tca->work);
|
|
}
|
|
|
|
static int tca6507_gpio_direction_output(struct gpio_chip *gc,
|
|
unsigned offset, int val)
|
|
{
|
|
tca6507_gpio_set_value(gc, offset, val);
|
|
return 0;
|
|
}
|
|
|
|
static int tca6507_probe_gpios(struct i2c_client *client,
|
|
struct tca6507_chip *tca,
|
|
struct tca6507_platform_data *pdata)
|
|
{
|
|
int err;
|
|
int i = 0;
|
|
int gpios = 0;
|
|
|
|
for (i = 0; i < NUM_LEDS; i++)
|
|
if (pdata->leds.leds[i].name && pdata->leds.leds[i].flags) {
|
|
/* Configure as a gpio */
|
|
tca->gpio_name[gpios] = pdata->leds.leds[i].name;
|
|
tca->gpio_map[gpios] = i;
|
|
gpios++;
|
|
}
|
|
|
|
if (!gpios)
|
|
return 0;
|
|
|
|
tca->gpio.label = "gpio-tca6507";
|
|
tca->gpio.names = tca->gpio_name;
|
|
tca->gpio.ngpio = gpios;
|
|
tca->gpio.base = pdata->gpio_base;
|
|
tca->gpio.owner = THIS_MODULE;
|
|
tca->gpio.direction_output = tca6507_gpio_direction_output;
|
|
tca->gpio.set = tca6507_gpio_set_value;
|
|
tca->gpio.dev = &client->dev;
|
|
err = gpiochip_add(&tca->gpio);
|
|
if (err) {
|
|
tca->gpio.ngpio = 0;
|
|
return err;
|
|
}
|
|
if (pdata->setup)
|
|
pdata->setup(tca->gpio.base, tca->gpio.ngpio);
|
|
return 0;
|
|
}
|
|
|
|
static void tca6507_remove_gpio(struct tca6507_chip *tca)
|
|
{
|
|
if (tca->gpio.ngpio) {
|
|
int err = gpiochip_remove(&tca->gpio);
|
|
dev_err(&tca->client->dev, "%s failed, %d\n",
|
|
"gpiochip_remove()", err);
|
|
}
|
|
}
|
|
#else /* CONFIG_GPIOLIB */
|
|
static int tca6507_probe_gpios(struct i2c_client *client,
|
|
struct tca6507_chip *tca,
|
|
struct tca6507_platform_data *pdata)
|
|
{
|
|
return 0;
|
|
}
|
|
static void tca6507_remove_gpio(struct tca6507_chip *tca)
|
|
{
|
|
}
|
|
#endif /* CONFIG_GPIOLIB */
|
|
|
|
static int tca6507_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct tca6507_chip *tca;
|
|
struct i2c_adapter *adapter;
|
|
struct tca6507_platform_data *pdata;
|
|
int err;
|
|
int i = 0;
|
|
|
|
adapter = to_i2c_adapter(client->dev.parent);
|
|
pdata = client->dev.platform_data;
|
|
|
|
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
|
|
return -EIO;
|
|
|
|
if (!pdata || pdata->leds.num_leds != NUM_LEDS) {
|
|
dev_err(&client->dev, "Need %d entries in platform-data list\n",
|
|
NUM_LEDS);
|
|
return -ENODEV;
|
|
}
|
|
tca = devm_kzalloc(&client->dev, sizeof(*tca), GFP_KERNEL);
|
|
if (!tca)
|
|
return -ENOMEM;
|
|
|
|
tca->client = client;
|
|
INIT_WORK(&tca->work, tca6507_work);
|
|
spin_lock_init(&tca->lock);
|
|
i2c_set_clientdata(client, tca);
|
|
|
|
for (i = 0; i < NUM_LEDS; i++) {
|
|
struct tca6507_led *l = tca->leds + i;
|
|
|
|
l->chip = tca;
|
|
l->num = i;
|
|
if (pdata->leds.leds[i].name && !pdata->leds.leds[i].flags) {
|
|
l->led_cdev.name = pdata->leds.leds[i].name;
|
|
l->led_cdev.default_trigger
|
|
= pdata->leds.leds[i].default_trigger;
|
|
l->led_cdev.brightness_set = tca6507_brightness_set;
|
|
l->led_cdev.blink_set = tca6507_blink_set;
|
|
l->bank = -1;
|
|
err = led_classdev_register(&client->dev,
|
|
&l->led_cdev);
|
|
if (err < 0)
|
|
goto exit;
|
|
}
|
|
}
|
|
err = tca6507_probe_gpios(client, tca, pdata);
|
|
if (err)
|
|
goto exit;
|
|
/* set all registers to known state - zero */
|
|
tca->reg_set = 0x7f;
|
|
schedule_work(&tca->work);
|
|
|
|
return 0;
|
|
exit:
|
|
while (i--) {
|
|
if (tca->leds[i].led_cdev.name)
|
|
led_classdev_unregister(&tca->leds[i].led_cdev);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int tca6507_remove(struct i2c_client *client)
|
|
{
|
|
int i;
|
|
struct tca6507_chip *tca = i2c_get_clientdata(client);
|
|
struct tca6507_led *tca_leds = tca->leds;
|
|
|
|
for (i = 0; i < NUM_LEDS; i++) {
|
|
if (tca_leds[i].led_cdev.name)
|
|
led_classdev_unregister(&tca_leds[i].led_cdev);
|
|
}
|
|
tca6507_remove_gpio(tca);
|
|
cancel_work_sync(&tca->work);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct i2c_driver tca6507_driver = {
|
|
.driver = {
|
|
.name = "leds-tca6507",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.probe = tca6507_probe,
|
|
.remove = tca6507_remove,
|
|
.id_table = tca6507_id,
|
|
};
|
|
|
|
module_i2c_driver(tca6507_driver);
|
|
|
|
MODULE_AUTHOR("NeilBrown <neilb@suse.de>");
|
|
MODULE_DESCRIPTION("TCA6507 LED/GPO driver");
|
|
MODULE_LICENSE("GPL v2");
|