gpio-adp5588.c 11.2 KB
Newer Older
1 2
/*
 * GPIO Chip driver for Analog Devices
3
 * ADP5588/ADP5587 I/O Expander and QWERTY Keypad Controller
4
 *
5
 * Copyright 2009-2010 Analog Devices Inc.
6 7 8 9 10 11
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/module.h>
#include <linux/kernel.h>
12
#include <linux/slab.h>
13 14 15
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
16 17
#include <linux/interrupt.h>
#include <linux/irq.h>
18

19
#include <linux/platform_data/adp5588.h>
20

21 22 23 24 25 26 27 28
#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)
29 30 31 32 33

struct adp5588_gpio {
	struct i2c_client *client;
	struct gpio_chip gpio_chip;
	struct mutex lock;	/* protect cached dir, dat_out */
34 35
	/* protect serialized access to the interrupt controller bus */
	struct mutex irq_lock;
36
	unsigned gpio_start;
37
	unsigned irq_base;
38 39
	uint8_t dat_out[3];
	uint8_t dir[3];
40 41 42 43
	uint8_t int_lvl[3];
	uint8_t int_en[3];
	uint8_t irq_mask[3];
	uint8_t irq_stat[3];
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
};

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;
}

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;
}

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

73 74 75 76 77 78 79 80 81 82
	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);
83 84 85 86 87 88
}

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

91 92
	bank = ADP5588_BANK(off);
	bit = ADP5588_BIT(off);
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

	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);
}

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

111
	bank = ADP5588_BANK(off);
112 113

	mutex_lock(&dev->lock);
114
	dev->dir[bank] &= ~ADP5588_BIT(off);
115 116 117 118 119 120 121 122 123 124 125
	ret = adp5588_gpio_write(dev->client, GPIO_DIR1 + bank, dev->dir[bank]);
	mutex_unlock(&dev->lock);

	return ret;
}

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

128 129
	bank = ADP5588_BANK(off);
	bit = ADP5588_BIT(off);
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147

	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;
}

148 149 150
#ifdef CONFIG_GPIO_ADP5588_IRQ
static int adp5588_gpio_to_irq(struct gpio_chip *chip, unsigned off)
{
151 152
	struct adp5588_gpio *dev = gpiochip_get_data(chip);

153 154 155
	return dev->irq_base + off;
}

156
static void adp5588_irq_bus_lock(struct irq_data *d)
157
{
158 159
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);

160 161 162 163 164 165 166 167 168 169 170
	mutex_lock(&dev->irq_lock);
}

 /*
  * 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.
  */

171
static void adp5588_irq_bus_sync_unlock(struct irq_data *d)
172
{
173
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
174 175 176 177 178 179 180 181 182 183 184 185
	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);
}

186
static void adp5588_irq_mask(struct irq_data *d)
187
{
188 189
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	unsigned gpio = d->irq - dev->irq_base;
190 191 192 193

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

194
static void adp5588_irq_unmask(struct irq_data *d)
195
{
196 197
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	unsigned gpio = d->irq - dev->irq_base;
198 199 200 201

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

202
static int adp5588_irq_set_type(struct irq_data *d, unsigned int type)
203
{
204 205
	struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
	uint16_t gpio = d->irq - dev->irq_base;
206 207 208 209
	unsigned bank, bit;

	if ((type & IRQ_TYPE_EDGE_BOTH)) {
		dev_err(&dev->client->dev, "irq %d: unsupported type %d\n",
210
			d->irq, type);
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
		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;
}

static struct irq_chip adp5588_irq_chip = {
	.name			= "adp5588",
233 234 235 236 237
	.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,
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
};

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;
}

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));

262
		for (bank = 0, bit = 0; bank <= ADP5588_BANK(ADP5588_MAXGPIO);
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
			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;
}

static int adp5588_irq_setup(struct adp5588_gpio *dev)
{
	struct i2c_client *client = dev->client;
Jingoo Han's avatar
Jingoo Han committed
286 287
	struct adp5588_gpio_platform_data *pdata =
			dev_get_platdata(&client->dev);
288 289 290 291 292 293 294 295 296 297 298 299
	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;
300 301
		irq_set_chip_data(irq, dev);
		irq_set_chip_and_handler(irq, &adp5588_irq_chip,
302
					 handle_level_irq);
303
		irq_set_nested_thread(irq, 1);
304
		irq_modify_status(irq, IRQ_NOREQUEST, IRQ_NOPROBE);
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
	}

	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;
}

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

#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;
}

static void adp5588_irq_teardown(struct adp5588_gpio *dev)
{
}
#endif /* CONFIG_GPIO_ADP5588_IRQ */

349
static int adp5588_gpio_probe(struct i2c_client *client,
350 351
					const struct i2c_device_id *id)
{
Jingoo Han's avatar
Jingoo Han committed
352 353
	struct adp5588_gpio_platform_data *pdata =
			dev_get_platdata(&client->dev);
354 355 356 357
	struct adp5588_gpio *dev;
	struct gpio_chip *gc;
	int ret, i, revid;

358
	if (!pdata) {
359 360 361 362 363 364 365 366 367 368
		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;
	}

Varka Bhadram's avatar
Varka Bhadram committed
369
	dev = devm_kzalloc(&client->dev, sizeof(*dev), GFP_KERNEL);
370
	if (!dev)
371 372 373 374 375 376 377 378 379
		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;
380
	gc->can_sleep = true;
381 382

	gc->base = pdata->gpio_start;
383
	gc->ngpio = ADP5588_MAXGPIO;
384 385
	gc->label = client->name;
	gc->owner = THIS_MODULE;
386
	gc->names = pdata->names;
387 388 389 390 391 392 393 394 395

	mutex_init(&dev->lock);

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

	revid = ret & ADP5588_DEVICE_ID_MASK;

396
	for (i = 0, ret = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
397 398 399 400 401
		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);
402
		ret |= adp5588_gpio_write(client, GPIO_INT_EN1 + i, 0);
403 404 405 406
		if (ret)
			goto err;
	}

407 408 409 410 411 412 413 414 415 416
	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;
		}
	}

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

421 422
	dev_info(&client->dev, "IRQ Base: %d Rev.: %d\n",
			pdata->irq_base, revid);
423 424 425 426 427 428 429 430

	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);
431

432 433
	return 0;

434 435
err_irq:
	adp5588_irq_teardown(dev);
436 437 438 439
err:
	return ret;
}

440
static int adp5588_gpio_remove(struct i2c_client *client)
441
{
Jingoo Han's avatar
Jingoo Han committed
442 443
	struct adp5588_gpio_platform_data *pdata =
			dev_get_platdata(&client->dev);
444 445 446 447 448 449 450 451 452 453 454 455 456
	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;
		}
	}

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

460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
	return 0;
}

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,
475
	.remove = adp5588_gpio_remove,
476 477 478
	.id_table = adp5588_gpio_id,
};

479
module_i2c_driver(adp5588_gpio_driver);
480 481 482 483

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("GPIO ADP5588 Driver");
MODULE_LICENSE("GPL");