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