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