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