gpio-mcp23s08.c 24.3 KB
Newer Older
1
/*
2 3 4 5 6 7 8 9 10
 * MCP23S08 SPI/I2C GPIO gpio expander driver
 *
 * The inputs and outputs of the mcp23s08, mcp23s17, mcp23008 and mcp23017 are
 * supported.
 * For the I2C versions of the chips (mcp23008 and mcp23017) generation of
 * interrupts is also supported.
 * The hardware of the SPI versions of the chips (mcp23s08 and mcp23s17) is
 * also capable of generating interrupts, but the linux driver does not
 * support that yet.
11 12 13 14 15
 */

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/mutex.h>
16
#include <linux/module.h>
17
#include <linux/gpio.h>
P
Peter Korsgaard 已提交
18
#include <linux/i2c.h>
19 20
#include <linux/spi/spi.h>
#include <linux/spi/mcp23s08.h>
21
#include <linux/slab.h>
22
#include <asm/byteorder.h>
23 24
#include <linux/interrupt.h>
#include <linux/of_irq.h>
25
#include <linux/of_device.h>
26

27 28 29 30 31
/**
 * MCP types supported by driver
 */
#define MCP_TYPE_S08	0
#define MCP_TYPE_S17	1
P
Peter Korsgaard 已提交
32 33
#define MCP_TYPE_008	2
#define MCP_TYPE_017	3
34
#define MCP_TYPE_S18    4
35 36 37 38 39 40 41 42 43 44 45 46

/* Registers are all 8 bits wide.
 *
 * The mcp23s17 has twice as many bits, and can be configured to work
 * with either 16 bit registers or with two adjacent 8 bit banks.
 */
#define MCP_IODIR	0x00		/* init/reset:  all ones */
#define MCP_IPOL	0x01
#define MCP_GPINTEN	0x02
#define MCP_DEFVAL	0x03
#define MCP_INTCON	0x04
#define MCP_IOCON	0x05
47
#	define IOCON_MIRROR	(1 << 6)
48 49 50 51
#	define IOCON_SEQOP	(1 << 5)
#	define IOCON_HAEN	(1 << 3)
#	define IOCON_ODR	(1 << 2)
#	define IOCON_INTPOL	(1 << 1)
52
#	define IOCON_INTCC	(1)
53 54 55 56 57 58
#define MCP_GPPU	0x06
#define MCP_INTF	0x07
#define MCP_INTCAP	0x08
#define MCP_GPIO	0x09
#define MCP_OLAT	0x0a

59 60 61 62 63 64 65 66 67
struct mcp23s08;

struct mcp23s08_ops {
	int	(*read)(struct mcp23s08 *mcp, unsigned reg);
	int	(*write)(struct mcp23s08 *mcp, unsigned reg, unsigned val);
	int	(*read_regs)(struct mcp23s08 *mcp, unsigned reg,
			     u16 *vals, unsigned n);
};

68 69
struct mcp23s08 {
	u8			addr;
70
	bool			irq_active_high;
71

72
	u16			cache[11];
73 74 75 76
	u16			irq_rise;
	u16			irq_fall;
	int			irq;
	bool			irq_controller;
77 78
	/* lock protects the cached values */
	struct mutex		lock;
79
	struct mutex		irq_lock;
80 81 82

	struct gpio_chip	chip;

83
	const struct mcp23s08_ops	*ops;
84
	void			*data; /* ops specific data */
85 86
};

87
/* A given spi_device can represent up to eight mcp23sxx chips
88 89 90 91 92 93
 * sharing the same chipselect but using different addresses
 * (e.g. chips #0 and #3 might be populated, but not #1 or $2).
 * Driver data holds all the per-chip data.
 */
struct mcp23s08_driver_data {
	unsigned		ngpio;
94
	struct mcp23s08		*mcp[8];
95 96 97
	struct mcp23s08		chip[];
};

P
Peter Korsgaard 已提交
98 99
/*----------------------------------------------------------------------*/

100
#if IS_ENABLED(CONFIG_I2C)
P
Peter Korsgaard 已提交
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163

static int mcp23008_read(struct mcp23s08 *mcp, unsigned reg)
{
	return i2c_smbus_read_byte_data(mcp->data, reg);
}

static int mcp23008_write(struct mcp23s08 *mcp, unsigned reg, unsigned val)
{
	return i2c_smbus_write_byte_data(mcp->data, reg, val);
}

static int
mcp23008_read_regs(struct mcp23s08 *mcp, unsigned reg, u16 *vals, unsigned n)
{
	while (n--) {
		int ret = mcp23008_read(mcp, reg++);
		if (ret < 0)
			return ret;
		*vals++ = ret;
	}

	return 0;
}

static int mcp23017_read(struct mcp23s08 *mcp, unsigned reg)
{
	return i2c_smbus_read_word_data(mcp->data, reg << 1);
}

static int mcp23017_write(struct mcp23s08 *mcp, unsigned reg, unsigned val)
{
	return i2c_smbus_write_word_data(mcp->data, reg << 1, val);
}

static int
mcp23017_read_regs(struct mcp23s08 *mcp, unsigned reg, u16 *vals, unsigned n)
{
	while (n--) {
		int ret = mcp23017_read(mcp, reg++);
		if (ret < 0)
			return ret;
		*vals++ = ret;
	}

	return 0;
}

static const struct mcp23s08_ops mcp23008_ops = {
	.read		= mcp23008_read,
	.write		= mcp23008_write,
	.read_regs	= mcp23008_read_regs,
};

static const struct mcp23s08_ops mcp23017_ops = {
	.read		= mcp23017_read,
	.write		= mcp23017_write,
	.read_regs	= mcp23017_read_regs,
};

#endif /* CONFIG_I2C */

/*----------------------------------------------------------------------*/

164 165
#ifdef CONFIG_SPI_MASTER

166 167 168 169 170 171 172
static int mcp23s08_read(struct mcp23s08 *mcp, unsigned reg)
{
	u8	tx[2], rx[1];
	int	status;

	tx[0] = mcp->addr | 0x01;
	tx[1] = reg;
173
	status = spi_write_then_read(mcp->data, tx, sizeof(tx), rx, sizeof(rx));
174 175 176
	return (status < 0) ? status : rx[0];
}

177
static int mcp23s08_write(struct mcp23s08 *mcp, unsigned reg, unsigned val)
178 179 180 181 182 183
{
	u8	tx[3];

	tx[0] = mcp->addr;
	tx[1] = reg;
	tx[2] = val;
184
	return spi_write_then_read(mcp->data, tx, sizeof(tx), NULL, 0);
185 186 187
}

static int
188
mcp23s08_read_regs(struct mcp23s08 *mcp, unsigned reg, u16 *vals, unsigned n)
189
{
190 191
	u8	tx[2], *tmp;
	int	status;
192

193
	if ((n + reg) > sizeof(mcp->cache))
194 195 196
		return -EINVAL;
	tx[0] = mcp->addr | 0x01;
	tx[1] = reg;
197 198

	tmp = (u8 *)vals;
199
	status = spi_write_then_read(mcp->data, tx, sizeof(tx), tmp, n);
200 201 202 203 204 205 206 207 208 209 210 211 212 213
	if (status >= 0) {
		while (n--)
			vals[n] = tmp[n]; /* expand to 16bit */
	}
	return status;
}

static int mcp23s17_read(struct mcp23s08 *mcp, unsigned reg)
{
	u8	tx[2], rx[2];
	int	status;

	tx[0] = mcp->addr | 0x01;
	tx[1] = reg << 1;
214
	status = spi_write_then_read(mcp->data, tx, sizeof(tx), rx, sizeof(rx));
215 216 217 218 219 220 221 222 223 224 225
	return (status < 0) ? status : (rx[0] | (rx[1] << 8));
}

static int mcp23s17_write(struct mcp23s08 *mcp, unsigned reg, unsigned val)
{
	u8	tx[4];

	tx[0] = mcp->addr;
	tx[1] = reg << 1;
	tx[2] = val;
	tx[3] = val >> 8;
226
	return spi_write_then_read(mcp->data, tx, sizeof(tx), NULL, 0);
227 228 229 230 231 232 233 234
}

static int
mcp23s17_read_regs(struct mcp23s08 *mcp, unsigned reg, u16 *vals, unsigned n)
{
	u8	tx[2];
	int	status;

235
	if ((n + reg) > sizeof(mcp->cache))
236 237 238 239
		return -EINVAL;
	tx[0] = mcp->addr | 0x01;
	tx[1] = reg << 1;

240
	status = spi_write_then_read(mcp->data, tx, sizeof(tx),
241 242 243 244 245 246 247
				     (u8 *)vals, n * 2);
	if (status >= 0) {
		while (n--)
			vals[n] = __le16_to_cpu((__le16)vals[n]);
	}

	return status;
248 249
}

250 251 252 253 254 255 256 257 258 259 260 261
static const struct mcp23s08_ops mcp23s08_ops = {
	.read		= mcp23s08_read,
	.write		= mcp23s08_write,
	.read_regs	= mcp23s08_read_regs,
};

static const struct mcp23s08_ops mcp23s17_ops = {
	.read		= mcp23s17_read,
	.write		= mcp23s17_write,
	.read_regs	= mcp23s17_read_regs,
};

262
#endif /* CONFIG_SPI_MASTER */
263

264 265 266 267
/*----------------------------------------------------------------------*/

static int mcp23s08_direction_input(struct gpio_chip *chip, unsigned offset)
{
268
	struct mcp23s08	*mcp = gpiochip_get_data(chip);
269 270 271 272
	int status;

	mutex_lock(&mcp->lock);
	mcp->cache[MCP_IODIR] |= (1 << offset);
273
	status = mcp->ops->write(mcp, MCP_IODIR, mcp->cache[MCP_IODIR]);
274 275 276 277 278 279
	mutex_unlock(&mcp->lock);
	return status;
}

static int mcp23s08_get(struct gpio_chip *chip, unsigned offset)
{
280
	struct mcp23s08	*mcp = gpiochip_get_data(chip);
281 282 283 284 285
	int status;

	mutex_lock(&mcp->lock);

	/* REVISIT reading this clears any IRQ ... */
286
	status = mcp->ops->read(mcp, MCP_GPIO);
287 288 289 290 291 292 293 294 295 296 297 298
	if (status < 0)
		status = 0;
	else {
		mcp->cache[MCP_GPIO] = status;
		status = !!(status & (1 << offset));
	}
	mutex_unlock(&mcp->lock);
	return status;
}

static int __mcp23s08_set(struct mcp23s08 *mcp, unsigned mask, int value)
{
299
	unsigned olat = mcp->cache[MCP_OLAT];
300 301 302 303 304 305

	if (value)
		olat |= mask;
	else
		olat &= ~mask;
	mcp->cache[MCP_OLAT] = olat;
306
	return mcp->ops->write(mcp, MCP_OLAT, olat);
307 308 309 310
}

static void mcp23s08_set(struct gpio_chip *chip, unsigned offset, int value)
{
311
	struct mcp23s08	*mcp = gpiochip_get_data(chip);
312
	unsigned mask = 1 << offset;
313 314 315 316 317 318 319 320 321

	mutex_lock(&mcp->lock);
	__mcp23s08_set(mcp, mask, value);
	mutex_unlock(&mcp->lock);
}

static int
mcp23s08_direction_output(struct gpio_chip *chip, unsigned offset, int value)
{
322
	struct mcp23s08	*mcp = gpiochip_get_data(chip);
323
	unsigned mask = 1 << offset;
324 325 326 327 328 329
	int status;

	mutex_lock(&mcp->lock);
	status = __mcp23s08_set(mcp, mask, value);
	if (status == 0) {
		mcp->cache[MCP_IODIR] &= ~mask;
330
		status = mcp->ops->write(mcp, MCP_IODIR, mcp->cache[MCP_IODIR]);
331 332 333 334 335
	}
	mutex_unlock(&mcp->lock);
	return status;
}

336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
/*----------------------------------------------------------------------*/
static irqreturn_t mcp23s08_irq(int irq, void *data)
{
	struct mcp23s08 *mcp = data;
	int intcap, intf, i;
	unsigned int child_irq;

	mutex_lock(&mcp->lock);
	intf = mcp->ops->read(mcp, MCP_INTF);
	if (intf < 0) {
		mutex_unlock(&mcp->lock);
		return IRQ_HANDLED;
	}

	mcp->cache[MCP_INTF] = intf;

	intcap = mcp->ops->read(mcp, MCP_INTCAP);
	if (intcap < 0) {
		mutex_unlock(&mcp->lock);
		return IRQ_HANDLED;
	}

	mcp->cache[MCP_INTCAP] = intcap;
	mutex_unlock(&mcp->lock);


	for (i = 0; i < mcp->chip.ngpio; i++) {
		if ((BIT(i) & mcp->cache[MCP_INTF]) &&
		    ((BIT(i) & intcap & mcp->irq_rise) ||
		     (mcp->irq_fall & ~intcap & BIT(i)))) {
366
			child_irq = irq_find_mapping(mcp->chip.irqdomain, i);
367 368 369 370 371 372 373 374 375
			handle_nested_irq(child_irq);
		}
	}

	return IRQ_HANDLED;
}

static void mcp23s08_irq_mask(struct irq_data *data)
{
376 377
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
378 379 380 381 382 383 384
	unsigned int pos = data->hwirq;

	mcp->cache[MCP_GPINTEN] &= ~BIT(pos);
}

static void mcp23s08_irq_unmask(struct irq_data *data)
{
385 386
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
387 388 389 390 391 392 393
	unsigned int pos = data->hwirq;

	mcp->cache[MCP_GPINTEN] |= BIT(pos);
}

static int mcp23s08_irq_set_type(struct irq_data *data, unsigned int type)
{
394 395
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
	unsigned int pos = data->hwirq;
	int status = 0;

	if ((type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
		mcp->cache[MCP_INTCON] &= ~BIT(pos);
		mcp->irq_rise |= BIT(pos);
		mcp->irq_fall |= BIT(pos);
	} else if (type & IRQ_TYPE_EDGE_RISING) {
		mcp->cache[MCP_INTCON] &= ~BIT(pos);
		mcp->irq_rise |= BIT(pos);
		mcp->irq_fall &= ~BIT(pos);
	} else if (type & IRQ_TYPE_EDGE_FALLING) {
		mcp->cache[MCP_INTCON] &= ~BIT(pos);
		mcp->irq_rise &= ~BIT(pos);
		mcp->irq_fall |= BIT(pos);
	} else
		return -EINVAL;

	return status;
}

static void mcp23s08_irq_bus_lock(struct irq_data *data)
{
419 420
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
421 422 423 424 425 426

	mutex_lock(&mcp->irq_lock);
}

static void mcp23s08_irq_bus_unlock(struct irq_data *data)
{
427 428
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
429 430 431 432 433 434 435 436 437

	mutex_lock(&mcp->lock);
	mcp->ops->write(mcp, MCP_GPINTEN, mcp->cache[MCP_GPINTEN]);
	mcp->ops->write(mcp, MCP_DEFVAL, mcp->cache[MCP_DEFVAL]);
	mcp->ops->write(mcp, MCP_INTCON, mcp->cache[MCP_INTCON]);
	mutex_unlock(&mcp->lock);
	mutex_unlock(&mcp->irq_lock);
}

438
static int mcp23s08_irq_reqres(struct irq_data *data)
439
{
440 441
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
442

443
	if (gpiochip_lock_as_irq(&mcp->chip, data->hwirq)) {
444
		dev_err(mcp->chip.parent,
445 446
			"unable to lock HW IRQ %lu for IRQ usage\n",
			data->hwirq);
447 448
		return -EINVAL;
	}
449 450 451 452

	return 0;
}

453
static void mcp23s08_irq_relres(struct irq_data *data)
454
{
455 456
	struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
	struct mcp23s08 *mcp = gpiochip_get_data(gc);
457

458
	gpiochip_unlock_as_irq(&mcp->chip, data->hwirq);
459 460 461 462 463 464 465 466 467
}

static struct irq_chip mcp23s08_irq_chip = {
	.name = "gpio-mcp23xxx",
	.irq_mask = mcp23s08_irq_mask,
	.irq_unmask = mcp23s08_irq_unmask,
	.irq_set_type = mcp23s08_irq_set_type,
	.irq_bus_lock = mcp23s08_irq_bus_lock,
	.irq_bus_sync_unlock = mcp23s08_irq_bus_unlock,
468 469
	.irq_request_resources = mcp23s08_irq_reqres,
	.irq_release_resources = mcp23s08_irq_relres,
470 471 472 473 474
};

static int mcp23s08_irq_setup(struct mcp23s08 *mcp)
{
	struct gpio_chip *chip = &mcp->chip;
475
	int err;
476
	unsigned long irqflags = IRQF_ONESHOT | IRQF_SHARED;
477 478 479

	mutex_init(&mcp->irq_lock);

480 481 482 483 484
	if (mcp->irq_active_high)
		irqflags |= IRQF_TRIGGER_HIGH;
	else
		irqflags |= IRQF_TRIGGER_LOW;

485 486 487
	err = devm_request_threaded_irq(chip->parent, mcp->irq, NULL,
					mcp23s08_irq,
					irqflags, dev_name(chip->parent), mcp);
488
	if (err != 0) {
489
		dev_err(chip->parent, "unable to request IRQ#%d: %d\n",
490 491 492 493
			mcp->irq, err);
		return err;
	}

494 495 496 497 498 499 500 501 502
	err =  gpiochip_irqchip_add(chip,
				    &mcp23s08_irq_chip,
				    0,
				    handle_simple_irq,
				    IRQ_TYPE_NONE);
	if (err) {
		dev_err(chip->parent,
			"could not connect irqchip to gpiochip: %d\n", err);
		return err;
503 504
	}

505 506 507 508
	gpiochip_set_chained_irqchip(chip,
				     &mcp23s08_irq_chip,
				     mcp->irq,
				     NULL);
509

510
	return 0;
511 512
}

513 514 515 516 517 518 519 520 521 522 523 524 525 526
/*----------------------------------------------------------------------*/

#ifdef CONFIG_DEBUG_FS

#include <linux/seq_file.h>

/*
 * This shows more info than the generic gpio dump code:
 * pullups, deglitching, open drain drive.
 */
static void mcp23s08_dbg_show(struct seq_file *s, struct gpio_chip *chip)
{
	struct mcp23s08	*mcp;
	char		bank;
R
Roel Kluin 已提交
527
	int		t;
528 529
	unsigned	mask;

530
	mcp = gpiochip_get_data(chip);
531 532

	/* NOTE: we only handle one bank for now ... */
533
	bank = '0' + ((mcp->addr >> 1) & 0x7);
534 535

	mutex_lock(&mcp->lock);
536
	t = mcp->ops->read_regs(mcp, 0, mcp->cache, ARRAY_SIZE(mcp->cache));
537 538 539 540 541
	if (t < 0) {
		seq_printf(s, " I/O ERROR %d\n", t);
		goto done;
	}

542
	for (t = 0, mask = 1; t < chip->ngpio; t++, mask <<= 1) {
543 544 545 546 547 548 549 550 551 552
		const char	*label;

		label = gpiochip_is_requested(chip, t);
		if (!label)
			continue;

		seq_printf(s, " gpio-%-3d P%c.%d (%-12s) %s %s %s",
			chip->base + t, bank, t, label,
			(mcp->cache[MCP_IODIR] & mask) ? "in " : "out",
			(mcp->cache[MCP_GPIO] & mask) ? "hi" : "lo",
553
			(mcp->cache[MCP_GPPU] & mask) ? "up" : "  ");
554
		/* NOTE:  ignoring the irq-related registers */
555
		seq_puts(s, "\n");
556 557 558 559 560 561 562 563 564 565 566
	}
done:
	mutex_unlock(&mcp->lock);
}

#else
#define mcp23s08_dbg_show	NULL
#endif

/*----------------------------------------------------------------------*/

567
static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
568
			      void *data, unsigned addr, unsigned type,
569
			      struct mcp23s08_platform_data *pdata, int cs)
570
{
571
	int status;
572
	bool mirror = false;
573 574 575

	mutex_init(&mcp->lock);

576 577
	mcp->data = data;
	mcp->addr = addr;
578
	mcp->irq_active_high = false;
579 580 581 582 583 584

	mcp->chip.direction_input = mcp23s08_direction_input;
	mcp->chip.get = mcp23s08_get;
	mcp->chip.direction_output = mcp23s08_direction_output;
	mcp->chip.set = mcp23s08_set;
	mcp->chip.dbg_show = mcp23s08_dbg_show;
585 586 587 588
#ifdef CONFIG_OF
	mcp->chip.of_gpio_n_cells = 2;
	mcp->chip.of_node = dev->of_node;
#endif
589

590 591 592
	switch (type) {
#ifdef CONFIG_SPI_MASTER
	case MCP_TYPE_S08:
593 594 595
		mcp->ops = &mcp23s08_ops;
		mcp->chip.ngpio = 8;
		mcp->chip.label = "mcp23s08";
596 597 598 599 600 601 602
		break;

	case MCP_TYPE_S17:
		mcp->ops = &mcp23s17_ops;
		mcp->chip.ngpio = 16;
		mcp->chip.label = "mcp23s17";
		break;
603 604 605 606 607 608

	case MCP_TYPE_S18:
		mcp->ops = &mcp23s17_ops;
		mcp->chip.ngpio = 16;
		mcp->chip.label = "mcp23s18";
		break;
609 610
#endif /* CONFIG_SPI_MASTER */

611
#if IS_ENABLED(CONFIG_I2C)
P
Peter Korsgaard 已提交
612 613 614 615 616 617 618 619 620 621 622 623 624
	case MCP_TYPE_008:
		mcp->ops = &mcp23008_ops;
		mcp->chip.ngpio = 8;
		mcp->chip.label = "mcp23008";
		break;

	case MCP_TYPE_017:
		mcp->ops = &mcp23017_ops;
		mcp->chip.ngpio = 16;
		mcp->chip.label = "mcp23017";
		break;
#endif /* CONFIG_I2C */

625 626 627
	default:
		dev_err(dev, "invalid device type (%d)\n", type);
		return -EINVAL;
628
	}
629

630
	mcp->chip.base = pdata->base;
631
	mcp->chip.can_sleep = true;
632
	mcp->chip.parent = dev;
633
	mcp->chip.owner = THIS_MODULE;
634

635 636 637
	/* verify MCP_IOCON.SEQOP = 0, so sequential reads work,
	 * and MCP_IOCON.HAEN = 1, so we work with all chips.
	 */
638

639
	status = mcp->ops->read(mcp, MCP_IOCON);
640 641
	if (status < 0)
		goto fail;
642

643
	mcp->irq_controller = pdata->irq_controller;
644
	if (mcp->irq && mcp->irq_controller) {
645
		mcp->irq_active_high =
646
			of_property_read_bool(mcp->chip.parent->of_node,
647
					      "microchip,irq-active-high");
648

649
		mirror = pdata->mirror;
650 651 652 653
	}

	if ((status & IOCON_SEQOP) || !(status & IOCON_HAEN) || mirror ||
	     mcp->irq_active_high) {
654 655 656
		/* mcp23s17 has IOCON twice, make sure they are in sync */
		status &= ~(IOCON_SEQOP | (IOCON_SEQOP << 8));
		status |= IOCON_HAEN | (IOCON_HAEN << 8);
657 658 659 660 661
		if (mcp->irq_active_high)
			status |= IOCON_INTPOL | (IOCON_INTPOL << 8);
		else
			status &= ~(IOCON_INTPOL | (IOCON_INTPOL << 8));

662 663 664
		if (mirror)
			status |= IOCON_MIRROR | (IOCON_MIRROR << 8);

665 666 667
		if (type == MCP_TYPE_S18)
			status |= IOCON_INTCC | (IOCON_INTCC << 8);

668
		status = mcp->ops->write(mcp, MCP_IOCON, status);
669 670 671 672 673
		if (status < 0)
			goto fail;
	}

	/* configure ~100K pullups */
674
	status = mcp->ops->write(mcp, MCP_GPPU, pdata->chip[cs].pullups);
675 676 677
	if (status < 0)
		goto fail;

678
	status = mcp->ops->read_regs(mcp, 0, mcp->cache, ARRAY_SIZE(mcp->cache));
679 680 681 682 683 684
	if (status < 0)
		goto fail;

	/* disable inverter on input */
	if (mcp->cache[MCP_IPOL] != 0) {
		mcp->cache[MCP_IPOL] = 0;
685 686 687
		status = mcp->ops->write(mcp, MCP_IPOL, 0);
		if (status < 0)
			goto fail;
688 689 690 691 692
	}

	/* disable irqs */
	if (mcp->cache[MCP_GPINTEN] != 0) {
		mcp->cache[MCP_GPINTEN] = 0;
693
		status = mcp->ops->write(mcp, MCP_GPINTEN, 0);
694 695
		if (status < 0)
			goto fail;
696 697
	}

698
	status = gpiochip_add_data(&mcp->chip, mcp);
699 700 701 702 703 704 705 706 707
	if (status < 0)
		goto fail;

	if (mcp->irq && mcp->irq_controller) {
		status = mcp23s08_irq_setup(mcp);
		if (status) {
			goto fail;
		}
	}
708 709
fail:
	if (status < 0)
710 711
		dev_dbg(dev, "can't setup chip %d, --> %d\n",
			addr, status);
712 713 714
	return status;
}

P
Peter Korsgaard 已提交
715 716
/*----------------------------------------------------------------------*/

717 718
#ifdef CONFIG_OF
#ifdef CONFIG_SPI_MASTER
719
static const struct of_device_id mcp23s08_spi_of_match[] = {
720
	{
721 722
		.compatible = "microchip,mcp23s08",
		.data = (void *) MCP_TYPE_S08,
723 724
	},
	{
725 726 727
		.compatible = "microchip,mcp23s17",
		.data = (void *) MCP_TYPE_S17,
	},
728 729 730 731
	{
		.compatible = "microchip,mcp23s18",
		.data = (void *) MCP_TYPE_S18,
	},
732 733 734 735 736 737 738 739
/* NOTE: The use of the mcp prefix is deprecated and will be removed. */
	{
		.compatible = "mcp,mcp23s08",
		.data = (void *) MCP_TYPE_S08,
	},
	{
		.compatible = "mcp,mcp23s17",
		.data = (void *) MCP_TYPE_S17,
740 741 742 743 744 745 746
	},
	{ },
};
MODULE_DEVICE_TABLE(of, mcp23s08_spi_of_match);
#endif

#if IS_ENABLED(CONFIG_I2C)
747
static const struct of_device_id mcp23s08_i2c_of_match[] = {
748
	{
749 750
		.compatible = "microchip,mcp23008",
		.data = (void *) MCP_TYPE_008,
751 752
	},
	{
753 754 755 756 757 758 759 760 761 762 763
		.compatible = "microchip,mcp23017",
		.data = (void *) MCP_TYPE_017,
	},
/* NOTE: The use of the mcp prefix is deprecated and will be removed. */
	{
		.compatible = "mcp,mcp23008",
		.data = (void *) MCP_TYPE_008,
	},
	{
		.compatible = "mcp,mcp23017",
		.data = (void *) MCP_TYPE_017,
764 765 766 767 768 769 770 771
	},
	{ },
};
MODULE_DEVICE_TABLE(of, mcp23s08_i2c_of_match);
#endif
#endif /* CONFIG_OF */


772
#if IS_ENABLED(CONFIG_I2C)
P
Peter Korsgaard 已提交
773

B
Bill Pemberton 已提交
774
static int mcp230xx_probe(struct i2c_client *client,
P
Peter Korsgaard 已提交
775 776
				    const struct i2c_device_id *id)
{
777
	struct mcp23s08_platform_data *pdata, local_pdata;
P
Peter Korsgaard 已提交
778
	struct mcp23s08 *mcp;
779
	int status;
780 781 782 783
	const struct of_device_id *match;

	match = of_match_device(of_match_ptr(mcp23s08_i2c_of_match),
					&client->dev);
784 785 786 787 788 789 790 791 792
	if (match) {
		pdata = &local_pdata;
		pdata->base = -1;
		pdata->chip[0].pullups = 0;
		pdata->irq_controller =	of_property_read_bool(
					client->dev.of_node,
					"interrupt-controller");
		pdata->mirror = of_property_read_bool(client->dev.of_node,
						      "microchip,irq-mirror");
793
		client->irq = irq_of_parse_and_map(client->dev.of_node, 0);
794
	} else {
795
		pdata = dev_get_platdata(&client->dev);
796 797 798 799
		if (!pdata) {
			pdata = devm_kzalloc(&client->dev,
					sizeof(struct mcp23s08_platform_data),
					GFP_KERNEL);
800 801
			if (!pdata)
				return -ENOMEM;
802
			pdata->base = -1;
803
		}
P
Peter Korsgaard 已提交
804 805
	}

806
	mcp = kzalloc(sizeof(*mcp), GFP_KERNEL);
P
Peter Korsgaard 已提交
807 808 809
	if (!mcp)
		return -ENOMEM;

810
	mcp->irq = client->irq;
P
Peter Korsgaard 已提交
811
	status = mcp23s08_probe_one(mcp, &client->dev, client, client->addr,
812
				    id->driver_data, pdata, 0);
P
Peter Korsgaard 已提交
813 814 815 816 817 818 819 820 821 822 823 824 825
	if (status)
		goto fail;

	i2c_set_clientdata(client, mcp);

	return 0;

fail:
	kfree(mcp);

	return status;
}

B
Bill Pemberton 已提交
826
static int mcp230xx_remove(struct i2c_client *client)
P
Peter Korsgaard 已提交
827 828 829
{
	struct mcp23s08 *mcp = i2c_get_clientdata(client);

830 831
	gpiochip_remove(&mcp->chip);
	kfree(mcp);
P
Peter Korsgaard 已提交
832

833
	return 0;
P
Peter Korsgaard 已提交
834 835 836 837 838 839 840 841 842 843 844 845
}

static const struct i2c_device_id mcp230xx_id[] = {
	{ "mcp23008", MCP_TYPE_008 },
	{ "mcp23017", MCP_TYPE_017 },
	{ },
};
MODULE_DEVICE_TABLE(i2c, mcp230xx_id);

static struct i2c_driver mcp230xx_driver = {
	.driver = {
		.name	= "mcp230xx",
846
		.of_match_table = of_match_ptr(mcp23s08_i2c_of_match),
P
Peter Korsgaard 已提交
847 848
	},
	.probe		= mcp230xx_probe,
B
Bill Pemberton 已提交
849
	.remove		= mcp230xx_remove,
P
Peter Korsgaard 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
	.id_table	= mcp230xx_id,
};

static int __init mcp23s08_i2c_init(void)
{
	return i2c_add_driver(&mcp230xx_driver);
}

static void mcp23s08_i2c_exit(void)
{
	i2c_del_driver(&mcp230xx_driver);
}

#else

static int __init mcp23s08_i2c_init(void) { return 0; }
static void mcp23s08_i2c_exit(void) { }

#endif /* CONFIG_I2C */

/*----------------------------------------------------------------------*/

872 873
#ifdef CONFIG_SPI_MASTER

874 875
static int mcp23s08_probe(struct spi_device *spi)
{
876
	struct mcp23s08_platform_data	*pdata, local_pdata;
877
	unsigned			addr;
878
	int				chips = 0;
879
	struct mcp23s08_driver_data	*data;
880
	int				status, type;
881
	unsigned			ngpio = 0;
882 883 884 885 886
	const struct			of_device_id *match;
	u32				spi_present_mask = 0;

	match = of_match_device(of_match_ptr(mcp23s08_spi_of_match), &spi->dev);
	if (match) {
887
		type = (int)(uintptr_t)match->data;
888
		status = of_property_read_u32(spi->dev.of_node,
889
			    "microchip,spi-present-mask", &spi_present_mask);
890
		if (status) {
891 892 893 894 895 896 897
			status = of_property_read_u32(spi->dev.of_node,
				    "mcp,spi-present-mask", &spi_present_mask);
			if (status) {
				dev_err(&spi->dev,
					"DT has no spi-present-mask\n");
				return -ENODEV;
			}
898 899 900 901 902
		}
		if ((spi_present_mask <= 0) || (spi_present_mask >= 256)) {
			dev_err(&spi->dev, "invalid spi-present-mask\n");
			return -ENODEV;
		}
903

904 905
		pdata = &local_pdata;
		pdata->base = -1;
906
		for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
907
			pdata->chip[addr].pullups = 0;
908 909
			if (spi_present_mask & (1 << addr))
				chips++;
910
		}
911 912 913 914 915
		pdata->irq_controller =	of_property_read_bool(
					spi->dev.of_node,
					"interrupt-controller");
		pdata->mirror = of_property_read_bool(spi->dev.of_node,
						      "microchip,irq-mirror");
916 917
	} else {
		type = spi_get_device_id(spi)->driver_data;
J
Jingoo Han 已提交
918
		pdata = dev_get_platdata(&spi->dev);
919 920 921 922 923
		if (!pdata) {
			pdata = devm_kzalloc(&spi->dev,
					sizeof(struct mcp23s08_platform_data),
					GFP_KERNEL);
			pdata->base = -1;
924
		}
925 926 927 928 929 930 931 932 933 934 935 936

		for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
			if (!pdata->chip[addr].is_present)
				continue;
			chips++;
			if ((type == MCP_TYPE_S08) && (addr > 3)) {
				dev_err(&spi->dev,
					"mcp23s08 only supports address 0..3\n");
				return -EINVAL;
			}
			spi_present_mask |= 1 << addr;
		}
937 938
	}

939 940 941
	if (!chips)
		return -ENODEV;

V
Varka Bhadram 已提交
942 943 944
	data = devm_kzalloc(&spi->dev,
			    sizeof(*data) + chips * sizeof(struct mcp23s08),
			    GFP_KERNEL);
945 946
	if (!data)
		return -ENOMEM;
V
Varka Bhadram 已提交
947

948 949
	spi_set_drvdata(spi, data);

950 951
	spi->irq = irq_of_parse_and_map(spi->dev.of_node, 0);

952
	for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
953
		if (!(spi_present_mask & (1 << addr)))
954 955 956
			continue;
		chips--;
		data->mcp[addr] = &data->chip[chips];
957
		data->mcp[addr]->irq = spi->irq;
958
		status = mcp23s08_probe_one(data->mcp[addr], &spi->dev, spi,
959 960
					    0x40 | (addr << 1), type, pdata,
					    addr);
961 962
		if (status < 0)
			goto fail;
963

964
		if (pdata->base != -1)
965 966
			pdata->base += data->mcp[addr]->chip.ngpio;
		ngpio += data->mcp[addr]->chip.ngpio;
967
	}
968
	data->ngpio = ngpio;
969 970 971 972 973 974 975 976 977

	/* NOTE:  these chips have a relatively sane IRQ framework, with
	 * per-signal masking and level/edge triggering.  It's not yet
	 * handled here...
	 */

	return 0;

fail:
978
	for (addr = 0; addr < ARRAY_SIZE(data->mcp); addr++) {
979 980 981

		if (!data->mcp[addr])
			continue;
982
		gpiochip_remove(&data->mcp[addr]->chip);
983
	}
984 985 986 987 988
	return status;
}

static int mcp23s08_remove(struct spi_device *spi)
{
989 990
	struct mcp23s08_driver_data	*data = spi_get_drvdata(spi);
	unsigned			addr;
991

992
	for (addr = 0; addr < ARRAY_SIZE(data->mcp); addr++) {
993 994 995 996

		if (!data->mcp[addr])
			continue;

997
		gpiochip_remove(&data->mcp[addr]->chip);
998
	}
999

1000
	return 0;
1001 1002
}

1003 1004 1005
static const struct spi_device_id mcp23s08_ids[] = {
	{ "mcp23s08", MCP_TYPE_S08 },
	{ "mcp23s17", MCP_TYPE_S17 },
1006
	{ "mcp23s18", MCP_TYPE_S18 },
1007 1008 1009 1010
	{ },
};
MODULE_DEVICE_TABLE(spi, mcp23s08_ids);

1011 1012 1013
static struct spi_driver mcp23s08_driver = {
	.probe		= mcp23s08_probe,
	.remove		= mcp23s08_remove,
1014
	.id_table	= mcp23s08_ids,
1015 1016
	.driver = {
		.name	= "mcp23s08",
1017
		.of_match_table = of_match_ptr(mcp23s08_spi_of_match),
1018 1019 1020
	},
};

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
static int __init mcp23s08_spi_init(void)
{
	return spi_register_driver(&mcp23s08_driver);
}

static void mcp23s08_spi_exit(void)
{
	spi_unregister_driver(&mcp23s08_driver);
}

#else

static int __init mcp23s08_spi_init(void) { return 0; }
static void mcp23s08_spi_exit(void) { }

#endif /* CONFIG_SPI_MASTER */

1038 1039 1040 1041
/*----------------------------------------------------------------------*/

static int __init mcp23s08_init(void)
{
P
Peter Korsgaard 已提交
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
	int ret;

	ret = mcp23s08_spi_init();
	if (ret)
		goto spi_fail;

	ret = mcp23s08_i2c_init();
	if (ret)
		goto i2c_fail;

	return 0;

 i2c_fail:
	mcp23s08_spi_exit();
 spi_fail:
	return ret;
1058
}
P
Peter Korsgaard 已提交
1059
/* register after spi/i2c postcore initcall and before
1060 1061 1062
 * subsys initcalls that may rely on these GPIOs
 */
subsys_initcall(mcp23s08_init);
1063 1064 1065

static void __exit mcp23s08_exit(void)
{
1066
	mcp23s08_spi_exit();
P
Peter Korsgaard 已提交
1067
	mcp23s08_i2c_exit();
1068 1069 1070 1071
}
module_exit(mcp23s08_exit);

MODULE_LICENSE("GPL");