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, ®_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 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 void 578 pca953x_get_alt_pdata(struct i2c_client *client, int *gpio_base, int *invert) 579 { 580 } 581 #endif 582 583 static int __devinit device_pca953x_init(struct pca953x_chip *chip, int invert) 584 { 585 int ret; 586 587 ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output); 588 if (ret) 589 goto out; 590 591 ret = pca953x_read_reg(chip, PCA953X_DIRECTION, 592 &chip->reg_direction); 593 if (ret) 594 goto out; 595 596 /* set platform specific polarity inversion */ 597 ret = pca953x_write_reg(chip, PCA953X_INVERT, invert); 598 if (ret) 599 goto out; 600 return 0; 601 out: 602 return ret; 603 } 604 605 static int __devinit device_pca957x_init(struct pca953x_chip *chip, int invert) 606 { 607 int ret; 608 uint16_t val = 0; 609 610 /* Let every port in proper state, that could save power */ 611 pca953x_write_reg(chip, PCA957X_PUPD, 0x0); 612 pca953x_write_reg(chip, PCA957X_CFG, 0xffff); 613 pca953x_write_reg(chip, PCA957X_OUT, 0x0); 614 615 ret = pca953x_read_reg(chip, PCA957X_IN, &val); 616 if (ret) 617 goto out; 618 ret = pca953x_read_reg(chip, PCA957X_OUT, &chip->reg_output); 619 if (ret) 620 goto out; 621 ret = pca953x_read_reg(chip, PCA957X_CFG, &chip->reg_direction); 622 if (ret) 623 goto out; 624 625 /* set platform specific polarity inversion */ 626 pca953x_write_reg(chip, PCA957X_INVRT, invert); 627 628 /* To enable register 6, 7 to controll pull up and pull down */ 629 pca953x_write_reg(chip, PCA957X_BKEN, 0x202); 630 631 return 0; 632 out: 633 return ret; 634 } 635 636 static int __devinit pca953x_probe(struct i2c_client *client, 637 const struct i2c_device_id *id) 638 { 639 struct pca953x_platform_data *pdata; 640 struct pca953x_chip *chip; 641 int irq_base=0, invert=0; 642 int ret = 0; 643 644 chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL); 645 if (chip == NULL) 646 return -ENOMEM; 647 648 pdata = client->dev.platform_data; 649 if (pdata) { 650 irq_base = pdata->irq_base; 651 chip->gpio_start = pdata->gpio_base; 652 invert = pdata->invert; 653 chip->names = pdata->names; 654 } else { 655 pca953x_get_alt_pdata(client, &chip->gpio_start, &invert); 656 #ifdef CONFIG_OF_GPIO 657 /* If I2C node has no interrupts property, disable GPIO interrupts */ 658 if (of_find_property(client->dev.of_node, "interrupts", NULL) == NULL) 659 irq_base = -1; 660 #endif 661 } 662 663 chip->client = client; 664 665 chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE); 666 667 mutex_init(&chip->i2c_lock); 668 669 /* initialize cached registers from their original values. 670 * we can't share this chip with another i2c master. 671 */ 672 pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK); 673 674 if (chip->chip_type == PCA953X_TYPE) 675 device_pca953x_init(chip, invert); 676 else if (chip->chip_type == PCA957X_TYPE) 677 device_pca957x_init(chip, invert); 678 else 679 goto out_failed; 680 681 ret = pca953x_irq_setup(chip, id, irq_base); 682 if (ret) 683 goto out_failed; 684 685 ret = gpiochip_add(&chip->gpio_chip); 686 if (ret) 687 goto out_failed_irq; 688 689 if (pdata && pdata->setup) { 690 ret = pdata->setup(client, chip->gpio_chip.base, 691 chip->gpio_chip.ngpio, pdata->context); 692 if (ret < 0) 693 dev_warn(&client->dev, "setup failed, %d\n", ret); 694 } 695 696 i2c_set_clientdata(client, chip); 697 return 0; 698 699 out_failed_irq: 700 pca953x_irq_teardown(chip); 701 out_failed: 702 kfree(chip); 703 return ret; 704 } 705 706 static int pca953x_remove(struct i2c_client *client) 707 { 708 struct pca953x_platform_data *pdata = client->dev.platform_data; 709 struct pca953x_chip *chip = i2c_get_clientdata(client); 710 int ret = 0; 711 712 if (pdata && pdata->teardown) { 713 ret = pdata->teardown(client, chip->gpio_chip.base, 714 chip->gpio_chip.ngpio, pdata->context); 715 if (ret < 0) { 716 dev_err(&client->dev, "%s failed, %d\n", 717 "teardown", ret); 718 return ret; 719 } 720 } 721 722 ret = gpiochip_remove(&chip->gpio_chip); 723 if (ret) { 724 dev_err(&client->dev, "%s failed, %d\n", 725 "gpiochip_remove()", ret); 726 return ret; 727 } 728 729 pca953x_irq_teardown(chip); 730 kfree(chip); 731 return 0; 732 } 733 734 static struct i2c_driver pca953x_driver = { 735 .driver = { 736 .name = "pca953x", 737 }, 738 .probe = pca953x_probe, 739 .remove = pca953x_remove, 740 .id_table = pca953x_id, 741 }; 742 743 static int __init pca953x_init(void) 744 { 745 return i2c_add_driver(&pca953x_driver); 746 } 747 /* register after i2c postcore initcall and before 748 * subsys initcalls that may rely on these GPIOs 749 */ 750 subsys_initcall(pca953x_init); 751 752 static void __exit pca953x_exit(void) 753 { 754 i2c_del_driver(&pca953x_driver); 755 } 756 module_exit(pca953x_exit); 757 758 MODULE_AUTHOR("eric miao <eric.miao@marvell.com>"); 759 MODULE_DESCRIPTION("GPIO expander driver for PCA953x"); 760 MODULE_LICENSE("GPL"); 761