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 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 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 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 133 static 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 161 static 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; 186 exit: 187 mutex_unlock(&chip->i2c_lock); 188 return ret; 189 } 190 191 static 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; 237 exit: 238 mutex_unlock(&chip->i2c_lock); 239 return ret; 240 } 241 242 static 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, ®_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 272 static 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; 299 exit: 300 mutex_unlock(&chip->i2c_lock); 301 } 302 303 static 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 324 static 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 332 static 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 339 static 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 346 static 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 353 static 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 372 static 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 397 static 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 406 static 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 444 static 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 465 static 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 532 out_failed: 533 chip->irq_base = -1; 534 return ret; 535 } 536 537 static 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 */ 545 static 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 557 static 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 */ 570 static void 571 pca953x_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 598 static void 599 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, u32 *invert) 600 { 601 *gpio_base = -1; 602 } 603 #endif 604 605 static 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); 620 out: 621 return ret; 622 } 623 624 static 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; 651 out: 652 return ret; 653 } 654 655 static 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 719 out_failed_irq: 720 pca953x_irq_teardown(chip); 721 out_failed: 722 kfree(chip); 723 return ret; 724 } 725 726 static 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 754 static 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 763 static 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 */ 770 subsys_initcall(pca953x_init); 771 772 static void __exit pca953x_exit(void) 773 { 774 i2c_del_driver(&pca953x_driver); 775 } 776 module_exit(pca953x_exit); 777 778 MODULE_AUTHOR("eric miao <eric.miao@marvell.com>"); 779 MODULE_DESCRIPTION("GPIO expander driver for PCA953x"); 780 MODULE_LICENSE("GPL"); 781