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