drivers/gpio/gpio-mcp23s08.c

   1 /*
   2  * MCP23S08 SPI/I2C GPIO gpio expander driver
   3  *
   4  * The inputs and outputs of the mcp23s08, mcp23s17, mcp23008 and mcp23017 are
   5  * supported.
   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
  10  * support that yet.
  11  */
  12
  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>
  26 #include <linux/regmap.h>
  27
  28 /**
  29  * MCP types supported by driver
  30  */
  31 #define MCP_TYPE_S08    0
  32 #define MCP_TYPE_S17    1
  33 #define MCP_TYPE_008    2
  34 #define MCP_TYPE_017    3
  35 #define MCP_TYPE_S18    4
  36
  37 /* Registers are all 8 bits wide.
  38  *
  39  * The mcp23s17 has twice as many bits, and can be configured to work
  40  * with either 16 bit registers or with two adjacent 8 bit banks.
  41  */
  42 #define MCP_IODIR       0x00            /* init/reset:  all ones */
  43 #define MCP_IPOL        0x01
  44 #define MCP_GPINTEN     0x02
  45 #define MCP_DEFVAL      0x03
  46 #define MCP_INTCON      0x04
  47 #define MCP_IOCON       0x05
  48 #       define IOCON_MIRROR     (1 << 6)
  49 #       define IOCON_SEQOP      (1 << 5)
  50 #       define IOCON_HAEN       (1 << 3)
  51 #       define IOCON_ODR        (1 << 2)
  52 #       define IOCON_INTPOL     (1 << 1)
  53 #       define IOCON_INTCC      (1)
  54 #define MCP_GPPU        0x06
  55 #define MCP_INTF        0x07
  56 #define MCP_INTCAP      0x08
  57 #define MCP_GPIO        0x09
  58 #define MCP_OLAT        0x0a
  59
  60 struct mcp23s08;
  61
  62 struct mcp23s08 {
  63         u8                      addr;
  64         bool                    irq_active_high;
  65         bool                    reg_shift;
  66
  67         u16                     cache[11];
  68         u16                     irq_rise;
  69         u16                     irq_fall;
  70         int                     irq;
  71         bool                    irq_controller;
  72         /* lock protects the cached values */
  73         struct mutex            lock;
  74         struct mutex            irq_lock;
  75
  76         struct gpio_chip        chip;
  77
  78         struct regmap           *regmap;
  79         struct device           *dev;
  80 };
  81
  82 static const struct regmap_config mcp23x08_regmap = {
  83         .reg_bits = 8,
  84         .val_bits = 8,
  85
  86         .reg_stride = 1,
  87         .max_register = MCP_OLAT,
  88 };
  89
  90 static const struct regmap_config mcp23x17_regmap = {
  91         .reg_bits = 8,
  92         .val_bits = 16,
  93
  94         .reg_stride = 2,
  95         .max_register = MCP_OLAT << 1,
  96         .val_format_endian = REGMAP_ENDIAN_LITTLE,
  97 };
  98
  99 /*----------------------------------------------------------------------*/
 100
 101 #ifdef CONFIG_SPI_MASTER
 102
 103 static int mcp23sxx_spi_write(void *context, const void *data, size_t count)
 104 {
 105         struct mcp23s08 *mcp = context;
 106         struct spi_device *spi = to_spi_device(mcp->dev);
 107         struct spi_message m;
 108         struct spi_transfer t[2] = { { .tx_buf = &mcp->addr, .len = 1, },
 109                                      { .tx_buf = data, .len = count, }, };
 110
 111         spi_message_init(&m);
 112         spi_message_add_tail(&t[0], &m);
 113         spi_message_add_tail(&t[1], &m);
 114
 115         return spi_sync(spi, &m);
 116 }
 117
 118 static int mcp23sxx_spi_gather_write(void *context,
 119                                 const void *reg, size_t reg_size,
 120                                 const void *val, size_t val_size)
 121 {
 122         struct mcp23s08 *mcp = context;
 123         struct spi_device *spi = to_spi_device(mcp->dev);
 124         struct spi_message m;
 125         struct spi_transfer t[3] = { { .tx_buf = &mcp->addr, .len = 1, },
 126                                      { .tx_buf = reg, .len = reg_size, },
 127                                      { .tx_buf = val, .len = val_size, }, };
 128
 129         spi_message_init(&m);
 130         spi_message_add_tail(&t[0], &m);
 131         spi_message_add_tail(&t[1], &m);
 132         spi_message_add_tail(&t[2], &m);
 133
 134         return spi_sync(spi, &m);
 135 }
 136
 137 static int mcp23sxx_spi_read(void *context, const void *reg, size_t reg_size,
 138                                 void *val, size_t val_size)
 139 {
 140         struct mcp23s08 *mcp = context;
 141         struct spi_device *spi = to_spi_device(mcp->dev);
 142         u8 tx[2];
 143
 144         if (reg_size != 1)
 145                 return -EINVAL;
 146
 147         tx[0] = mcp->addr | 0x01;
 148         tx[1] = *((u8 *) reg);
 149
 150         return spi_write_then_read(spi, tx, sizeof(tx), val, val_size);
 151 }
 152
 153 static const struct regmap_bus mcp23sxx_spi_regmap = {
 154         .write = mcp23sxx_spi_write,
 155         .gather_write = mcp23sxx_spi_gather_write,
 156         .read = mcp23sxx_spi_read,
 157 };
 158
 159 #endif /* CONFIG_SPI_MASTER */
 160
 161 static int mcp_read(struct mcp23s08 *mcp, unsigned int reg, unsigned int *val)
 162 {
 163         return regmap_read(mcp->regmap, reg << mcp->reg_shift, val);
 164 }
 165
 166 static int mcp_write(struct mcp23s08 *mcp, unsigned int reg, unsigned int val)
 167 {
 168         return regmap_write(mcp->regmap, reg << mcp->reg_shift, val);
 169 }
 170
 171 static int mcp_update_cache(struct mcp23s08 *mcp)
 172 {
 173         int ret, reg, i;
 174
 175         for (i = 0; i < ARRAY_SIZE(mcp->cache); i++) {
 176                 ret = mcp_read(mcp, i, &reg);
 177                 if (ret < 0)
 178                         return ret;
 179                 mcp->cache[i] = reg;
 180         }
 181
 182         return 0;
 183 }
 184
 185 /*----------------------------------------------------------------------*/
 186
 187 /* A given spi_device can represent up to eight mcp23sxx chips
 188  * sharing the same chipselect but using different addresses
 189  * (e.g. chips #0 and #3 might be populated, but not #1 or $2).
 190  * Driver data holds all the per-chip data.
 191  */
 192 struct mcp23s08_driver_data {
 193         unsigned                ngpio;
 194         struct mcp23s08         *mcp[8];
 195         struct mcp23s08         chip[];
 196 };
 197
 198
 199 static int mcp23s08_direction_input(struct gpio_chip *chip, unsigned offset)
 200 {
 201         struct mcp23s08 *mcp = gpiochip_get_data(chip);
 202         int status;
 203
 204         mutex_lock(&mcp->lock);
 205         mcp->cache[MCP_IODIR] |= (1 << offset);
 206         status = mcp_write(mcp, MCP_IODIR, mcp->cache[MCP_IODIR]);
 207         mutex_unlock(&mcp->lock);
 208         return status;
 209 }
 210
 211 static int mcp23s08_get(struct gpio_chip *chip, unsigned offset)
 212 {
 213         struct mcp23s08 *mcp = gpiochip_get_data(chip);
 214         int status, ret;
 215
 216         mutex_lock(&mcp->lock);
 217
 218         /* REVISIT reading this clears any IRQ ... */
 219         ret = mcp_read(mcp, MCP_GPIO, &status);
 220         if (ret < 0)
 221                 status = 0;
 222         else {
 223                 mcp->cache[MCP_GPIO] = status;
 224                 status = !!(status & (1 << offset));
 225         }
 226         mutex_unlock(&mcp->lock);
 227         return status;
 228 }
 229
 230 static int __mcp23s08_set(struct mcp23s08 *mcp, unsigned mask, int value)
 231 {
 232         unsigned olat = mcp->cache[MCP_OLAT];
 233
 234         if (value)
 235                 olat |= mask;
 236         else
 237                 olat &= ~mask;
 238         mcp->cache[MCP_OLAT] = olat;
 239         return mcp_write(mcp, MCP_OLAT, olat);
 240 }
 241
 242 static void mcp23s08_set(struct gpio_chip *chip, unsigned offset, int value)
 243 {
 244         struct mcp23s08 *mcp = gpiochip_get_data(chip);
 245         unsigned mask = 1 << offset;
 246
 247         mutex_lock(&mcp->lock);
 248         __mcp23s08_set(mcp, mask, value);
 249         mutex_unlock(&mcp->lock);
 250 }
 251
 252 static int
 253 mcp23s08_direction_output(struct gpio_chip *chip, unsigned offset, int value)
 254 {
 255         struct mcp23s08 *mcp = gpiochip_get_data(chip);
 256         unsigned mask = 1 << offset;
 257         int status;
 258
 259         mutex_lock(&mcp->lock);
 260         status = __mcp23s08_set(mcp, mask, value);
 261         if (status == 0) {
 262                 mcp->cache[MCP_IODIR] &= ~mask;
 263                 status = mcp_write(mcp, MCP_IODIR, mcp->cache[MCP_IODIR]);
 264         }
 265         mutex_unlock(&mcp->lock);
 266         return status;
 267 }
 268
 269 /*----------------------------------------------------------------------*/
 270 static irqreturn_t mcp23s08_irq(int irq, void *data)
 271 {
 272         struct mcp23s08 *mcp = data;
 273         int intcap, intf, i;
 274         unsigned int child_irq;
 275
 276         mutex_lock(&mcp->lock);
 277         if (mcp_read(mcp, MCP_INTF, &intf) < 0) {
 278                 mutex_unlock(&mcp->lock);
 279                 return IRQ_HANDLED;
 280         }
 281
 282         mcp->cache[MCP_INTF] = intf;
 283
 284         if (mcp_read(mcp, MCP_INTCAP, &intcap) < 0) {
 285                 mutex_unlock(&mcp->lock);
 286                 return IRQ_HANDLED;
 287         }
 288
 289         mcp->cache[MCP_INTCAP] = intcap;
 290         mutex_unlock(&mcp->lock);
 291
 292
 293         for (i = 0; i < mcp->chip.ngpio; i++) {
 294                 if ((BIT(i) & mcp->cache[MCP_INTF]) &&
 295                     ((BIT(i) & intcap & mcp->irq_rise) ||
 296                      (mcp->irq_fall & ~intcap & BIT(i)) ||
 297                      (BIT(i) & mcp->cache[MCP_INTCON]))) {
 298                         child_irq = irq_find_mapping(mcp->chip.irqdomain, i);
 299                         handle_nested_irq(child_irq);
 300                 }
 301         }
 302
 303         return IRQ_HANDLED;
 304 }
 305
 306 static void mcp23s08_irq_mask(struct irq_data *data)
 307 {
 308         struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
 309         struct mcp23s08 *mcp = gpiochip_get_data(gc);
 310         unsigned int pos = data->hwirq;
 311
 312         mcp->cache[MCP_GPINTEN] &= ~BIT(pos);
 313 }
 314
 315 static void mcp23s08_irq_unmask(struct irq_data *data)
 316 {
 317         struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
 318         struct mcp23s08 *mcp = gpiochip_get_data(gc);
 319         unsigned int pos = data->hwirq;
 320
 321         mcp->cache[MCP_GPINTEN] |= BIT(pos);
 322 }
 323
 324 static int mcp23s08_irq_set_type(struct irq_data *data, unsigned int type)
 325 {
 326         struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
 327         struct mcp23s08 *mcp = gpiochip_get_data(gc);
 328         unsigned int pos = data->hwirq;
 329         int status = 0;
 330
 331         if ((type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
 332                 mcp->cache[MCP_INTCON] &= ~BIT(pos);
 333                 mcp->irq_rise |= BIT(pos);
 334                 mcp->irq_fall |= BIT(pos);
 335         } else if (type & IRQ_TYPE_EDGE_RISING) {
 336                 mcp->cache[MCP_INTCON] &= ~BIT(pos);
 337                 mcp->irq_rise |= BIT(pos);
 338                 mcp->irq_fall &= ~BIT(pos);
 339         } else if (type & IRQ_TYPE_EDGE_FALLING) {
 340                 mcp->cache[MCP_INTCON] &= ~BIT(pos);
 341                 mcp->irq_rise &= ~BIT(pos);
 342                 mcp->irq_fall |= BIT(pos);
 343         } else if (type & IRQ_TYPE_LEVEL_HIGH) {
 344                 mcp->cache[MCP_INTCON] |= BIT(pos);
 345                 mcp->cache[MCP_DEFVAL] &= ~BIT(pos);
 346         } else if (type & IRQ_TYPE_LEVEL_LOW) {
 347                 mcp->cache[MCP_INTCON] |= BIT(pos);
 348                 mcp->cache[MCP_DEFVAL] |= BIT(pos);
 349         } else
 350                 return -EINVAL;
 351
 352         return status;
 353 }
 354
 355 static void mcp23s08_irq_bus_lock(struct irq_data *data)
 356 {
 357         struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
 358         struct mcp23s08 *mcp = gpiochip_get_data(gc);
 359
 360         mutex_lock(&mcp->irq_lock);
 361 }
 362
 363 static void mcp23s08_irq_bus_unlock(struct irq_data *data)
 364 {
 365         struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
 366         struct mcp23s08 *mcp = gpiochip_get_data(gc);
 367
 368         mutex_lock(&mcp->lock);
 369         mcp_write(mcp, MCP_GPINTEN, mcp->cache[MCP_GPINTEN]);
 370         mcp_write(mcp, MCP_DEFVAL, mcp->cache[MCP_DEFVAL]);
 371         mcp_write(mcp, MCP_INTCON, mcp->cache[MCP_INTCON]);
 372         mutex_unlock(&mcp->lock);
 373         mutex_unlock(&mcp->irq_lock);
 374 }
 375
 376 static struct irq_chip mcp23s08_irq_chip = {
 377         .name = "gpio-mcp23xxx",
 378         .irq_mask = mcp23s08_irq_mask,
 379         .irq_unmask = mcp23s08_irq_unmask,
 380         .irq_set_type = mcp23s08_irq_set_type,
 381         .irq_bus_lock = mcp23s08_irq_bus_lock,
 382         .irq_bus_sync_unlock = mcp23s08_irq_bus_unlock,
 383 };
 384
 385 static int mcp23s08_irq_setup(struct mcp23s08 *mcp)
 386 {
 387         struct gpio_chip *chip = &mcp->chip;
 388         int err;
 389         unsigned long irqflags = IRQF_ONESHOT | IRQF_SHARED;
 390
 391         mutex_init(&mcp->irq_lock);
 392
 393         if (mcp->irq_active_high)
 394                 irqflags |= IRQF_TRIGGER_HIGH;
 395         else
 396                 irqflags |= IRQF_TRIGGER_LOW;
 397
 398         err = devm_request_threaded_irq(chip->parent, mcp->irq, NULL,
 399                                         mcp23s08_irq,
 400                                         irqflags, dev_name(chip->parent), mcp);
 401         if (err != 0) {
 402                 dev_err(chip->parent, "unable to request IRQ#%d: %d\n",
 403                         mcp->irq, err);
 404                 return err;
 405         }
 406
 407         err =  gpiochip_irqchip_add_nested(chip,
 408                                            &mcp23s08_irq_chip,
 409                                            0,
 410                                            handle_simple_irq,
 411                                            IRQ_TYPE_NONE);
 412         if (err) {
 413                 dev_err(chip->parent,
 414                         "could not connect irqchip to gpiochip: %d\n", err);
 415                 return err;
 416         }
 417
 418         gpiochip_set_nested_irqchip(chip,
 419                                     &mcp23s08_irq_chip,
 420                                     mcp->irq);
 421
 422         return 0;
 423 }
 424
 425 /*----------------------------------------------------------------------*/
 426
 427 #ifdef CONFIG_DEBUG_FS
 428
 429 #include <linux/seq_file.h>
 430
 431 /*
 432  * This shows more info than the generic gpio dump code:
 433  * pullups, deglitching, open drain drive.
 434  */
 435 static void mcp23s08_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 436 {
 437         struct mcp23s08 *mcp;
 438         char            bank;
 439         int             t;
 440         unsigned        mask;
 441
 442         mcp = gpiochip_get_data(chip);
 443
 444         /* NOTE: we only handle one bank for now ... */
 445         bank = '0' + ((mcp->addr >> 1) & 0x7);
 446
 447         mutex_lock(&mcp->lock);
 448         t = mcp_update_cache(mcp);
 449         if (t < 0) {
 450                 seq_printf(s, " I/O ERROR %d\n", t);
 451                 goto done;
 452         }
 453
 454         for (t = 0, mask = 1; t < chip->ngpio; t++, mask <<= 1) {
 455                 const char      *label;
 456
 457                 label = gpiochip_is_requested(chip, t);
 458                 if (!label)
 459                         continue;
 460
 461                 seq_printf(s, " gpio-%-3d P%c.%d (%-12s) %s %s %s",
 462                         chip->base + t, bank, t, label,
 463                         (mcp->cache[MCP_IODIR] & mask) ? "in " : "out",
 464                         (mcp->cache[MCP_GPIO] & mask) ? "hi" : "lo",
 465                         (mcp->cache[MCP_GPPU] & mask) ? "up" : "  ");
 466                 /* NOTE:  ignoring the irq-related registers */
 467                 seq_puts(s, "\n");
 468         }
 469 done:
 470         mutex_unlock(&mcp->lock);
 471 }
 472
 473 #else
 474 #define mcp23s08_dbg_show       NULL
 475 #endif
 476
 477 /*----------------------------------------------------------------------*/
 478
 479 static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
 480                               void *data, unsigned addr, unsigned type,
 481                               struct mcp23s08_platform_data *pdata, int cs)
 482 {
 483         int status, ret;
 484         bool mirror = false;
 485
 486         mutex_init(&mcp->lock);
 487
 488         mcp->dev = dev;
 489         mcp->addr = addr;
 490         mcp->irq_active_high = false;
 491
 492         mcp->chip.direction_input = mcp23s08_direction_input;
 493         mcp->chip.get = mcp23s08_get;
 494         mcp->chip.direction_output = mcp23s08_direction_output;
 495         mcp->chip.set = mcp23s08_set;
 496         mcp->chip.dbg_show = mcp23s08_dbg_show;
 497 #ifdef CONFIG_OF_GPIO
 498         mcp->chip.of_gpio_n_cells = 2;
 499         mcp->chip.of_node = dev->of_node;
 500 #endif
 501
 502         switch (type) {
 503 #ifdef CONFIG_SPI_MASTER
 504         case MCP_TYPE_S08:
 505                 mcp->regmap = devm_regmap_init(dev, &mcp23sxx_spi_regmap, mcp,
 506                                                &mcp23x08_regmap);
 507                 mcp->reg_shift = 0;
 508                 mcp->chip.ngpio = 8;
 509                 mcp->chip.label = "mcp23s08";
 510                 break;
 511
 512         case MCP_TYPE_S17:
 513                 mcp->regmap = devm_regmap_init(dev, &mcp23sxx_spi_regmap, mcp,
 514                                                &mcp23x17_regmap);
 515                 mcp->reg_shift = 1;
 516                 mcp->chip.ngpio = 16;
 517                 mcp->chip.label = "mcp23s17";
 518                 break;
 519
 520         case MCP_TYPE_S18:
 521                 mcp->regmap = devm_regmap_init(dev, &mcp23sxx_spi_regmap, mcp,
 522                                                &mcp23x17_regmap);
 523                 mcp->reg_shift = 1;
 524                 mcp->chip.ngpio = 16;
 525                 mcp->chip.label = "mcp23s18";
 526                 break;
 527 #endif /* CONFIG_SPI_MASTER */
 528
 529 #if IS_ENABLED(CONFIG_I2C)
 530         case MCP_TYPE_008:
 531                 mcp->regmap = devm_regmap_init_i2c(data, &mcp23x08_regmap);
 532                 mcp->reg_shift = 0;
 533                 mcp->chip.ngpio = 8;
 534                 mcp->chip.label = "mcp23008";
 535                 break;
 536
 537         case MCP_TYPE_017:
 538                 mcp->regmap = devm_regmap_init_i2c(data, &mcp23x17_regmap);
 539                 mcp->reg_shift = 1;
 540                 mcp->chip.ngpio = 16;
 541                 mcp->chip.label = "mcp23017";
 542                 break;
 543 #endif /* CONFIG_I2C */
 544
 545         default:
 546                 dev_err(dev, "invalid device type (%d)\n", type);
 547                 return -EINVAL;
 548         }
 549
 550         if (IS_ERR(mcp->regmap))
 551                 return PTR_ERR(mcp->regmap);
 552
 553         mcp->chip.base = pdata->base;
 554         mcp->chip.can_sleep = true;
 555         mcp->chip.parent = dev;
 556         mcp->chip.owner = THIS_MODULE;
 557
 558         /* verify MCP_IOCON.SEQOP = 0, so sequential reads work,
 559          * and MCP_IOCON.HAEN = 1, so we work with all chips.
 560          */
 561
 562         ret = mcp_read(mcp, MCP_IOCON, &status);
 563         if (ret < 0)
 564                 goto fail;
 565
 566         mcp->irq_controller = pdata->irq_controller;
 567         if (mcp->irq && mcp->irq_controller) {
 568                 mcp->irq_active_high =
 569                         of_property_read_bool(mcp->chip.parent->of_node,
 570                                               "microchip,irq-active-high");
 571
 572                 mirror = pdata->mirror;
 573         }
 574
 575         if ((status & IOCON_SEQOP) || !(status & IOCON_HAEN) || mirror ||
 576              mcp->irq_active_high) {
 577                 /* mcp23s17 has IOCON twice, make sure they are in sync */
 578                 status &= ~(IOCON_SEQOP | (IOCON_SEQOP << 8));
 579                 status |= IOCON_HAEN | (IOCON_HAEN << 8);
 580                 if (mcp->irq_active_high)
 581                         status |= IOCON_INTPOL | (IOCON_INTPOL << 8);
 582                 else
 583                         status &= ~(IOCON_INTPOL | (IOCON_INTPOL << 8));
 584
 585                 if (mirror)
 586                         status |= IOCON_MIRROR | (IOCON_MIRROR << 8);
 587
 588                 if (type == MCP_TYPE_S18)
 589                         status |= IOCON_INTCC | (IOCON_INTCC << 8);
 590
 591                 ret = mcp_write(mcp, MCP_IOCON, status);
 592                 if (ret < 0)
 593                         goto fail;
 594         }
 595
 596         /* configure ~100K pullups */
 597         ret = mcp_write(mcp, MCP_GPPU, pdata->chip[cs].pullups);
 598         if (ret < 0)
 599                 goto fail;
 600
 601         ret = mcp_update_cache(mcp);
 602         if (ret < 0)
 603                 goto fail;
 604
 605         /* disable inverter on input */
 606         if (mcp->cache[MCP_IPOL] != 0) {
 607                 mcp->cache[MCP_IPOL] = 0;
 608                 ret = mcp_write(mcp, MCP_IPOL, 0);
 609                 if (ret < 0)
 610                         goto fail;
 611         }
 612
 613         /* disable irqs */
 614         if (mcp->cache[MCP_GPINTEN] != 0) {
 615                 mcp->cache[MCP_GPINTEN] = 0;
 616                 ret = mcp_write(mcp, MCP_GPINTEN, 0);
 617                 if (ret < 0)
 618                         goto fail;
 619         }
 620
 621         ret = gpiochip_add_data(&mcp->chip, mcp);
 622         if (ret < 0)
 623                 goto fail;
 624
 625         if (mcp->irq && mcp->irq_controller) {
 626                 ret = mcp23s08_irq_setup(mcp);
 627                 if (ret)
 628                         goto fail;
 629         }
 630 fail:
 631         if (ret < 0)
 632                 dev_dbg(dev, "can't setup chip %d, --> %d\n", addr, ret);
 633         return ret;
 634 }
 635
 636 /*----------------------------------------------------------------------*/
 637
 638 #ifdef CONFIG_OF
 639 #ifdef CONFIG_SPI_MASTER
 640 static const struct of_device_id mcp23s08_spi_of_match[] = {
 641         {
 642                 .compatible = "microchip,mcp23s08",
 643                 .data = (void *) MCP_TYPE_S08,
 644         },
 645         {
 646                 .compatible = "microchip,mcp23s17",
 647                 .data = (void *) MCP_TYPE_S17,
 648         },
 649         {
 650                 .compatible = "microchip,mcp23s18",
 651                 .data = (void *) MCP_TYPE_S18,
 652         },
 653 /* NOTE: The use of the mcp prefix is deprecated and will be removed. */
 654         {
 655                 .compatible = "mcp,mcp23s08",
 656                 .data = (void *) MCP_TYPE_S08,
 657         },
 658         {
 659                 .compatible = "mcp,mcp23s17",
 660                 .data = (void *) MCP_TYPE_S17,
 661         },
 662         { },
 663 };
 664 MODULE_DEVICE_TABLE(of, mcp23s08_spi_of_match);
 665 #endif
 666
 667 #if IS_ENABLED(CONFIG_I2C)
 668 static const struct of_device_id mcp23s08_i2c_of_match[] = {
 669         {
 670                 .compatible = "microchip,mcp23008",
 671                 .data = (void *) MCP_TYPE_008,
 672         },
 673         {
 674                 .compatible = "microchip,mcp23017",
 675                 .data = (void *) MCP_TYPE_017,
 676         },
 677 /* NOTE: The use of the mcp prefix is deprecated and will be removed. */
 678         {
 679                 .compatible = "mcp,mcp23008",
 680                 .data = (void *) MCP_TYPE_008,
 681         },
 682         {
 683                 .compatible = "mcp,mcp23017",
 684                 .data = (void *) MCP_TYPE_017,
 685         },
 686         { },
 687 };
 688 MODULE_DEVICE_TABLE(of, mcp23s08_i2c_of_match);
 689 #endif
 690 #endif /* CONFIG_OF */
 691
 692
 693 #if IS_ENABLED(CONFIG_I2C)
 694
 695 static int mcp230xx_probe(struct i2c_client *client,
 696                                     const struct i2c_device_id *id)
 697 {
 698         struct mcp23s08_platform_data *pdata, local_pdata;
 699         struct mcp23s08 *mcp;
 700         int status;
 701         const struct of_device_id *match;
 702
 703         match = of_match_device(of_match_ptr(mcp23s08_i2c_of_match),
 704                                         &client->dev);
 705         if (match) {
 706                 pdata = &local_pdata;
 707                 pdata->base = -1;
 708                 pdata->chip[0].pullups = 0;
 709                 pdata->irq_controller = of_property_read_bool(
 710                                         client->dev.of_node,
 711                                         "interrupt-controller");
 712                 pdata->mirror = of_property_read_bool(client->dev.of_node,
 713                                                       "microchip,irq-mirror");
 714                 client->irq = irq_of_parse_and_map(client->dev.of_node, 0);
 715         } else {
 716                 pdata = dev_get_platdata(&client->dev);
 717                 if (!pdata) {
 718                         pdata = devm_kzalloc(&client->dev,
 719                                         sizeof(struct mcp23s08_platform_data),
 720                                         GFP_KERNEL);
 721                         if (!pdata)
 722                                 return -ENOMEM;
 723                         pdata->base = -1;
 724                 }
 725         }
 726
 727         mcp = kzalloc(sizeof(*mcp), GFP_KERNEL);
 728         if (!mcp)
 729                 return -ENOMEM;
 730
 731         mcp->irq = client->irq;
 732         status = mcp23s08_probe_one(mcp, &client->dev, client, client->addr,
 733                                     id->driver_data, pdata, 0);
 734         if (status)
 735                 goto fail;
 736
 737         i2c_set_clientdata(client, mcp);
 738
 739         return 0;
 740
 741 fail:
 742         kfree(mcp);
 743
 744         return status;
 745 }
 746
 747 static int mcp230xx_remove(struct i2c_client *client)
 748 {
 749         struct mcp23s08 *mcp = i2c_get_clientdata(client);
 750
 751         gpiochip_remove(&mcp->chip);
 752         kfree(mcp);
 753
 754         return 0;
 755 }
 756
 757 static const struct i2c_device_id mcp230xx_id[] = {
 758         { "mcp23008", MCP_TYPE_008 },
 759         { "mcp23017", MCP_TYPE_017 },
 760         { },
 761 };
 762 MODULE_DEVICE_TABLE(i2c, mcp230xx_id);
 763
 764 static struct i2c_driver mcp230xx_driver = {
 765         .driver = {
 766                 .name   = "mcp230xx",
 767                 .of_match_table = of_match_ptr(mcp23s08_i2c_of_match),
 768         },
 769         .probe          = mcp230xx_probe,
 770         .remove         = mcp230xx_remove,
 771         .id_table       = mcp230xx_id,
 772 };
 773
 774 static int __init mcp23s08_i2c_init(void)
 775 {
 776         return i2c_add_driver(&mcp230xx_driver);
 777 }
 778
 779 static void mcp23s08_i2c_exit(void)
 780 {
 781         i2c_del_driver(&mcp230xx_driver);
 782 }
 783
 784 #else
 785
 786 static int __init mcp23s08_i2c_init(void) { return 0; }
 787 static void mcp23s08_i2c_exit(void) { }
 788
 789 #endif /* CONFIG_I2C */
 790
 791 /*----------------------------------------------------------------------*/
 792
 793 #ifdef CONFIG_SPI_MASTER
 794
 795 static int mcp23s08_probe(struct spi_device *spi)
 796 {
 797         struct mcp23s08_platform_data   *pdata, local_pdata;
 798         unsigned                        addr;
 799         int                             chips = 0;
 800         struct mcp23s08_driver_data     *data;
 801         int                             status, type;
 802         unsigned                        ngpio = 0;
 803         const struct                    of_device_id *match;
 804         u32                             spi_present_mask = 0;
 805
 806         match = of_match_device(of_match_ptr(mcp23s08_spi_of_match), &spi->dev);
 807         if (match) {
 808                 type = (int)(uintptr_t)match->data;
 809                 status = of_property_read_u32(spi->dev.of_node,
 810                             "microchip,spi-present-mask", &spi_present_mask);
 811                 if (status) {
 812                         status = of_property_read_u32(spi->dev.of_node,
 813                                     "mcp,spi-present-mask", &spi_present_mask);
 814                         if (status) {
 815                                 dev_err(&spi->dev,
 816                                         "DT has no spi-present-mask\n");
 817                                 return -ENODEV;
 818                         }
 819                 }
 820                 if ((spi_present_mask <= 0) || (spi_present_mask >= 256)) {
 821                         dev_err(&spi->dev, "invalid spi-present-mask\n");
 822                         return -ENODEV;
 823                 }
 824
 825                 pdata = &local_pdata;
 826                 pdata->base = -1;
 827                 for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
 828                         pdata->chip[addr].pullups = 0;
 829                         if (spi_present_mask & (1 << addr))
 830                                 chips++;
 831                 }
 832                 pdata->irq_controller = of_property_read_bool(
 833                                         spi->dev.of_node,
 834                                         "interrupt-controller");
 835                 pdata->mirror = of_property_read_bool(spi->dev.of_node,
 836                                                       "microchip,irq-mirror");
 837         } else {
 838                 type = spi_get_device_id(spi)->driver_data;
 839                 pdata = dev_get_platdata(&spi->dev);
 840                 if (!pdata) {
 841                         pdata = devm_kzalloc(&spi->dev,
 842                                         sizeof(struct mcp23s08_platform_data),
 843                                         GFP_KERNEL);
 844                         pdata->base = -1;
 845                 }
 846
 847                 for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
 848                         if (!pdata->chip[addr].is_present)
 849                                 continue;
 850                         chips++;
 851                         if ((type == MCP_TYPE_S08) && (addr > 3)) {
 852                                 dev_err(&spi->dev,
 853                                         "mcp23s08 only supports address 0..3\n");
 854                                 return -EINVAL;
 855                         }
 856                         spi_present_mask |= 1 << addr;
 857                 }
 858         }
 859
 860         if (!chips)
 861                 return -ENODEV;
 862
 863         data = devm_kzalloc(&spi->dev,
 864                             sizeof(*data) + chips * sizeof(struct mcp23s08),
 865                             GFP_KERNEL);
 866         if (!data)
 867                 return -ENOMEM;
 868
 869         spi_set_drvdata(spi, data);
 870
 871         spi->irq = irq_of_parse_and_map(spi->dev.of_node, 0);
 872
 873         for (addr = 0; addr < ARRAY_SIZE(pdata->chip); addr++) {
 874                 if (!(spi_present_mask & (1 << addr)))
 875                         continue;
 876                 chips--;
 877                 data->mcp[addr] = &data->chip[chips];
 878                 data->mcp[addr]->irq = spi->irq;
 879                 status = mcp23s08_probe_one(data->mcp[addr], &spi->dev, spi,
 880                                             0x40 | (addr << 1), type, pdata,
 881                                             addr);
 882                 if (status < 0)
 883                         goto fail;
 884
 885                 if (pdata->base != -1)
 886                         pdata->base += data->mcp[addr]->chip.ngpio;
 887                 ngpio += data->mcp[addr]->chip.ngpio;
 888         }
 889         data->ngpio = ngpio;
 890
 891         /* NOTE:  these chips have a relatively sane IRQ framework, with
 892          * per-signal masking and level/edge triggering.  It's not yet
 893          * handled here...
 894          */
 895
 896         return 0;
 897
 898 fail:
 899         for (addr = 0; addr < ARRAY_SIZE(data->mcp); addr++) {
 900
 901                 if (!data->mcp[addr])
 902                         continue;
 903                 gpiochip_remove(&data->mcp[addr]->chip);
 904         }
 905         return status;
 906 }
 907
 908 static int mcp23s08_remove(struct spi_device *spi)
 909 {
 910         struct mcp23s08_driver_data     *data = spi_get_drvdata(spi);
 911         unsigned                        addr;
 912
 913         for (addr = 0; addr < ARRAY_SIZE(data->mcp); addr++) {
 914
 915                 if (!data->mcp[addr])
 916                         continue;
 917
 918                 gpiochip_remove(&data->mcp[addr]->chip);
 919         }
 920
 921         return 0;
 922 }
 923
 924 static const struct spi_device_id mcp23s08_ids[] = {
 925         { "mcp23s08", MCP_TYPE_S08 },
 926         { "mcp23s17", MCP_TYPE_S17 },
 927         { "mcp23s18", MCP_TYPE_S18 },
 928         { },
 929 };
 930 MODULE_DEVICE_TABLE(spi, mcp23s08_ids);
 931
 932 static struct spi_driver mcp23s08_driver = {
 933         .probe          = mcp23s08_probe,
 934         .remove         = mcp23s08_remove,
 935         .id_table       = mcp23s08_ids,
 936         .driver = {
 937                 .name   = "mcp23s08",
 938                 .of_match_table = of_match_ptr(mcp23s08_spi_of_match),
 939         },
 940 };
 941
 942 static int __init mcp23s08_spi_init(void)
 943 {
 944         return spi_register_driver(&mcp23s08_driver);
 945 }
 946
 947 static void mcp23s08_spi_exit(void)
 948 {
 949         spi_unregister_driver(&mcp23s08_driver);
 950 }
 951
 952 #else
 953
 954 static int __init mcp23s08_spi_init(void) { return 0; }
 955 static void mcp23s08_spi_exit(void) { }
 956
 957 #endif /* CONFIG_SPI_MASTER */
 958
 959 /*----------------------------------------------------------------------*/
 960
 961 static int __init mcp23s08_init(void)
 962 {
 963         int ret;
 964
 965         ret = mcp23s08_spi_init();
 966         if (ret)
 967                 goto spi_fail;
 968
 969         ret = mcp23s08_i2c_init();
 970         if (ret)
 971                 goto i2c_fail;
 972
 973         return 0;
 974
 975  i2c_fail:
 976         mcp23s08_spi_exit();
 977  spi_fail:
 978         return ret;
 979 }
 980 /* register after spi/i2c postcore initcall and before
 981  * subsys initcalls that may rely on these GPIOs
 982  */
 983 subsys_initcall(mcp23s08_init);
 984
 985 static void __exit mcp23s08_exit(void)
 986 {
 987         mcp23s08_spi_exit();
 988         mcp23s08_i2c_exit();
 989 }
 990 module_exit(mcp23s08_exit);
 991
 992 MODULE_LICENSE("GPL");