2 * MCP23S08 SPI/I2C GPIO gpio expander driver
4 * The inputs and outputs of the mcp23s08, mcp23s17, mcp23008 and mcp23017 are
6 * For the I2C versions of the chips (mcp23008 and mcp23017) generation of
7 * interrupts is also supported.
8 * The hardware of the SPI versions of the chips (mcp23s08 and mcp23s17) is
9 * also capable of generating interrupts, but the linux driver does not
13 #include <linux/kernel.h>
14 #include <linux/device.h>
15 #include <linux/mutex.h>
16 #include <linux/module.h>
17 #include <linux/gpio.h>
18 #include <linux/i2c.h>
19 #include <linux/spi/spi.h>
20 #include <linux/spi/mcp23s08.h>
21 #include <linux/slab.h>
22 #include <asm/byteorder.h>
23 #include <linux/interrupt.h>
24 #include <linux/of_irq.h>
25 #include <linux/of_device.h>
28 * MCP types supported by driver
30 #define MCP_TYPE_S08 0
31 #define MCP_TYPE_S17 1
32 #define MCP_TYPE_008 2
33 #define MCP_TYPE_017 3
35 /* Registers are all 8 bits wide.
37 * The mcp23s17 has twice as many bits, and can be configured to work
38 * with either 16 bit registers or with two adjacent 8 bit banks.
40 #define MCP_IODIR 0x00 /* init/reset: all ones */
42 #define MCP_GPINTEN 0x02
43 #define MCP_DEFVAL 0x03
44 #define MCP_INTCON 0x04
45 #define MCP_IOCON 0x05
46 # define IOCON_MIRROR (1 << 6)
47 # define IOCON_SEQOP (1 << 5)
48 # define IOCON_HAEN (1 << 3)
49 # define IOCON_ODR (1 << 2)
50 # define IOCON_INTPOL (1 << 1)
53 #define MCP_INTCAP 0x08
60 int (*read
)(struct mcp23s08
*mcp
, unsigned reg
);
61 int (*write
)(struct mcp23s08
*mcp
, unsigned reg
, unsigned val
);
62 int (*read_regs
)(struct mcp23s08
*mcp
, unsigned reg
,
63 u16
*vals
, unsigned n
);
75 /* lock protects the cached values */
77 struct mutex irq_lock
;
78 struct irq_domain
*irq_domain
;
80 struct gpio_chip chip
;
82 const struct mcp23s08_ops
*ops
;
83 void *data
; /* ops specific data */
86 /* A given spi_device can represent up to eight mcp23sxx chips
87 * sharing the same chipselect but using different addresses
88 * (e.g. chips #0 and #3 might be populated, but not #1 or $2).
89 * Driver data holds all the per-chip data.
91 struct mcp23s08_driver_data
{
93 struct mcp23s08
*mcp
[8];
94 struct mcp23s08 chip
[];
97 /* This lock class tells lockdep that GPIO irqs are in a different
98 * category than their parents, so it won't report false recursion.
100 static struct lock_class_key gpio_lock_class
;
102 /*----------------------------------------------------------------------*/
104 #if IS_ENABLED(CONFIG_I2C)
106 static int mcp23008_read(struct mcp23s08
*mcp
, unsigned reg
)
108 return i2c_smbus_read_byte_data(mcp
->data
, reg
);
111 static int mcp23008_write(struct mcp23s08
*mcp
, unsigned reg
, unsigned val
)
113 return i2c_smbus_write_byte_data(mcp
->data
, reg
, val
);
117 mcp23008_read_regs(struct mcp23s08
*mcp
, unsigned reg
, u16
*vals
, unsigned n
)
120 int ret
= mcp23008_read(mcp
, reg
++);
129 static int mcp23017_read(struct mcp23s08
*mcp
, unsigned reg
)
131 return i2c_smbus_read_word_data(mcp
->data
, reg
<< 1);
134 static int mcp23017_write(struct mcp23s08
*mcp
, unsigned reg
, unsigned val
)
136 return i2c_smbus_write_word_data(mcp
->data
, reg
<< 1, val
);
140 mcp23017_read_regs(struct mcp23s08
*mcp
, unsigned reg
, u16
*vals
, unsigned n
)
143 int ret
= mcp23017_read(mcp
, reg
++);
152 static const struct mcp23s08_ops mcp23008_ops
= {
153 .read
= mcp23008_read
,
154 .write
= mcp23008_write
,
155 .read_regs
= mcp23008_read_regs
,
158 static const struct mcp23s08_ops mcp23017_ops
= {
159 .read
= mcp23017_read
,
160 .write
= mcp23017_write
,
161 .read_regs
= mcp23017_read_regs
,
164 #endif /* CONFIG_I2C */
166 /*----------------------------------------------------------------------*/
168 #ifdef CONFIG_SPI_MASTER
170 static int mcp23s08_read(struct mcp23s08
*mcp
, unsigned reg
)
175 tx
[0] = mcp
->addr
| 0x01;
177 status
= spi_write_then_read(mcp
->data
, tx
, sizeof(tx
), rx
, sizeof(rx
));
178 return (status
< 0) ? status
: rx
[0];
181 static int mcp23s08_write(struct mcp23s08
*mcp
, unsigned reg
, unsigned val
)
188 return spi_write_then_read(mcp
->data
, tx
, sizeof(tx
), NULL
, 0);
192 mcp23s08_read_regs(struct mcp23s08
*mcp
, unsigned reg
, u16
*vals
, unsigned n
)
197 if ((n
+ reg
) > sizeof(mcp
->cache
))
199 tx
[0] = mcp
->addr
| 0x01;
203 status
= spi_write_then_read(mcp
->data
, tx
, sizeof(tx
), tmp
, n
);
206 vals
[n
] = tmp
[n
]; /* expand to 16bit */
211 static int mcp23s17_read(struct mcp23s08
*mcp
, unsigned reg
)
216 tx
[0] = mcp
->addr
| 0x01;
218 status
= spi_write_then_read(mcp
->data
, tx
, sizeof(tx
), rx
, sizeof(rx
));
219 return (status
< 0) ? status
: (rx
[0] | (rx
[1] << 8));
222 static int mcp23s17_write(struct mcp23s08
*mcp
, unsigned reg
, unsigned val
)
230 return spi_write_then_read(mcp
->data
, tx
, sizeof(tx
), NULL
, 0);
234 mcp23s17_read_regs(struct mcp23s08
*mcp
, unsigned reg
, u16
*vals
, unsigned n
)
239 if ((n
+ reg
) > sizeof(mcp
->cache
))
241 tx
[0] = mcp
->addr
| 0x01;
244 status
= spi_write_then_read(mcp
->data
, tx
, sizeof(tx
),
248 vals
[n
] = __le16_to_cpu((__le16
)vals
[n
]);
254 static const struct mcp23s08_ops mcp23s08_ops
= {
255 .read
= mcp23s08_read
,
256 .write
= mcp23s08_write
,
257 .read_regs
= mcp23s08_read_regs
,
260 static const struct mcp23s08_ops mcp23s17_ops
= {
261 .read
= mcp23s17_read
,
262 .write
= mcp23s17_write
,
263 .read_regs
= mcp23s17_read_regs
,
266 #endif /* CONFIG_SPI_MASTER */
268 /*----------------------------------------------------------------------*/
270 static int mcp23s08_direction_input(struct gpio_chip
*chip
, unsigned offset
)
272 struct mcp23s08
*mcp
= gpiochip_get_data(chip
);
275 mutex_lock(&mcp
->lock
);
276 mcp
->cache
[MCP_IODIR
] |= (1 << offset
);
277 status
= mcp
->ops
->write(mcp
, MCP_IODIR
, mcp
->cache
[MCP_IODIR
]);
278 mutex_unlock(&mcp
->lock
);
282 static int mcp23s08_get(struct gpio_chip
*chip
, unsigned offset
)
284 struct mcp23s08
*mcp
= gpiochip_get_data(chip
);
287 mutex_lock(&mcp
->lock
);
289 /* REVISIT reading this clears any IRQ ... */
290 status
= mcp
->ops
->read(mcp
, MCP_GPIO
);
294 mcp
->cache
[MCP_GPIO
] = status
;
295 status
= !!(status
& (1 << offset
));
297 mutex_unlock(&mcp
->lock
);
301 static int __mcp23s08_set(struct mcp23s08
*mcp
, unsigned mask
, int value
)
303 unsigned olat
= mcp
->cache
[MCP_OLAT
];
309 mcp
->cache
[MCP_OLAT
] = olat
;
310 return mcp
->ops
->write(mcp
, MCP_OLAT
, olat
);
313 static void mcp23s08_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
315 struct mcp23s08
*mcp
= gpiochip_get_data(chip
);
316 unsigned mask
= 1 << offset
;
318 mutex_lock(&mcp
->lock
);
319 __mcp23s08_set(mcp
, mask
, value
);
320 mutex_unlock(&mcp
->lock
);
324 mcp23s08_direction_output(struct gpio_chip
*chip
, unsigned offset
, int value
)
326 struct mcp23s08
*mcp
= gpiochip_get_data(chip
);
327 unsigned mask
= 1 << offset
;
330 mutex_lock(&mcp
->lock
);
331 status
= __mcp23s08_set(mcp
, mask
, value
);
333 mcp
->cache
[MCP_IODIR
] &= ~mask
;
334 status
= mcp
->ops
->write(mcp
, MCP_IODIR
, mcp
->cache
[MCP_IODIR
]);
336 mutex_unlock(&mcp
->lock
);
340 /*----------------------------------------------------------------------*/
341 static irqreturn_t
mcp23s08_irq(int irq
, void *data
)
343 struct mcp23s08
*mcp
= data
;
345 unsigned int child_irq
;
347 mutex_lock(&mcp
->lock
);
348 intf
= mcp
->ops
->read(mcp
, MCP_INTF
);
350 mutex_unlock(&mcp
->lock
);
354 mcp
->cache
[MCP_INTF
] = intf
;
356 intcap
= mcp
->ops
->read(mcp
, MCP_INTCAP
);
358 mutex_unlock(&mcp
->lock
);
362 mcp
->cache
[MCP_INTCAP
] = intcap
;
363 mutex_unlock(&mcp
->lock
);
366 for (i
= 0; i
< mcp
->chip
.ngpio
; i
++) {
367 if ((BIT(i
) & mcp
->cache
[MCP_INTF
]) &&
368 ((BIT(i
) & intcap
& mcp
->irq_rise
) ||
369 (mcp
->irq_fall
& ~intcap
& BIT(i
)))) {
370 child_irq
= irq_find_mapping(mcp
->irq_domain
, i
);
371 handle_nested_irq(child_irq
);
378 static int mcp23s08_gpio_to_irq(struct gpio_chip
*chip
, unsigned offset
)
380 struct mcp23s08
*mcp
= gpiochip_get_data(chip
);
382 return irq_find_mapping(mcp
->irq_domain
, offset
);
385 static void mcp23s08_irq_mask(struct irq_data
*data
)
387 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
388 unsigned int pos
= data
->hwirq
;
390 mcp
->cache
[MCP_GPINTEN
] &= ~BIT(pos
);
393 static void mcp23s08_irq_unmask(struct irq_data
*data
)
395 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
396 unsigned int pos
= data
->hwirq
;
398 mcp
->cache
[MCP_GPINTEN
] |= BIT(pos
);
401 static int mcp23s08_irq_set_type(struct irq_data
*data
, unsigned int type
)
403 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
404 unsigned int pos
= data
->hwirq
;
407 if ((type
& IRQ_TYPE_EDGE_BOTH
) == IRQ_TYPE_EDGE_BOTH
) {
408 mcp
->cache
[MCP_INTCON
] &= ~BIT(pos
);
409 mcp
->irq_rise
|= BIT(pos
);
410 mcp
->irq_fall
|= BIT(pos
);
411 } else if (type
& IRQ_TYPE_EDGE_RISING
) {
412 mcp
->cache
[MCP_INTCON
] &= ~BIT(pos
);
413 mcp
->irq_rise
|= BIT(pos
);
414 mcp
->irq_fall
&= ~BIT(pos
);
415 } else if (type
& IRQ_TYPE_EDGE_FALLING
) {
416 mcp
->cache
[MCP_INTCON
] &= ~BIT(pos
);
417 mcp
->irq_rise
&= ~BIT(pos
);
418 mcp
->irq_fall
|= BIT(pos
);
425 static void mcp23s08_irq_bus_lock(struct irq_data
*data
)
427 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
429 mutex_lock(&mcp
->irq_lock
);
432 static void mcp23s08_irq_bus_unlock(struct irq_data
*data
)
434 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
436 mutex_lock(&mcp
->lock
);
437 mcp
->ops
->write(mcp
, MCP_GPINTEN
, mcp
->cache
[MCP_GPINTEN
]);
438 mcp
->ops
->write(mcp
, MCP_DEFVAL
, mcp
->cache
[MCP_DEFVAL
]);
439 mcp
->ops
->write(mcp
, MCP_INTCON
, mcp
->cache
[MCP_INTCON
]);
440 mutex_unlock(&mcp
->lock
);
441 mutex_unlock(&mcp
->irq_lock
);
444 static int mcp23s08_irq_reqres(struct irq_data
*data
)
446 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
448 if (gpiochip_lock_as_irq(&mcp
->chip
, data
->hwirq
)) {
449 dev_err(mcp
->chip
.parent
,
450 "unable to lock HW IRQ %lu for IRQ usage\n",
458 static void mcp23s08_irq_relres(struct irq_data
*data
)
460 struct mcp23s08
*mcp
= irq_data_get_irq_chip_data(data
);
462 gpiochip_unlock_as_irq(&mcp
->chip
, data
->hwirq
);
465 static struct irq_chip mcp23s08_irq_chip
= {
466 .name
= "gpio-mcp23xxx",
467 .irq_mask
= mcp23s08_irq_mask
,
468 .irq_unmask
= mcp23s08_irq_unmask
,
469 .irq_set_type
= mcp23s08_irq_set_type
,
470 .irq_bus_lock
= mcp23s08_irq_bus_lock
,
471 .irq_bus_sync_unlock
= mcp23s08_irq_bus_unlock
,
472 .irq_request_resources
= mcp23s08_irq_reqres
,
473 .irq_release_resources
= mcp23s08_irq_relres
,
476 static int mcp23s08_irq_setup(struct mcp23s08
*mcp
)
478 struct gpio_chip
*chip
= &mcp
->chip
;
480 unsigned long irqflags
= IRQF_ONESHOT
| IRQF_SHARED
;
482 mutex_init(&mcp
->irq_lock
);
484 mcp
->irq_domain
= irq_domain_add_linear(chip
->parent
->of_node
,
486 &irq_domain_simple_ops
, mcp
);
487 if (!mcp
->irq_domain
)
490 if (mcp
->irq_active_high
)
491 irqflags
|= IRQF_TRIGGER_HIGH
;
493 irqflags
|= IRQF_TRIGGER_LOW
;
495 err
= devm_request_threaded_irq(chip
->parent
, mcp
->irq
, NULL
,
497 irqflags
, dev_name(chip
->parent
), mcp
);
499 dev_err(chip
->parent
, "unable to request IRQ#%d: %d\n",
504 chip
->to_irq
= mcp23s08_gpio_to_irq
;
506 for (j
= 0; j
< mcp
->chip
.ngpio
; j
++) {
507 irq
= irq_create_mapping(mcp
->irq_domain
, j
);
508 irq_set_lockdep_class(irq
, &gpio_lock_class
);
509 irq_set_chip_data(irq
, mcp
);
510 irq_set_chip(irq
, &mcp23s08_irq_chip
);
511 irq_set_nested_thread(irq
, true);
512 irq_set_noprobe(irq
);
517 static void mcp23s08_irq_teardown(struct mcp23s08
*mcp
)
521 for (i
= 0; i
< mcp
->chip
.ngpio
; i
++) {
522 irq
= irq_find_mapping(mcp
->irq_domain
, i
);
524 irq_dispose_mapping(irq
);
527 irq_domain_remove(mcp
->irq_domain
);
530 /*----------------------------------------------------------------------*/
532 #ifdef CONFIG_DEBUG_FS
534 #include <linux/seq_file.h>
537 * This shows more info than the generic gpio dump code:
538 * pullups, deglitching, open drain drive.
540 static void mcp23s08_dbg_show(struct seq_file
*s
, struct gpio_chip
*chip
)
542 struct mcp23s08
*mcp
;
547 mcp
= gpiochip_get_data(chip
);
549 /* NOTE: we only handle one bank for now ... */
550 bank
= '0' + ((mcp
->addr
>> 1) & 0x7);
552 mutex_lock(&mcp
->lock
);
553 t
= mcp
->ops
->read_regs(mcp
, 0, mcp
->cache
, ARRAY_SIZE(mcp
->cache
));
555 seq_printf(s
, " I/O ERROR %d\n", t
);
559 for (t
= 0, mask
= 1; t
< chip
->ngpio
; t
++, mask
<<= 1) {
562 label
= gpiochip_is_requested(chip
, t
);
566 seq_printf(s
, " gpio-%-3d P%c.%d (%-12s) %s %s %s",
567 chip
->base
+ t
, bank
, t
, label
,
568 (mcp
->cache
[MCP_IODIR
] & mask
) ? "in " : "out",
569 (mcp
->cache
[MCP_GPIO
] & mask
) ? "hi" : "lo",
570 (mcp
->cache
[MCP_GPPU
] & mask
) ? "up" : " ");
571 /* NOTE: ignoring the irq-related registers */
575 mutex_unlock(&mcp
->lock
);
579 #define mcp23s08_dbg_show NULL
582 /*----------------------------------------------------------------------*/
584 static int mcp23s08_probe_one(struct mcp23s08
*mcp
, struct device
*dev
,
585 void *data
, unsigned addr
, unsigned type
,
586 struct mcp23s08_platform_data
*pdata
, int cs
)
591 mutex_init(&mcp
->lock
);
595 mcp
->irq_active_high
= false;
597 mcp
->chip
.direction_input
= mcp23s08_direction_input
;
598 mcp
->chip
.get
= mcp23s08_get
;
599 mcp
->chip
.direction_output
= mcp23s08_direction_output
;
600 mcp
->chip
.set
= mcp23s08_set
;
601 mcp
->chip
.dbg_show
= mcp23s08_dbg_show
;
603 mcp
->chip
.of_gpio_n_cells
= 2;
604 mcp
->chip
.of_node
= dev
->of_node
;
608 #ifdef CONFIG_SPI_MASTER
610 mcp
->ops
= &mcp23s08_ops
;
612 mcp
->chip
.label
= "mcp23s08";
616 mcp
->ops
= &mcp23s17_ops
;
617 mcp
->chip
.ngpio
= 16;
618 mcp
->chip
.label
= "mcp23s17";
620 #endif /* CONFIG_SPI_MASTER */
622 #if IS_ENABLED(CONFIG_I2C)
624 mcp
->ops
= &mcp23008_ops
;
626 mcp
->chip
.label
= "mcp23008";
630 mcp
->ops
= &mcp23017_ops
;
631 mcp
->chip
.ngpio
= 16;
632 mcp
->chip
.label
= "mcp23017";
634 #endif /* CONFIG_I2C */
637 dev_err(dev
, "invalid device type (%d)\n", type
);
641 mcp
->chip
.base
= pdata
->base
;
642 mcp
->chip
.can_sleep
= true;
643 mcp
->chip
.parent
= dev
;
644 mcp
->chip
.owner
= THIS_MODULE
;
646 /* verify MCP_IOCON.SEQOP = 0, so sequential reads work,
647 * and MCP_IOCON.HAEN = 1, so we work with all chips.
650 status
= mcp
->ops
->read(mcp
, MCP_IOCON
);
654 mcp
->irq_controller
= pdata
->irq_controller
;
655 if (mcp
->irq
&& mcp
->irq_controller
) {
656 mcp
->irq_active_high
=
657 of_property_read_bool(mcp
->chip
.parent
->of_node
,
658 "microchip,irq-active-high");
660 if (type
== MCP_TYPE_017
)
661 mirror
= pdata
->mirror
;
664 if ((status
& IOCON_SEQOP
) || !(status
& IOCON_HAEN
) || mirror
||
665 mcp
->irq_active_high
) {
666 /* mcp23s17 has IOCON twice, make sure they are in sync */
667 status
&= ~(IOCON_SEQOP
| (IOCON_SEQOP
<< 8));
668 status
|= IOCON_HAEN
| (IOCON_HAEN
<< 8);
669 if (mcp
->irq_active_high
)
670 status
|= IOCON_INTPOL
| (IOCON_INTPOL
<< 8);
672 status
&= ~(IOCON_INTPOL
| (IOCON_INTPOL
<< 8));
675 status
|= IOCON_MIRROR
| (IOCON_MIRROR
<< 8);
677 status
= mcp
->ops
->write(mcp
, MCP_IOCON
, status
);
682 /* configure ~100K pullups */
683 status
= mcp
->ops
->write(mcp
, MCP_GPPU
, pdata
->chip
[cs
].pullups
);
687 status
= mcp
->ops
->read_regs(mcp
, 0, mcp
->cache
, ARRAY_SIZE(mcp
->cache
));
691 /* disable inverter on input */
692 if (mcp
->cache
[MCP_IPOL
] != 0) {
693 mcp
->cache
[MCP_IPOL
] = 0;
694 status
= mcp
->ops
->write(mcp
, MCP_IPOL
, 0);
700 if (mcp
->cache
[MCP_GPINTEN
] != 0) {
701 mcp
->cache
[MCP_GPINTEN
] = 0;
702 status
= mcp
->ops
->write(mcp
, MCP_GPINTEN
, 0);
707 status
= gpiochip_add_data(&mcp
->chip
, mcp
);
711 if (mcp
->irq
&& mcp
->irq_controller
) {
712 status
= mcp23s08_irq_setup(mcp
);
714 mcp23s08_irq_teardown(mcp
);
720 dev_dbg(dev
, "can't setup chip %d, --> %d\n",
725 /*----------------------------------------------------------------------*/
728 #ifdef CONFIG_SPI_MASTER
729 static const struct of_device_id mcp23s08_spi_of_match
[] = {
731 .compatible
= "microchip,mcp23s08",
732 .data
= (void *) MCP_TYPE_S08
,
735 .compatible
= "microchip,mcp23s17",
736 .data
= (void *) MCP_TYPE_S17
,
738 /* NOTE: The use of the mcp prefix is deprecated and will be removed. */
740 .compatible
= "mcp,mcp23s08",
741 .data
= (void *) MCP_TYPE_S08
,
744 .compatible
= "mcp,mcp23s17",
745 .data
= (void *) MCP_TYPE_S17
,
749 MODULE_DEVICE_TABLE(of
, mcp23s08_spi_of_match
);
752 #if IS_ENABLED(CONFIG_I2C)
753 static const struct of_device_id mcp23s08_i2c_of_match
[] = {
755 .compatible
= "microchip,mcp23008",
756 .data
= (void *) MCP_TYPE_008
,
759 .compatible
= "microchip,mcp23017",
760 .data
= (void *) MCP_TYPE_017
,
762 /* NOTE: The use of the mcp prefix is deprecated and will be removed. */
764 .compatible
= "mcp,mcp23008",
765 .data
= (void *) MCP_TYPE_008
,
768 .compatible
= "mcp,mcp23017",
769 .data
= (void *) MCP_TYPE_017
,
773 MODULE_DEVICE_TABLE(of
, mcp23s08_i2c_of_match
);
775 #endif /* CONFIG_OF */
778 #if IS_ENABLED(CONFIG_I2C)
780 static int mcp230xx_probe(struct i2c_client
*client
,
781 const struct i2c_device_id
*id
)
783 struct mcp23s08_platform_data
*pdata
, local_pdata
;
784 struct mcp23s08
*mcp
;
786 const struct of_device_id
*match
;
788 match
= of_match_device(of_match_ptr(mcp23s08_i2c_of_match
),
791 pdata
= &local_pdata
;
793 pdata
->chip
[0].pullups
= 0;
794 pdata
->irq_controller
= of_property_read_bool(
796 "interrupt-controller");
797 pdata
->mirror
= of_property_read_bool(client
->dev
.of_node
,
798 "microchip,irq-mirror");
799 client
->irq
= irq_of_parse_and_map(client
->dev
.of_node
, 0);
801 pdata
= dev_get_platdata(&client
->dev
);
803 pdata
= devm_kzalloc(&client
->dev
,
804 sizeof(struct mcp23s08_platform_data
),
810 mcp
= kzalloc(sizeof(*mcp
), GFP_KERNEL
);
814 mcp
->irq
= client
->irq
;
815 status
= mcp23s08_probe_one(mcp
, &client
->dev
, client
, client
->addr
,
816 id
->driver_data
, pdata
, 0);
820 i2c_set_clientdata(client
, mcp
);
830 static int mcp230xx_remove(struct i2c_client
*client
)
832 struct mcp23s08
*mcp
= i2c_get_clientdata(client
);
834 if (client
->irq
&& mcp
->irq_controller
)
835 mcp23s08_irq_teardown(mcp
);
837 gpiochip_remove(&mcp
->chip
);
843 static const struct i2c_device_id mcp230xx_id
[] = {
844 { "mcp23008", MCP_TYPE_008
},
845 { "mcp23017", MCP_TYPE_017
},
848 MODULE_DEVICE_TABLE(i2c
, mcp230xx_id
);
850 static struct i2c_driver mcp230xx_driver
= {
853 .of_match_table
= of_match_ptr(mcp23s08_i2c_of_match
),
855 .probe
= mcp230xx_probe
,
856 .remove
= mcp230xx_remove
,
857 .id_table
= mcp230xx_id
,
860 static int __init
mcp23s08_i2c_init(void)
862 return i2c_add_driver(&mcp230xx_driver
);
865 static void mcp23s08_i2c_exit(void)
867 i2c_del_driver(&mcp230xx_driver
);
872 static int __init
mcp23s08_i2c_init(void) { return 0; }
873 static void mcp23s08_i2c_exit(void) { }
875 #endif /* CONFIG_I2C */
877 /*----------------------------------------------------------------------*/
879 #ifdef CONFIG_SPI_MASTER
881 static int mcp23s08_probe(struct spi_device
*spi
)
883 struct mcp23s08_platform_data
*pdata
, local_pdata
;
886 struct mcp23s08_driver_data
*data
;
889 const struct of_device_id
*match
;
890 u32 spi_present_mask
= 0;
892 match
= of_match_device(of_match_ptr(mcp23s08_spi_of_match
), &spi
->dev
);
894 type
= (int)(uintptr_t)match
->data
;
895 status
= of_property_read_u32(spi
->dev
.of_node
,
896 "microchip,spi-present-mask", &spi_present_mask
);
898 status
= of_property_read_u32(spi
->dev
.of_node
,
899 "mcp,spi-present-mask", &spi_present_mask
);
902 "DT has no spi-present-mask\n");
906 if ((spi_present_mask
<= 0) || (spi_present_mask
>= 256)) {
907 dev_err(&spi
->dev
, "invalid spi-present-mask\n");
911 pdata
= &local_pdata
;
913 for (addr
= 0; addr
< ARRAY_SIZE(pdata
->chip
); addr
++) {
914 pdata
->chip
[addr
].pullups
= 0;
915 if (spi_present_mask
& (1 << addr
))
918 pdata
->irq_controller
= of_property_read_bool(
920 "interrupt-controller");
921 pdata
->mirror
= of_property_read_bool(spi
->dev
.of_node
,
922 "microchip,irq-mirror");
924 type
= spi_get_device_id(spi
)->driver_data
;
925 pdata
= dev_get_platdata(&spi
->dev
);
927 pdata
= devm_kzalloc(&spi
->dev
,
928 sizeof(struct mcp23s08_platform_data
),
933 for (addr
= 0; addr
< ARRAY_SIZE(pdata
->chip
); addr
++) {
934 if (!pdata
->chip
[addr
].is_present
)
937 if ((type
== MCP_TYPE_S08
) && (addr
> 3)) {
939 "mcp23s08 only supports address 0..3\n");
942 spi_present_mask
|= 1 << addr
;
949 data
= devm_kzalloc(&spi
->dev
,
950 sizeof(*data
) + chips
* sizeof(struct mcp23s08
),
955 spi_set_drvdata(spi
, data
);
957 spi
->irq
= irq_of_parse_and_map(spi
->dev
.of_node
, 0);
959 for (addr
= 0; addr
< ARRAY_SIZE(pdata
->chip
); addr
++) {
960 if (!(spi_present_mask
& (1 << addr
)))
963 data
->mcp
[addr
] = &data
->chip
[chips
];
964 data
->mcp
[addr
]->irq
= spi
->irq
;
965 status
= mcp23s08_probe_one(data
->mcp
[addr
], &spi
->dev
, spi
,
966 0x40 | (addr
<< 1), type
, pdata
,
971 if (pdata
->base
!= -1)
972 pdata
->base
+= (type
== MCP_TYPE_S17
) ? 16 : 8;
973 ngpio
+= (type
== MCP_TYPE_S17
) ? 16 : 8;
977 /* NOTE: these chips have a relatively sane IRQ framework, with
978 * per-signal masking and level/edge triggering. It's not yet
985 for (addr
= 0; addr
< ARRAY_SIZE(data
->mcp
); addr
++) {
987 if (!data
->mcp
[addr
])
989 gpiochip_remove(&data
->mcp
[addr
]->chip
);
994 static int mcp23s08_remove(struct spi_device
*spi
)
996 struct mcp23s08_driver_data
*data
= spi_get_drvdata(spi
);
999 for (addr
= 0; addr
< ARRAY_SIZE(data
->mcp
); addr
++) {
1001 if (!data
->mcp
[addr
])
1004 if (spi
->irq
&& data
->mcp
[addr
]->irq_controller
)
1005 mcp23s08_irq_teardown(data
->mcp
[addr
]);
1006 gpiochip_remove(&data
->mcp
[addr
]->chip
);
1012 static const struct spi_device_id mcp23s08_ids
[] = {
1013 { "mcp23s08", MCP_TYPE_S08
},
1014 { "mcp23s17", MCP_TYPE_S17
},
1017 MODULE_DEVICE_TABLE(spi
, mcp23s08_ids
);
1019 static struct spi_driver mcp23s08_driver
= {
1020 .probe
= mcp23s08_probe
,
1021 .remove
= mcp23s08_remove
,
1022 .id_table
= mcp23s08_ids
,
1025 .of_match_table
= of_match_ptr(mcp23s08_spi_of_match
),
1029 static int __init
mcp23s08_spi_init(void)
1031 return spi_register_driver(&mcp23s08_driver
);
1034 static void mcp23s08_spi_exit(void)
1036 spi_unregister_driver(&mcp23s08_driver
);
1041 static int __init
mcp23s08_spi_init(void) { return 0; }
1042 static void mcp23s08_spi_exit(void) { }
1044 #endif /* CONFIG_SPI_MASTER */
1046 /*----------------------------------------------------------------------*/
1048 static int __init
mcp23s08_init(void)
1052 ret
= mcp23s08_spi_init();
1056 ret
= mcp23s08_i2c_init();
1063 mcp23s08_spi_exit();
1067 /* register after spi/i2c postcore initcall and before
1068 * subsys initcalls that may rely on these GPIOs
1070 subsys_initcall(mcp23s08_init
);
1072 static void __exit
mcp23s08_exit(void)
1074 mcp23s08_spi_exit();
1075 mcp23s08_i2c_exit();
1077 module_exit(mcp23s08_exit
);
1079 MODULE_LICENSE("GPL");