Release 4.7 drivers/gpio/gpio-adp5588.c

Directory: drivers/gpio
/*
 * GPIO Chip driver for Analog Devices
 * ADP5588/ADP5587 I/O Expander and QWERTY Keypad Controller
 *
 * Copyright 2009-2010 Analog Devices Inc.
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/irq.h>

#include <linux/i2c/adp5588.h>


#define DRV_NAME	"adp5588-gpio"

/*
 * Early pre 4.0 Silicon required to delay readout by at least 25ms,
 * since the Event Counter Register updated 25ms after the interrupt
 * asserted.
 */

#define WA_DELAYED_READOUT_REVID(rev)	((rev) < 4)


struct adp5588_gpio {
	
struct i2c_client *client;
	
struct gpio_chip gpio_chip;
	
struct mutex lock;	/* protect cached dir, dat_out */
	/* protect serialized access to the interrupt controller bus */
	
struct mutex irq_lock;
	
unsigned gpio_start;
	
unsigned irq_base;
	
uint8_t dat_out[3];
	
uint8_t dir[3];
	
uint8_t int_lvl[3];
	
uint8_t int_en[3];
	
uint8_t irq_mask[3];
	
uint8_t irq_stat[3];
};



static int adp5588_gpio_read(struct i2c_client *client, u8 reg)
{
	int ret = i2c_smbus_read_byte_data(client, reg);

	if (ret < 0)
		dev_err(&client->dev, "Read Error\n");

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



static int adp5588_gpio_write(struct i2c_client *client, u8 reg, u8 val)
{
	int ret = i2c_smbus_write_byte_data(client, reg, val);

	if (ret < 0)
		dev_err(&client->dev, "Write Error\n");

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 48 100.00% 1 100.00%
Total 48 100.00% 1 100.00%



static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
{
	struct adp5588_gpio *dev = gpiochip_get_data(chip);
	unsigned bank = ADP5588_BANK(off);
	unsigned bit = ADP5588_BIT(off);
	int val;

	mutex_lock(&dev->lock);

	if (dev->dir[bank] & bit)
		val = dev->dat_out[bank];
	else
		val = adp5588_gpio_read(dev->client, GPIO_DAT_STAT1 + bank);

	mutex_unlock(&dev->lock);

	return !!(val & bit);
}

Contributors
Person Tokens Prop Commits CommitProp
jean-francois dagenais jean-francois dagenais 65 63.73% 1 33.33%
michael hennerich michael hennerich 36 35.29% 1 33.33%
linus walleij linus walleij 1 0.98% 1 33.33%
Total 102 100.00% 3 100.00%



static void adp5588_gpio_set_value(struct gpio_chip *chip,
				   unsigned off, int val)
{
	unsigned bank, bit;
	struct adp5588_gpio *dev = gpiochip_get_data(chip);

	bank = ADP5588_BANK(off);
	bit = ADP5588_BIT(off);

	mutex_lock(&dev->lock);
	if (val)
		dev->dat_out[bank] |= bit;
	else
		dev->dat_out[bank] &= ~bit;

	adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
			   dev->dat_out[bank]);
	mutex_unlock(&dev->lock);
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 103 99.04% 2 66.67%
linus walleij linus walleij 1 0.96% 1 33.33%
Total 104 100.00% 3 100.00%



static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
{
	int ret;
	unsigned bank;
	struct adp5588_gpio *dev = gpiochip_get_data(chip);

	bank = ADP5588_BANK(off);

	mutex_lock(&dev->lock);
	dev->dir[bank] &= ~ADP5588_BIT(off);
	ret = adp5588_gpio_write(dev->client, GPIO_DIR1 + bank, dev->dir[bank]);
	mutex_unlock(&dev->lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 88 98.88% 2 66.67%
linus walleij linus walleij 1 1.12% 1 33.33%
Total 89 100.00% 3 100.00%



static int adp5588_gpio_direction_output(struct gpio_chip *chip,
					 unsigned off, int val)
{
	int ret;
	unsigned bank, bit;
	struct adp5588_gpio *dev = gpiochip_get_data(chip);

	bank = ADP5588_BANK(off);
	bit = ADP5588_BIT(off);

	mutex_lock(&dev->lock);
	dev->dir[bank] |= bit;

	if (val)
		dev->dat_out[bank] |= bit;
	else
		dev->dat_out[bank] &= ~bit;

	ret = adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
				 dev->dat_out[bank]);
	ret |= adp5588_gpio_write(dev->client, GPIO_DIR1 + bank,
				 dev->dir[bank]);
	mutex_unlock(&dev->lock);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 140 99.29% 2 66.67%
linus walleij linus walleij 1 0.71% 1 33.33%
Total 141 100.00% 3 100.00%

#ifdef CONFIG_GPIO_ADP5588_IRQ


static int adp5588_gpio_to_irq(struct gpio_chip *chip, unsigned off)
{
	struct adp5588_gpio *dev = gpiochip_get_data(chip);

	return dev->irq_base + off;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 30 96.77% 2 66.67%
linus walleij linus walleij 1 3.23% 1 33.33%
Total 31 100.00% 3 100.00%



static void adp5588_irq_bus_lock(struct irq_data *d)
{
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);

	mutex_lock(&dev->irq_lock);
}

 Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 23 79.31% 2 66.67%
lennert buytenhek lennert buytenhek 6 20.69% 1 33.33%
Total 29 100.00% 3 100.00%

/*
  * genirq core code can issue chip->mask/unmask from atomic context.
  * This doesn't work for slow busses where an access needs to sleep.
  * bus_sync_unlock() is therefore called outside the atomic context,
  * syncs the current irq mask state with the slow external controller
  * and unlocks the bus.
  */



static void adp5588_irq_bus_sync_unlock(struct irq_data *d)
{
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	int i;

	for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++)
		if (dev->int_en[i] ^ dev->irq_mask[i]) {
			dev->int_en[i] = dev->irq_mask[i];
			adp5588_gpio_write(dev->client, GPIO_INT_EN1 + i,
					   dev->int_en[i]);
		}

	mutex_unlock(&dev->irq_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 92 93.88% 2 66.67%
lennert buytenhek lennert buytenhek 6 6.12% 1 33.33%
Total 98 100.00% 3 100.00%



static void adp5588_irq_mask(struct irq_data *d)
{
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	unsigned gpio = d->irq - dev->irq_base;

	dev->irq_mask[ADP5588_BANK(gpio)] &= ~ADP5588_BIT(gpio);
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 40 83.33% 2 66.67%
lennert buytenhek lennert buytenhek 8 16.67% 1 33.33%
Total 48 100.00% 3 100.00%



static void adp5588_irq_unmask(struct irq_data *d)
{
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	unsigned gpio = d->irq - dev->irq_base;

	dev->irq_mask[ADP5588_BANK(gpio)] |= ADP5588_BIT(gpio);
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 39 82.98% 1 50.00%
lennert buytenhek lennert buytenhek 8 17.02% 1 50.00%
Total 47 100.00% 2 100.00%



static int adp5588_irq_set_type(struct irq_data *d, unsigned int type)
{
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	uint16_t gpio = d->irq - dev->irq_base;
	unsigned bank, bit;

	if ((type & IRQ_TYPE_EDGE_BOTH)) {
		dev_err(&dev->client->dev, "irq %d: unsupported type %d\n",
			d->irq, type);
		return -EINVAL;
	}

	bank = ADP5588_BANK(gpio);
	bit = ADP5588_BIT(gpio);

	if (type & IRQ_TYPE_LEVEL_HIGH)
		dev->int_lvl[bank] |= bit;
	else if (type & IRQ_TYPE_LEVEL_LOW)
		dev->int_lvl[bank] &= ~bit;
	else
		return -EINVAL;

	adp5588_gpio_direction_input(&dev->gpio_chip, gpio);
	adp5588_gpio_write(dev->client, GPIO_INT_LVL1 + bank,
			   dev->int_lvl[bank]);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 145 93.55% 1 50.00%
lennert buytenhek lennert buytenhek 10 6.45% 1 50.00%
Total 155 100.00% 2 100.00%


static struct irq_chip adp5588_irq_chip = {
	.name			= "adp5588",
	.irq_mask		= adp5588_irq_mask,
	.irq_unmask		= adp5588_irq_unmask,
	.irq_bus_lock		= adp5588_irq_bus_lock,
	.irq_bus_sync_unlock	= adp5588_irq_bus_sync_unlock,
	.irq_set_type		= adp5588_irq_set_type,
};



static int adp5588_gpio_read_intstat(struct i2c_client *client, u8 *buf)
{
	int ret = i2c_smbus_read_i2c_block_data(client, GPIO_INT_STAT1, 3, buf);

	if (ret < 0)
		dev_err(&client->dev, "Read INT_STAT Error\n");

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 48 100.00% 1 100.00%
Total 48 100.00% 1 100.00%



static irqreturn_t adp5588_irq_handler(int irq, void *devid)
{
	struct adp5588_gpio *dev = devid;
	unsigned status, bank, bit, pending;
	int ret;
	status = adp5588_gpio_read(dev->client, INT_STAT);

	if (status & ADP5588_GPI_INT) {
		ret = adp5588_gpio_read_intstat(dev->client, dev->irq_stat);
		if (ret < 0)
			memset(dev->irq_stat, 0, ARRAY_SIZE(dev->irq_stat));

		for (bank = 0, bit = 0; bank <= ADP5588_BANK(ADP5588_MAXGPIO);
			bank++, bit = 0) {
			pending = dev->irq_stat[bank] & dev->irq_mask[bank];

			while (pending) {
				if (pending & (1 << bit)) {
					handle_nested_irq(dev->irq_base +
							  (bank << 3) + bit);
					pending &= ~(1 << bit);

				}
				bit++;
			}
		}
	}

	adp5588_gpio_write(dev->client, INT_STAT, status); /* Status is W1C */

	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 184 97.87% 1 50.00%
axel lin axel lin 4 2.13% 1 50.00%
Total 188 100.00% 2 100.00%



static int adp5588_irq_setup(struct adp5588_gpio *dev)
{
	struct i2c_client *client = dev->client;
	struct adp5588_gpio_platform_data *pdata =
			dev_get_platdata(&client->dev);
	unsigned gpio;
	int ret;

	adp5588_gpio_write(client, CFG, ADP5588_AUTO_INC);
	adp5588_gpio_write(client, INT_STAT, -1); /* status is W1C */
	adp5588_gpio_read_intstat(client, dev->irq_stat); /* read to clear */

	dev->irq_base = pdata->irq_base;
	mutex_init(&dev->irq_lock);

	for (gpio = 0; gpio < dev->gpio_chip.ngpio; gpio++) {
		int irq = gpio + dev->irq_base;
		irq_set_chip_data(irq, dev);
		irq_set_chip_and_handler(irq, &adp5588_irq_chip,
					 handle_level_irq);
		irq_set_nested_thread(irq, 1);
		irq_modify_status(irq, IRQ_NOREQUEST, IRQ_NOPROBE);
	}

	ret = request_threaded_irq(client->irq,
				   NULL,
				   adp5588_irq_handler,
				   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
				   dev_name(&client->dev), dev);
	if (ret) {
		dev_err(&client->dev, "failed to request irq %d\n",
			client->irq);
		goto out;
	}

	dev->gpio_chip.to_irq = adp5588_gpio_to_irq;
	adp5588_gpio_write(client, CFG,
		ADP5588_AUTO_INC | ADP5588_INT_CFG | ADP5588_GPI_INT);

	return 0;

out:
	dev->irq_base = 0;
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 220 95.24% 1 25.00%
rob herring rob herring 4 1.73% 1 25.00%
jingoo han jingoo han 4 1.73% 1 25.00%
thomas gleixner thomas gleixner 3 1.30% 1 25.00%
Total 231 100.00% 4 100.00%



static void adp5588_irq_teardown(struct adp5588_gpio *dev)
{
	if (dev->irq_base)
		free_irq(dev->client->irq, dev);
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%

#else


static int adp5588_irq_setup(struct adp5588_gpio *dev)
{
	struct i2c_client *client = dev->client;
	dev_warn(&client->dev, "interrupt support not compiled in\n");

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%



static void adp5588_irq_teardown(struct adp5588_gpio *dev)
{
}
Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 10 100.00% 1 100.00%
Total 10 100.00% 1 100.00%

#endif /* CONFIG_GPIO_ADP5588_IRQ */



static int adp5588_gpio_probe(struct i2c_client *client,
					const struct i2c_device_id *id)
{
	struct adp5588_gpio_platform_data *pdata =
			dev_get_platdata(&client->dev);
	struct adp5588_gpio *dev;
	struct gpio_chip *gc;
	int ret, i, revid;

	if (!pdata) {
		dev_err(&client->dev, "missing platform data\n");
		return -ENODEV;
	}

	if (!i2c_check_functionality(client->adapter,
					I2C_FUNC_SMBUS_BYTE_DATA)) {
		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
		return -EIO;
	}

	dev = devm_kzalloc(&client->dev, sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	dev->client = client;

	gc = &dev->gpio_chip;
	gc->direction_input = adp5588_gpio_direction_input;
	gc->direction_output = adp5588_gpio_direction_output;
	gc->get = adp5588_gpio_get_value;
	gc->set = adp5588_gpio_set_value;
	gc->can_sleep = true;

	gc->base = pdata->gpio_start;
	gc->ngpio = ADP5588_MAXGPIO;
	gc->label = client->name;
	gc->owner = THIS_MODULE;
	gc->names = pdata->names;

	mutex_init(&dev->lock);

	ret = adp5588_gpio_read(dev->client, DEV_ID);
	if (ret < 0)
		goto err;

	revid = ret & ADP5588_DEVICE_ID_MASK;

	for (i = 0, ret = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
		dev->dat_out[i] = adp5588_gpio_read(client, GPIO_DAT_OUT1 + i);
		dev->dir[i] = adp5588_gpio_read(client, GPIO_DIR1 + i);
		ret |= adp5588_gpio_write(client, KP_GPIO1 + i, 0);
		ret |= adp5588_gpio_write(client, GPIO_PULL1 + i,
				(pdata->pullup_dis_mask >> (8 * i)) & 0xFF);
		ret |= adp5588_gpio_write(client, GPIO_INT_EN1 + i, 0);
		if (ret)
			goto err;
	}

	if (pdata->irq_base) {
		if (WA_DELAYED_READOUT_REVID(revid)) {
			dev_warn(&client->dev, "GPIO int not supported\n");
		} else {
			ret = adp5588_irq_setup(dev);
			if (ret)
				goto err;
		}
	}

	ret = devm_gpiochip_add_data(&client->dev, &dev->gpio_chip, dev);
	if (ret)
		goto err_irq;

	dev_info(&client->dev, "IRQ Base: %d Rev.: %d\n",
			pdata->irq_base, revid);

	if (pdata->setup) {
		ret = pdata->setup(client, gc->base, gc->ngpio, pdata->context);
		if (ret < 0)
			dev_warn(&client->dev, "setup failed, %d\n", ret);
	}

	i2c_set_clientdata(client, dev);

	return 0;

err_irq:
	adp5588_irq_teardown(dev);
err:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 471 94.01% 2 20.00%
varka bhadram varka bhadram 8 1.60% 2 20.00%
jean-francois dagenais jean-francois dagenais 8 1.60% 1 10.00%
laxman dewangan laxman dewangan 6 1.20% 1 10.00%
jingoo han jingoo han 4 0.80% 1 10.00%
linus walleij linus walleij 3 0.60% 2 20.00%
grant likely grant likely 1 0.20% 1 10.00%
Total 501 100.00% 10 100.00%



static int adp5588_gpio_remove(struct i2c_client *client)
{
	struct adp5588_gpio_platform_data *pdata =
			dev_get_platdata(&client->dev);
	struct adp5588_gpio *dev = i2c_get_clientdata(client);
	int ret;

	if (pdata->teardown) {
		ret = pdata->teardown(client,
				      dev->gpio_chip.base, dev->gpio_chip.ngpio,
				      pdata->context);
		if (ret < 0) {
			dev_err(&client->dev, "teardown failed %d\n", ret);
			return ret;
		}
	}

	if (dev->irq_base)
		free_irq(dev->client->irq, dev);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 109 96.46% 2 66.67%
jingoo han jingoo han 4 3.54% 1 33.33%
Total 113 100.00% 3 100.00%


static const struct i2c_device_id adp5588_gpio_id[] = {
	{DRV_NAME, 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, adp5588_gpio_id);


static struct i2c_driver adp5588_gpio_driver = {
	.driver = {
		   .name = DRV_NAME,
                   },
	.probe = adp5588_gpio_probe,
	.remove = adp5588_gpio_remove,
	.id_table = adp5588_gpio_id,
};


module_i2c_driver(adp5588_gpio_driver);

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("GPIO ADP5588 Driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person Tokens Prop Commits CommitProp
michael hennerich michael hennerich 2149 92.83% 2 11.76%
jean-francois dagenais jean-francois dagenais 73 3.15% 2 11.76%
lennert buytenhek lennert buytenhek 43 1.86% 1 5.88%
jingoo han jingoo han 12 0.52% 1 5.88%
linus walleij linus walleij 8 0.35% 2 11.76%
varka bhadram varka bhadram 8 0.35% 2 11.76%
laxman dewangan laxman dewangan 6 0.26% 1 5.88%
axel lin axel lin 5 0.22% 2 11.76%
rob herring rob herring 4 0.17% 1 5.88%
thomas gleixner thomas gleixner 3 0.13% 1 5.88%
tejun heo tejun heo 3 0.13% 1 5.88%
grant likely grant likely 1 0.04% 1 5.88%
Total 2315 100.00% 17 100.00%
  Directory: drivers/gpio

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
michael hennerich	michael hennerich	43	100.00%	1	100.00%
	Total	43	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/gpio/gpio-adp5588.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
