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