drivers/gpio/gpio-pca953x.c

   1 /*
   2  *  PCA953x 4/8/16 bit I/O ports
   3  *
   4  *  Copyright (C) 2005 Ben Gardner <bgardner@wabtec.com>
   5  *  Copyright (C) 2007 Marvell International Ltd.
   6  *
   7  *  Derived from drivers/i2c/chips/pca9539.c
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; version 2 of the License.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/gpio.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/irq.h>
  19 #include <linux/irqdomain.h>
  20 #include <linux/i2c.h>
  21 #include <linux/i2c/pca953x.h>
  22 #include <linux/slab.h>
  23 #ifdef CONFIG_OF_GPIO
  24 #include <linux/of_platform.h>
  25 #endif
  26
  27 #define PCA953X_INPUT           0
  28 #define PCA953X_OUTPUT          1
  29 #define PCA953X_INVERT          2
  30 #define PCA953X_DIRECTION       3
  31
  32 #define REG_ADDR_AI             0x80
  33
  34 #define PCA957X_IN              0
  35 #define PCA957X_INVRT           1
  36 #define PCA957X_BKEN            2
  37 #define PCA957X_PUPD            3
  38 #define PCA957X_CFG             4
  39 #define PCA957X_OUT             5
  40 #define PCA957X_MSK             6
  41 #define PCA957X_INTS            7
  42
  43 #define PCA_GPIO_MASK           0x00FF
  44 #define PCA_INT                 0x0100
  45 #define PCA953X_TYPE            0x1000
  46 #define PCA957X_TYPE            0x2000
  47
  48 static const struct i2c_device_id pca953x_id[] = {
  49         { "pca9534", 8  | PCA953X_TYPE | PCA_INT, },
  50         { "pca9535", 16 | PCA953X_TYPE | PCA_INT, },
  51         { "pca9536", 4  | PCA953X_TYPE, },
  52         { "pca9537", 4  | PCA953X_TYPE | PCA_INT, },
  53         { "pca9538", 8  | PCA953X_TYPE | PCA_INT, },
  54         { "pca9539", 16 | PCA953X_TYPE | PCA_INT, },
  55         { "pca9554", 8  | PCA953X_TYPE | PCA_INT, },
  56         { "pca9555", 16 | PCA953X_TYPE | PCA_INT, },
  57         { "pca9556", 8  | PCA953X_TYPE, },
  58         { "pca9557", 8  | PCA953X_TYPE, },
  59         { "pca9574", 8  | PCA957X_TYPE | PCA_INT, },
  60         { "pca9575", 16 | PCA957X_TYPE | PCA_INT, },
  61
  62         { "max7310", 8  | PCA953X_TYPE, },
  63         { "max7312", 16 | PCA953X_TYPE | PCA_INT, },
  64         { "max7313", 16 | PCA953X_TYPE | PCA_INT, },
  65         { "max7315", 8  | PCA953X_TYPE | PCA_INT, },
  66         { "pca6107", 8  | PCA953X_TYPE | PCA_INT, },
  67         { "tca6408", 8  | PCA953X_TYPE | PCA_INT, },
  68         { "tca6416", 16 | PCA953X_TYPE | PCA_INT, },
  69         { "tca6424", 24 | PCA953X_TYPE | PCA_INT, },
  70         { }
  71 };
  72 MODULE_DEVICE_TABLE(i2c, pca953x_id);
  73
  74 struct pca953x_chip {
  75         unsigned gpio_start;
  76         u32 reg_output;
  77         u32 reg_direction;
  78         struct mutex i2c_lock;
  79
  80 #ifdef CONFIG_GPIO_PCA953X_IRQ
  81         struct mutex irq_lock;
  82         u32 irq_mask;
  83         u32 irq_stat;
  84         u32 irq_trig_raise;
  85         u32 irq_trig_fall;
  86         int      irq_base;
  87         struct irq_domain *domain;
  88 #endif
  89
  90         struct i2c_client *client;
  91         struct gpio_chip gpio_chip;
  92         const char *const *names;
  93         int     chip_type;
  94 };
  95
  96 static int pca953x_write_reg(struct pca953x_chip *chip, int reg, u32 val)
  97 {
  98         int ret = 0;
  99
 100         if (chip->gpio_chip.ngpio <= 8)
 101                 ret = i2c_smbus_write_byte_data(chip->client, reg, val);
 102         else if (chip->gpio_chip.ngpio == 24) {
 103                 cpu_to_le32s(&val);
 104                 ret = i2c_smbus_write_i2c_block_data(chip->client,
 105                                                 (reg << 2) | REG_ADDR_AI,
 106                                                 3,
 107                                                 (u8 *) &val);
 108         }
 109         else {
 110                 switch (chip->chip_type) {
 111                 case PCA953X_TYPE:
 112                         ret = i2c_smbus_write_word_data(chip->client,
 113                                                         reg << 1, val);
 114                         break;
 115                 case PCA957X_TYPE:
 116                         ret = i2c_smbus_write_byte_data(chip->client, reg << 1,
 117                                                         val & 0xff);
 118                         if (ret < 0)
 119                                 break;
 120                         ret = i2c_smbus_write_byte_data(chip->client,
 121                                                         (reg << 1) + 1,
 122                                                         (val & 0xff00) >> 8);
 123                         break;
 124                 }
 125         }
 126
 127         if (ret < 0) {
 128                 dev_err(&chip->client->dev, "failed writing register\n");
 129                 return ret;
 130         }
 131
 132         return 0;
 133 }
 134
 135 static int pca953x_read_reg(struct pca953x_chip *chip, int reg, u32 *val)
 136 {
 137         int ret;
 138
 139         if (chip->gpio_chip.ngpio <= 8) {
 140                 ret = i2c_smbus_read_byte_data(chip->client, reg);
 141                 *val = ret;
 142         }
 143         else if (chip->gpio_chip.ngpio == 24) {
 144                 *val = 0;
 145                 ret = i2c_smbus_read_i2c_block_data(chip->client,
 146                                                 (reg << 2) | REG_ADDR_AI,
 147                                                 3,
 148                                                 (u8 *) val);
 149                 le32_to_cpus(val);
 150         } else {
 151                 ret = i2c_smbus_read_word_data(chip->client, reg << 1);
 152                 *val = ret;
 153         }
 154
 155         if (ret < 0) {
 156                 dev_err(&chip->client->dev, "failed reading register\n");
 157                 return ret;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
 164 {
 165         struct pca953x_chip *chip;
 166         uint reg_val;
 167         int ret, offset = 0;
 168
 169         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 170
 171         mutex_lock(&chip->i2c_lock);
 172         reg_val = chip->reg_direction | (1u << off);
 173
 174         switch (chip->chip_type) {
 175         case PCA953X_TYPE:
 176                 offset = PCA953X_DIRECTION;
 177                 break;
 178         case PCA957X_TYPE:
 179                 offset = PCA957X_CFG;
 180                 break;
 181         }
 182         ret = pca953x_write_reg(chip, offset, reg_val);
 183         if (ret)
 184                 goto exit;
 185
 186         chip->reg_direction = reg_val;
 187         ret = 0;
 188 exit:
 189         mutex_unlock(&chip->i2c_lock);
 190         return ret;
 191 }
 192
 193 static int pca953x_gpio_direction_output(struct gpio_chip *gc,
 194                 unsigned off, int val)
 195 {
 196         struct pca953x_chip *chip;
 197         uint reg_val;
 198         int ret, offset = 0;
 199
 200         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 201
 202         mutex_lock(&chip->i2c_lock);
 203         /* set output level */
 204         if (val)
 205                 reg_val = chip->reg_output | (1u << off);
 206         else
 207                 reg_val = chip->reg_output & ~(1u << off);
 208
 209         switch (chip->chip_type) {
 210         case PCA953X_TYPE:
 211                 offset = PCA953X_OUTPUT;
 212                 break;
 213         case PCA957X_TYPE:
 214                 offset = PCA957X_OUT;
 215                 break;
 216         }
 217         ret = pca953x_write_reg(chip, offset, reg_val);
 218         if (ret)
 219                 goto exit;
 220
 221         chip->reg_output = reg_val;
 222
 223         /* then direction */
 224         reg_val = chip->reg_direction & ~(1u << off);
 225         switch (chip->chip_type) {
 226         case PCA953X_TYPE:
 227                 offset = PCA953X_DIRECTION;
 228                 break;
 229         case PCA957X_TYPE:
 230                 offset = PCA957X_CFG;
 231                 break;
 232         }
 233         ret = pca953x_write_reg(chip, offset, reg_val);
 234         if (ret)
 235                 goto exit;
 236
 237         chip->reg_direction = reg_val;
 238         ret = 0;
 239 exit:
 240         mutex_unlock(&chip->i2c_lock);
 241         return ret;
 242 }
 243
 244 static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 245 {
 246         struct pca953x_chip *chip;
 247         u32 reg_val;
 248         int ret, offset = 0;
 249
 250         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 251
 252         mutex_lock(&chip->i2c_lock);
 253         switch (chip->chip_type) {
 254         case PCA953X_TYPE:
 255                 offset = PCA953X_INPUT;
 256                 break;
 257         case PCA957X_TYPE:
 258                 offset = PCA957X_IN;
 259                 break;
 260         }
 261         ret = pca953x_read_reg(chip, offset, &reg_val);
 262         mutex_unlock(&chip->i2c_lock);
 263         if (ret < 0) {
 264                 /* NOTE:  diagnostic already emitted; that's all we should
 265                  * do unless gpio_*_value_cansleep() calls become different
 266                  * from their nonsleeping siblings (and report faults).
 267                  */
 268                 return 0;
 269         }
 270
 271         return (reg_val & (1u << off)) ? 1 : 0;
 272 }
 273
 274 static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
 275 {
 276         struct pca953x_chip *chip;
 277         u32 reg_val;
 278         int ret, offset = 0;
 279
 280         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 281
 282         mutex_lock(&chip->i2c_lock);
 283         if (val)
 284                 reg_val = chip->reg_output | (1u << off);
 285         else
 286                 reg_val = chip->reg_output & ~(1u << off);
 287
 288         switch (chip->chip_type) {
 289         case PCA953X_TYPE:
 290                 offset = PCA953X_OUTPUT;
 291                 break;
 292         case PCA957X_TYPE:
 293                 offset = PCA957X_OUT;
 294                 break;
 295         }
 296         ret = pca953x_write_reg(chip, offset, reg_val);
 297         if (ret)
 298                 goto exit;
 299
 300         chip->reg_output = reg_val;
 301 exit:
 302         mutex_unlock(&chip->i2c_lock);
 303 }
 304
 305 static void pca953x_setup_gpio(struct pca953x_chip *chip, int gpios)
 306 {
 307         struct gpio_chip *gc;
 308
 309         gc = &chip->gpio_chip;
 310
 311         gc->direction_input  = pca953x_gpio_direction_input;
 312         gc->direction_output = pca953x_gpio_direction_output;
 313         gc->get = pca953x_gpio_get_value;
 314         gc->set = pca953x_gpio_set_value;
 315         gc->can_sleep = 1;
 316
 317         gc->base = chip->gpio_start;
 318         gc->ngpio = gpios;
 319         gc->label = chip->client->name;
 320         gc->dev = &chip->client->dev;
 321         gc->owner = THIS_MODULE;
 322         gc->names = chip->names;
 323 }
 324
 325 #ifdef CONFIG_GPIO_PCA953X_IRQ
 326 static int pca953x_gpio_to_irq(struct gpio_chip *gc, unsigned off)
 327 {
 328         struct pca953x_chip *chip;
 329
 330         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 331         return chip->irq_base + off;
 332 }
 333
 334 static void pca953x_irq_mask(struct irq_data *d)
 335 {
 336         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 337
 338         chip->irq_mask &= ~(1 << d->hwirq);
 339 }
 340
 341 static void pca953x_irq_unmask(struct irq_data *d)
 342 {
 343         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 344
 345         chip->irq_mask |= 1 << d->hwirq;
 346 }
 347
 348 static void pca953x_irq_bus_lock(struct irq_data *d)
 349 {
 350         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 351
 352         mutex_lock(&chip->irq_lock);
 353 }
 354
 355 static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
 356 {
 357         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 358         u32 new_irqs;
 359         u32 level;
 360
 361         /* Look for any newly setup interrupt */
 362         new_irqs = chip->irq_trig_fall | chip->irq_trig_raise;
 363         new_irqs &= ~chip->reg_direction;
 364
 365         while (new_irqs) {
 366                 level = __ffs(new_irqs);
 367                 pca953x_gpio_direction_input(&chip->gpio_chip, level);
 368                 new_irqs &= ~(1 << level);
 369         }
 370
 371         mutex_unlock(&chip->irq_lock);
 372 }
 373
 374 static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
 375 {
 376         struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 377         u32 mask = 1 << d->hwirq;
 378
 379         if (!(type & IRQ_TYPE_EDGE_BOTH)) {
 380                 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
 381                         d->irq, type);
 382                 return -EINVAL;
 383         }
 384
 385         if (type & IRQ_TYPE_EDGE_FALLING)
 386                 chip->irq_trig_fall |= mask;
 387         else
 388                 chip->irq_trig_fall &= ~mask;
 389
 390         if (type & IRQ_TYPE_EDGE_RISING)
 391                 chip->irq_trig_raise |= mask;
 392         else
 393                 chip->irq_trig_raise &= ~mask;
 394
 395         return 0;
 396 }
 397
 398 static struct irq_chip pca953x_irq_chip = {
 399         .name                   = "pca953x",
 400         .irq_mask               = pca953x_irq_mask,
 401         .irq_unmask             = pca953x_irq_unmask,
 402         .irq_bus_lock           = pca953x_irq_bus_lock,
 403         .irq_bus_sync_unlock    = pca953x_irq_bus_sync_unlock,
 404         .irq_set_type           = pca953x_irq_set_type,
 405 };
 406
 407 static u32 pca953x_irq_pending(struct pca953x_chip *chip)
 408 {
 409         u32 cur_stat;
 410         u32 old_stat;
 411         u32 pending;
 412         u32 trigger;
 413         int ret, offset = 0;
 414
 415         switch (chip->chip_type) {
 416         case PCA953X_TYPE:
 417                 offset = PCA953X_INPUT;
 418                 break;
 419         case PCA957X_TYPE:
 420                 offset = PCA957X_IN;
 421                 break;
 422         }
 423         ret = pca953x_read_reg(chip, offset, &cur_stat);
 424         if (ret)
 425                 return 0;
 426
 427         /* Remove output pins from the equation */
 428         cur_stat &= chip->reg_direction;
 429
 430         old_stat = chip->irq_stat;
 431         trigger = (cur_stat ^ old_stat) & chip->irq_mask;
 432
 433         if (!trigger)
 434                 return 0;
 435
 436         chip->irq_stat = cur_stat;
 437
 438         pending = (old_stat & chip->irq_trig_fall) |
 439                   (cur_stat & chip->irq_trig_raise);
 440         pending &= trigger;
 441
 442         return pending;
 443 }
 444
 445 static irqreturn_t pca953x_irq_handler(int irq, void *devid)
 446 {
 447         struct pca953x_chip *chip = devid;
 448         u32 pending;
 449         u32 level;
 450
 451         pending = pca953x_irq_pending(chip);
 452
 453         if (!pending)
 454                 return IRQ_HANDLED;
 455
 456         do {
 457                 level = __ffs(pending);
 458                 handle_nested_irq(irq_find_mapping(chip->domain, level));
 459
 460                 pending &= ~(1 << level);
 461         } while (pending);
 462
 463         return IRQ_HANDLED;
 464 }
 465
 466 static int pca953x_irq_setup(struct pca953x_chip *chip,
 467                              const struct i2c_device_id *id,
 468                              int irq_base)
 469 {
 470         struct i2c_client *client = chip->client;
 471         int ret, offset = 0;
 472         u32 temporary;
 473
 474         if (irq_base != -1
 475                         && (id->driver_data & PCA_INT)) {
 476                 int lvl;
 477
 478                 switch (chip->chip_type) {
 479                 case PCA953X_TYPE:
 480                         offset = PCA953X_INPUT;
 481                         break;
 482                 case PCA957X_TYPE:
 483                         offset = PCA957X_IN;
 484                         break;
 485                 }
 486                 ret = pca953x_read_reg(chip, offset, &temporary);
 487                 chip->irq_stat = temporary;
 488                 if (ret)
 489                         goto out_failed;
 490
 491                 /*
 492                  * There is no way to know which GPIO line generated the
 493                  * interrupt.  We have to rely on the previous read for
 494                  * this purpose.
 495                  */
 496                 chip->irq_stat &= chip->reg_direction;
 497                 mutex_init(&chip->irq_lock);
 498
 499                 chip->irq_base = irq_alloc_descs(-1, irq_base, chip->gpio_chip.ngpio, -1);
 500                 if (chip->irq_base < 0)
 501                         goto out_failed;
 502
 503                 chip->domain = irq_domain_add_legacy(client->dev.of_node,
 504                                                 chip->gpio_chip.ngpio,
 505                                                 chip->irq_base,
 506                                                 0,
 507                                                 &irq_domain_simple_ops,
 508                                                 NULL);
 509                 if (!chip->domain) {
 510                         ret = -ENODEV;
 511                         goto out_irqdesc_free;
 512                 }
 513
 514                 for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
 515                         int irq = lvl + chip->irq_base;
 516
 517                         irq_clear_status_flags(irq, IRQ_NOREQUEST);
 518                         irq_set_chip_data(irq, chip);
 519                         irq_set_chip(irq, &pca953x_irq_chip);
 520                         irq_set_nested_thread(irq, true);
 521 #ifdef CONFIG_ARM
 522                         set_irq_flags(irq, IRQF_VALID);
 523 #else
 524                         irq_set_noprobe(irq);
 525 #endif
 526                 }
 527
 528                 ret = request_threaded_irq(client->irq,
 529                                            NULL,
 530                                            pca953x_irq_handler,
 531                                            IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 532                                            dev_name(&client->dev), chip);
 533                 if (ret) {
 534                         dev_err(&client->dev, "failed to request irq %d\n",
 535                                 client->irq);
 536                         goto out_irqdesc_free;
 537                 }
 538
 539                 chip->gpio_chip.to_irq = pca953x_gpio_to_irq;
 540         }
 541
 542         return 0;
 543
 544 out_irqdesc_free:
 545         irq_free_descs(chip->irq_base, chip->gpio_chip.ngpio);
 546 out_failed:
 547         chip->irq_base = -1;
 548         return ret;
 549 }
 550
 551 static void pca953x_irq_teardown(struct pca953x_chip *chip)
 552 {
 553         if (chip->irq_base != -1) {
 554                 irq_free_descs(chip->irq_base, chip->gpio_chip.ngpio);
 555                 free_irq(chip->client->irq, chip);
 556         }
 557 }
 558 #else /* CONFIG_GPIO_PCA953X_IRQ */
 559 static int pca953x_irq_setup(struct pca953x_chip *chip,
 560                              const struct i2c_device_id *id,
 561                              int irq_base)
 562 {
 563         struct i2c_client *client = chip->client;
 564
 565         if (irq_base != -1 && (id->driver_data & PCA_INT))
 566                 dev_warn(&client->dev, "interrupt support not compiled in\n");
 567
 568         return 0;
 569 }
 570
 571 static void pca953x_irq_teardown(struct pca953x_chip *chip)
 572 {
 573 }
 574 #endif
 575
 576 /*
 577  * Handlers for alternative sources of platform_data
 578  */
 579 #ifdef CONFIG_OF_GPIO
 580 /*
 581  * Translate OpenFirmware node properties into platform_data
 582  * WARNING: This is DEPRECATED and will be removed eventually!
 583  */
 584 static void
 585 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, u32 *invert)
 586 {
 587         struct device_node *node;
 588         const __be32 *val;
 589         int size;
 590
 591         node = client->dev.of_node;
 592         if (node == NULL)
 593                 return;
 594
 595         *gpio_base = -1;
 596         val = of_get_property(node, "linux,gpio-base", &size);
 597         WARN(val, "%s: device-tree property 'linux,gpio-base' is deprecated!", __func__);
 598         if (val) {
 599                 if (size != sizeof(*val))
 600                         dev_warn(&client->dev, "%s: wrong linux,gpio-base\n",
 601                                  node->full_name);
 602                 else
 603                         *gpio_base = be32_to_cpup(val);
 604         }
 605
 606         val = of_get_property(node, "polarity", NULL);
 607         WARN(val, "%s: device-tree property 'polarity' is deprecated!", __func__);
 608         if (val)
 609                 *invert = *val;
 610 }
 611 #else
 612 static void
 613 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, u32 *invert)
 614 {
 615         *gpio_base = -1;
 616 }
 617 #endif
 618
 619 static int device_pca953x_init(struct pca953x_chip *chip, u32 invert)
 620 {
 621         int ret;
 622
 623         ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
 624         if (ret)
 625                 goto out;
 626
 627         ret = pca953x_read_reg(chip, PCA953X_DIRECTION,
 628                                &chip->reg_direction);
 629         if (ret)
 630                 goto out;
 631
 632         /* set platform specific polarity inversion */
 633         ret = pca953x_write_reg(chip, PCA953X_INVERT, invert);
 634 out:
 635         return ret;
 636 }
 637
 638 static int device_pca957x_init(struct pca953x_chip *chip, u32 invert)
 639 {
 640         int ret;
 641         u32 val = 0;
 642
 643         /* Let every port in proper state, that could save power */
 644         pca953x_write_reg(chip, PCA957X_PUPD, 0x0);
 645         pca953x_write_reg(chip, PCA957X_CFG, 0xffff);
 646         pca953x_write_reg(chip, PCA957X_OUT, 0x0);
 647
 648         ret = pca953x_read_reg(chip, PCA957X_IN, &val);
 649         if (ret)
 650                 goto out;
 651         ret = pca953x_read_reg(chip, PCA957X_OUT, &chip->reg_output);
 652         if (ret)
 653                 goto out;
 654         ret = pca953x_read_reg(chip, PCA957X_CFG, &chip->reg_direction);
 655         if (ret)
 656                 goto out;
 657
 658         /* set platform specific polarity inversion */
 659         pca953x_write_reg(chip, PCA957X_INVRT, invert);
 660
 661         /* To enable register 6, 7 to controll pull up and pull down */
 662         pca953x_write_reg(chip, PCA957X_BKEN, 0x202);
 663
 664         return 0;
 665 out:
 666         return ret;
 667 }
 668
 669 static int pca953x_probe(struct i2c_client *client,
 670                                    const struct i2c_device_id *id)
 671 {
 672         struct pca953x_platform_data *pdata;
 673         struct pca953x_chip *chip;
 674         int irq_base = 0;
 675         int ret;
 676         u32 invert = 0;
 677
 678         chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
 679         if (chip == NULL)
 680                 return -ENOMEM;
 681
 682         pdata = client->dev.platform_data;
 683         if (pdata) {
 684                 irq_base = pdata->irq_base;
 685                 chip->gpio_start = pdata->gpio_base;
 686                 invert = pdata->invert;
 687                 chip->names = pdata->names;
 688         } else {
 689                 pca953x_get_alt_pdata(client, &chip->gpio_start, &invert);
 690 #ifdef CONFIG_OF_GPIO
 691                 /* If I2C node has no interrupts property, disable GPIO interrupts */
 692                 if (of_find_property(client->dev.of_node, "interrupts", NULL) == NULL)
 693                         irq_base = -1;
 694 #endif
 695         }
 696
 697         chip->client = client;
 698
 699         chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE);
 700
 701         mutex_init(&chip->i2c_lock);
 702
 703         /* initialize cached registers from their original values.
 704          * we can't share this chip with another i2c master.
 705          */
 706         pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK);
 707
 708         if (chip->chip_type == PCA953X_TYPE)
 709                 ret = device_pca953x_init(chip, invert);
 710         else
 711                 ret = device_pca957x_init(chip, invert);
 712         if (ret)
 713                 goto out_failed;
 714
 715         ret = pca953x_irq_setup(chip, id, irq_base);
 716         if (ret)
 717                 goto out_failed;
 718
 719         ret = gpiochip_add(&chip->gpio_chip);
 720         if (ret)
 721                 goto out_failed_irq;
 722
 723         if (pdata && pdata->setup) {
 724                 ret = pdata->setup(client, chip->gpio_chip.base,
 725                                 chip->gpio_chip.ngpio, pdata->context);
 726                 if (ret < 0)
 727                         dev_warn(&client->dev, "setup failed, %d\n", ret);
 728         }
 729
 730         i2c_set_clientdata(client, chip);
 731         return 0;
 732
 733 out_failed_irq:
 734         pca953x_irq_teardown(chip);
 735 out_failed:
 736         kfree(chip);
 737         return ret;
 738 }
 739
 740 static int pca953x_remove(struct i2c_client *client)
 741 {
 742         struct pca953x_platform_data *pdata = client->dev.platform_data;
 743         struct pca953x_chip *chip = i2c_get_clientdata(client);
 744         int ret = 0;
 745
 746         if (pdata && pdata->teardown) {
 747                 ret = pdata->teardown(client, chip->gpio_chip.base,
 748                                 chip->gpio_chip.ngpio, pdata->context);
 749                 if (ret < 0) {
 750                         dev_err(&client->dev, "%s failed, %d\n",
 751                                         "teardown", ret);
 752                         return ret;
 753                 }
 754         }
 755
 756         ret = gpiochip_remove(&chip->gpio_chip);
 757         if (ret) {
 758                 dev_err(&client->dev, "%s failed, %d\n",
 759                                 "gpiochip_remove()", ret);
 760                 return ret;
 761         }
 762
 763         pca953x_irq_teardown(chip);
 764         kfree(chip);
 765         return 0;
 766 }
 767
 768 static const struct of_device_id pca953x_dt_ids[] = {
 769         { .compatible = "nxp,pca9534", },
 770         { .compatible = "nxp,pca9535", },
 771         { .compatible = "nxp,pca9536", },
 772         { .compatible = "nxp,pca9537", },
 773         { .compatible = "nxp,pca9538", },
 774         { .compatible = "nxp,pca9539", },
 775         { .compatible = "nxp,pca9554", },
 776         { .compatible = "nxp,pca9555", },
 777         { .compatible = "nxp,pca9556", },
 778         { .compatible = "nxp,pca9557", },
 779         { .compatible = "nxp,pca9574", },
 780         { .compatible = "nxp,pca9575", },
 781
 782         { .compatible = "maxim,max7310", },
 783         { .compatible = "maxim,max7312", },
 784         { .compatible = "maxim,max7313", },
 785         { .compatible = "maxim,max7315", },
 786
 787         { .compatible = "ti,pca6107", },
 788         { .compatible = "ti,tca6408", },
 789         { .compatible = "ti,tca6416", },
 790         { .compatible = "ti,tca6424", },
 791         { }
 792 };
 793
 794 MODULE_DEVICE_TABLE(of, pca953x_dt_ids);
 795
 796 static struct i2c_driver pca953x_driver = {
 797         .driver = {
 798                 .name   = "pca953x",
 799                 .of_match_table = pca953x_dt_ids,
 800         },
 801         .probe          = pca953x_probe,
 802         .remove         = pca953x_remove,
 803         .id_table       = pca953x_id,
 804 };
 805
 806 static int __init pca953x_init(void)
 807 {
 808         return i2c_add_driver(&pca953x_driver);
 809 }
 810 /* register after i2c postcore initcall and before
 811  * subsys initcalls that may rely on these GPIOs
 812  */
 813 subsys_initcall(pca953x_init);
 814
 815 static void __exit pca953x_exit(void)
 816 {
 817         i2c_del_driver(&pca953x_driver);
 818 }
 819 module_exit(pca953x_exit);
 820
 821 MODULE_AUTHOR("eric miao <eric.miao@marvell.com>");
 822 MODULE_DESCRIPTION("GPIO expander driver for PCA953x");
 823 MODULE_LICENSE("GPL");