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