1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // regmap based irq_chip 4 // 5 // Copyright 2011 Wolfson Microelectronics plc 6 // 7 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 9 #include <linux/device.h> 10 #include <linux/export.h> 11 #include <linux/interrupt.h> 12 #include <linux/irq.h> 13 #include <linux/irqdomain.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regmap.h> 16 #include <linux/slab.h> 17 18 #include "internal.h" 19 20 struct regmap_irq_chip_data { 21 struct mutex lock; 22 struct irq_chip irq_chip; 23 24 struct regmap *map; 25 const struct regmap_irq_chip *chip; 26 27 int irq_base; 28 struct irq_domain *domain; 29 30 int irq; 31 int wake_count; 32 33 void *status_reg_buf; 34 unsigned int *main_status_buf; 35 unsigned int *status_buf; 36 unsigned int *mask_buf; 37 unsigned int *mask_buf_def; 38 unsigned int *wake_buf; 39 unsigned int *type_buf; 40 unsigned int *type_buf_def; 41 42 unsigned int irq_reg_stride; 43 unsigned int type_reg_stride; 44 45 bool clear_status:1; 46 }; 47 48 static inline const 49 struct regmap_irq *irq_to_regmap_irq(struct regmap_irq_chip_data *data, 50 int irq) 51 { 52 return &data->chip->irqs[irq]; 53 } 54 55 static void regmap_irq_lock(struct irq_data *data) 56 { 57 struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); 58 59 mutex_lock(&d->lock); 60 } 61 62 static int regmap_irq_update_bits(struct regmap_irq_chip_data *d, 63 unsigned int reg, unsigned int mask, 64 unsigned int val) 65 { 66 if (d->chip->mask_writeonly) 67 return regmap_write_bits(d->map, reg, mask, val); 68 else 69 return regmap_update_bits(d->map, reg, mask, val); 70 } 71 72 static void regmap_irq_sync_unlock(struct irq_data *data) 73 { 74 struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); 75 struct regmap *map = d->map; 76 int i, ret; 77 u32 reg; 78 u32 unmask_offset; 79 u32 val; 80 81 if (d->chip->runtime_pm) { 82 ret = pm_runtime_get_sync(map->dev); 83 if (ret < 0) 84 dev_err(map->dev, "IRQ sync failed to resume: %d\n", 85 ret); 86 } 87 88 if (d->clear_status) { 89 for (i = 0; i < d->chip->num_regs; i++) { 90 reg = d->chip->status_base + 91 (i * map->reg_stride * d->irq_reg_stride); 92 93 ret = regmap_read(map, reg, &val); 94 if (ret) 95 dev_err(d->map->dev, 96 "Failed to clear the interrupt status bits\n"); 97 } 98 99 d->clear_status = false; 100 } 101 102 /* 103 * If there's been a change in the mask write it back to the 104 * hardware. We rely on the use of the regmap core cache to 105 * suppress pointless writes. 106 */ 107 for (i = 0; i < d->chip->num_regs; i++) { 108 if (!d->chip->mask_base) 109 continue; 110 111 reg = d->chip->mask_base + 112 (i * map->reg_stride * d->irq_reg_stride); 113 if (d->chip->mask_invert) { 114 ret = regmap_irq_update_bits(d, reg, 115 d->mask_buf_def[i], ~d->mask_buf[i]); 116 } else if (d->chip->unmask_base) { 117 /* set mask with mask_base register */ 118 ret = regmap_irq_update_bits(d, reg, 119 d->mask_buf_def[i], ~d->mask_buf[i]); 120 if (ret < 0) 121 dev_err(d->map->dev, 122 "Failed to sync unmasks in %x\n", 123 reg); 124 unmask_offset = d->chip->unmask_base - 125 d->chip->mask_base; 126 /* clear mask with unmask_base register */ 127 ret = regmap_irq_update_bits(d, 128 reg + unmask_offset, 129 d->mask_buf_def[i], 130 d->mask_buf[i]); 131 } else { 132 ret = regmap_irq_update_bits(d, reg, 133 d->mask_buf_def[i], d->mask_buf[i]); 134 } 135 if (ret != 0) 136 dev_err(d->map->dev, "Failed to sync masks in %x\n", 137 reg); 138 139 reg = d->chip->wake_base + 140 (i * map->reg_stride * d->irq_reg_stride); 141 if (d->wake_buf) { 142 if (d->chip->wake_invert) 143 ret = regmap_irq_update_bits(d, reg, 144 d->mask_buf_def[i], 145 ~d->wake_buf[i]); 146 else 147 ret = regmap_irq_update_bits(d, reg, 148 d->mask_buf_def[i], 149 d->wake_buf[i]); 150 if (ret != 0) 151 dev_err(d->map->dev, 152 "Failed to sync wakes in %x: %d\n", 153 reg, ret); 154 } 155 156 if (!d->chip->init_ack_masked) 157 continue; 158 /* 159 * Ack all the masked interrupts unconditionally, 160 * OR if there is masked interrupt which hasn't been Acked, 161 * it'll be ignored in irq handler, then may introduce irq storm 162 */ 163 if (d->mask_buf[i] && (d->chip->ack_base || d->chip->use_ack)) { 164 reg = d->chip->ack_base + 165 (i * map->reg_stride * d->irq_reg_stride); 166 /* some chips ack by write 0 */ 167 if (d->chip->ack_invert) 168 ret = regmap_write(map, reg, ~d->mask_buf[i]); 169 else 170 ret = regmap_write(map, reg, d->mask_buf[i]); 171 if (ret != 0) 172 dev_err(d->map->dev, "Failed to ack 0x%x: %d\n", 173 reg, ret); 174 } 175 } 176 177 /* Don't update the type bits if we're using mask bits for irq type. */ 178 if (!d->chip->type_in_mask) { 179 for (i = 0; i < d->chip->num_type_reg; i++) { 180 if (!d->type_buf_def[i]) 181 continue; 182 reg = d->chip->type_base + 183 (i * map->reg_stride * d->type_reg_stride); 184 if (d->chip->type_invert) 185 ret = regmap_irq_update_bits(d, reg, 186 d->type_buf_def[i], ~d->type_buf[i]); 187 else 188 ret = regmap_irq_update_bits(d, reg, 189 d->type_buf_def[i], d->type_buf[i]); 190 if (ret != 0) 191 dev_err(d->map->dev, "Failed to sync type in %x\n", 192 reg); 193 } 194 } 195 196 if (d->chip->runtime_pm) 197 pm_runtime_put(map->dev); 198 199 /* If we've changed our wakeup count propagate it to the parent */ 200 if (d->wake_count < 0) 201 for (i = d->wake_count; i < 0; i++) 202 irq_set_irq_wake(d->irq, 0); 203 else if (d->wake_count > 0) 204 for (i = 0; i < d->wake_count; i++) 205 irq_set_irq_wake(d->irq, 1); 206 207 d->wake_count = 0; 208 209 mutex_unlock(&d->lock); 210 } 211 212 static void regmap_irq_enable(struct irq_data *data) 213 { 214 struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); 215 struct regmap *map = d->map; 216 const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq); 217 unsigned int mask, type; 218 219 type = irq_data->type.type_falling_val | irq_data->type.type_rising_val; 220 221 /* 222 * The type_in_mask flag means that the underlying hardware uses 223 * separate mask bits for rising and falling edge interrupts, but 224 * we want to make them into a single virtual interrupt with 225 * configurable edge. 226 * 227 * If the interrupt we're enabling defines the falling or rising 228 * masks then instead of using the regular mask bits for this 229 * interrupt, use the value previously written to the type buffer 230 * at the corresponding offset in regmap_irq_set_type(). 231 */ 232 if (d->chip->type_in_mask && type) 233 mask = d->type_buf[irq_data->reg_offset / map->reg_stride]; 234 else 235 mask = irq_data->mask; 236 237 if (d->chip->clear_on_unmask) 238 d->clear_status = true; 239 240 d->mask_buf[irq_data->reg_offset / map->reg_stride] &= ~mask; 241 } 242 243 static void regmap_irq_disable(struct irq_data *data) 244 { 245 struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); 246 struct regmap *map = d->map; 247 const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq); 248 249 d->mask_buf[irq_data->reg_offset / map->reg_stride] |= irq_data->mask; 250 } 251 252 static int regmap_irq_set_type(struct irq_data *data, unsigned int type) 253 { 254 struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); 255 struct regmap *map = d->map; 256 const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq); 257 int reg; 258 const struct regmap_irq_type *t = &irq_data->type; 259 260 if ((t->types_supported & type) != type) 261 return 0; 262 263 reg = t->type_reg_offset / map->reg_stride; 264 265 if (t->type_reg_mask) 266 d->type_buf[reg] &= ~t->type_reg_mask; 267 else 268 d->type_buf[reg] &= ~(t->type_falling_val | 269 t->type_rising_val | 270 t->type_level_low_val | 271 t->type_level_high_val); 272 switch (type) { 273 case IRQ_TYPE_EDGE_FALLING: 274 d->type_buf[reg] |= t->type_falling_val; 275 break; 276 277 case IRQ_TYPE_EDGE_RISING: 278 d->type_buf[reg] |= t->type_rising_val; 279 break; 280 281 case IRQ_TYPE_EDGE_BOTH: 282 d->type_buf[reg] |= (t->type_falling_val | 283 t->type_rising_val); 284 break; 285 286 case IRQ_TYPE_LEVEL_HIGH: 287 d->type_buf[reg] |= t->type_level_high_val; 288 break; 289 290 case IRQ_TYPE_LEVEL_LOW: 291 d->type_buf[reg] |= t->type_level_low_val; 292 break; 293 default: 294 return -EINVAL; 295 } 296 return 0; 297 } 298 299 static int regmap_irq_set_wake(struct irq_data *data, unsigned int on) 300 { 301 struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); 302 struct regmap *map = d->map; 303 const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->hwirq); 304 305 if (on) { 306 if (d->wake_buf) 307 d->wake_buf[irq_data->reg_offset / map->reg_stride] 308 &= ~irq_data->mask; 309 d->wake_count++; 310 } else { 311 if (d->wake_buf) 312 d->wake_buf[irq_data->reg_offset / map->reg_stride] 313 |= irq_data->mask; 314 d->wake_count--; 315 } 316 317 return 0; 318 } 319 320 static const struct irq_chip regmap_irq_chip = { 321 .irq_bus_lock = regmap_irq_lock, 322 .irq_bus_sync_unlock = regmap_irq_sync_unlock, 323 .irq_disable = regmap_irq_disable, 324 .irq_enable = regmap_irq_enable, 325 .irq_set_type = regmap_irq_set_type, 326 .irq_set_wake = regmap_irq_set_wake, 327 }; 328 329 static inline int read_sub_irq_data(struct regmap_irq_chip_data *data, 330 unsigned int b) 331 { 332 const struct regmap_irq_chip *chip = data->chip; 333 struct regmap *map = data->map; 334 struct regmap_irq_sub_irq_map *subreg; 335 int i, ret = 0; 336 337 if (!chip->sub_reg_offsets) { 338 /* Assume linear mapping */ 339 ret = regmap_read(map, chip->status_base + 340 (b * map->reg_stride * data->irq_reg_stride), 341 &data->status_buf[b]); 342 } else { 343 subreg = &chip->sub_reg_offsets[b]; 344 for (i = 0; i < subreg->num_regs; i++) { 345 unsigned int offset = subreg->offset[i]; 346 347 ret = regmap_read(map, chip->status_base + offset, 348 &data->status_buf[offset]); 349 if (ret) 350 break; 351 } 352 } 353 return ret; 354 } 355 356 static irqreturn_t regmap_irq_thread(int irq, void *d) 357 { 358 struct regmap_irq_chip_data *data = d; 359 const struct regmap_irq_chip *chip = data->chip; 360 struct regmap *map = data->map; 361 int ret, i; 362 bool handled = false; 363 u32 reg; 364 365 if (chip->handle_pre_irq) 366 chip->handle_pre_irq(chip->irq_drv_data); 367 368 if (chip->runtime_pm) { 369 ret = pm_runtime_get_sync(map->dev); 370 if (ret < 0) { 371 dev_err(map->dev, "IRQ thread failed to resume: %d\n", 372 ret); 373 goto exit; 374 } 375 } 376 377 /* 378 * Read only registers with active IRQs if the chip has 'main status 379 * register'. Else read in the statuses, using a single bulk read if 380 * possible in order to reduce the I/O overheads. 381 */ 382 383 if (chip->num_main_regs) { 384 unsigned int max_main_bits; 385 unsigned long size; 386 387 size = chip->num_regs * sizeof(unsigned int); 388 389 max_main_bits = (chip->num_main_status_bits) ? 390 chip->num_main_status_bits : chip->num_regs; 391 /* Clear the status buf as we don't read all status regs */ 392 memset(data->status_buf, 0, size); 393 394 /* We could support bulk read for main status registers 395 * but I don't expect to see devices with really many main 396 * status registers so let's only support single reads for the 397 * sake of simplicity. and add bulk reads only if needed 398 */ 399 for (i = 0; i < chip->num_main_regs; i++) { 400 ret = regmap_read(map, chip->main_status + 401 (i * map->reg_stride 402 * data->irq_reg_stride), 403 &data->main_status_buf[i]); 404 if (ret) { 405 dev_err(map->dev, 406 "Failed to read IRQ status %d\n", 407 ret); 408 goto exit; 409 } 410 } 411 412 /* Read sub registers with active IRQs */ 413 for (i = 0; i < chip->num_main_regs; i++) { 414 unsigned int b; 415 const unsigned long mreg = data->main_status_buf[i]; 416 417 for_each_set_bit(b, &mreg, map->format.val_bytes * 8) { 418 if (i * map->format.val_bytes * 8 + b > 419 max_main_bits) 420 break; 421 ret = read_sub_irq_data(data, b); 422 423 if (ret != 0) { 424 dev_err(map->dev, 425 "Failed to read IRQ status %d\n", 426 ret); 427 goto exit; 428 } 429 } 430 431 } 432 } else if (!map->use_single_read && map->reg_stride == 1 && 433 data->irq_reg_stride == 1) { 434 435 u8 *buf8 = data->status_reg_buf; 436 u16 *buf16 = data->status_reg_buf; 437 u32 *buf32 = data->status_reg_buf; 438 439 BUG_ON(!data->status_reg_buf); 440 441 ret = regmap_bulk_read(map, chip->status_base, 442 data->status_reg_buf, 443 chip->num_regs); 444 if (ret != 0) { 445 dev_err(map->dev, "Failed to read IRQ status: %d\n", 446 ret); 447 goto exit; 448 } 449 450 for (i = 0; i < data->chip->num_regs; i++) { 451 switch (map->format.val_bytes) { 452 case 1: 453 data->status_buf[i] = buf8[i]; 454 break; 455 case 2: 456 data->status_buf[i] = buf16[i]; 457 break; 458 case 4: 459 data->status_buf[i] = buf32[i]; 460 break; 461 default: 462 BUG(); 463 goto exit; 464 } 465 } 466 467 } else { 468 for (i = 0; i < data->chip->num_regs; i++) { 469 ret = regmap_read(map, chip->status_base + 470 (i * map->reg_stride 471 * data->irq_reg_stride), 472 &data->status_buf[i]); 473 474 if (ret != 0) { 475 dev_err(map->dev, 476 "Failed to read IRQ status: %d\n", 477 ret); 478 goto exit; 479 } 480 } 481 } 482 483 /* 484 * Ignore masked IRQs and ack if we need to; we ack early so 485 * there is no race between handling and acknowleding the 486 * interrupt. We assume that typically few of the interrupts 487 * will fire simultaneously so don't worry about overhead from 488 * doing a write per register. 489 */ 490 for (i = 0; i < data->chip->num_regs; i++) { 491 data->status_buf[i] &= ~data->mask_buf[i]; 492 493 if (data->status_buf[i] && (chip->ack_base || chip->use_ack)) { 494 reg = chip->ack_base + 495 (i * map->reg_stride * data->irq_reg_stride); 496 ret = regmap_write(map, reg, data->status_buf[i]); 497 if (ret != 0) 498 dev_err(map->dev, "Failed to ack 0x%x: %d\n", 499 reg, ret); 500 } 501 } 502 503 for (i = 0; i < chip->num_irqs; i++) { 504 if (data->status_buf[chip->irqs[i].reg_offset / 505 map->reg_stride] & chip->irqs[i].mask) { 506 handle_nested_irq(irq_find_mapping(data->domain, i)); 507 handled = true; 508 } 509 } 510 511 exit: 512 if (chip->runtime_pm) 513 pm_runtime_put(map->dev); 514 515 if (chip->handle_post_irq) 516 chip->handle_post_irq(chip->irq_drv_data); 517 518 if (handled) 519 return IRQ_HANDLED; 520 else 521 return IRQ_NONE; 522 } 523 524 static int regmap_irq_map(struct irq_domain *h, unsigned int virq, 525 irq_hw_number_t hw) 526 { 527 struct regmap_irq_chip_data *data = h->host_data; 528 529 irq_set_chip_data(virq, data); 530 irq_set_chip(virq, &data->irq_chip); 531 irq_set_nested_thread(virq, 1); 532 irq_set_parent(virq, data->irq); 533 irq_set_noprobe(virq); 534 535 return 0; 536 } 537 538 static const struct irq_domain_ops regmap_domain_ops = { 539 .map = regmap_irq_map, 540 .xlate = irq_domain_xlate_onetwocell, 541 }; 542 543 /** 544 * regmap_add_irq_chip_np() - Use standard regmap IRQ controller handling 545 * 546 * @np: The device_node where the IRQ domain should be added to. 547 * @map: The regmap for the device. 548 * @irq: The IRQ the device uses to signal interrupts. 549 * @irq_flags: The IRQF_ flags to use for the primary interrupt. 550 * @irq_base: Allocate at specific IRQ number if irq_base > 0. 551 * @chip: Configuration for the interrupt controller. 552 * @data: Runtime data structure for the controller, allocated on success. 553 * 554 * Returns 0 on success or an errno on failure. 555 * 556 * In order for this to be efficient the chip really should use a 557 * register cache. The chip driver is responsible for restoring the 558 * register values used by the IRQ controller over suspend and resume. 559 */ 560 int regmap_add_irq_chip_np(struct device_node *np, struct regmap *map, int irq, 561 int irq_flags, int irq_base, 562 const struct regmap_irq_chip *chip, 563 struct regmap_irq_chip_data **data) 564 { 565 struct regmap_irq_chip_data *d; 566 int i; 567 int ret = -ENOMEM; 568 int num_type_reg; 569 u32 reg; 570 u32 unmask_offset; 571 572 if (chip->num_regs <= 0) 573 return -EINVAL; 574 575 if (chip->clear_on_unmask && (chip->ack_base || chip->use_ack)) 576 return -EINVAL; 577 578 for (i = 0; i < chip->num_irqs; i++) { 579 if (chip->irqs[i].reg_offset % map->reg_stride) 580 return -EINVAL; 581 if (chip->irqs[i].reg_offset / map->reg_stride >= 582 chip->num_regs) 583 return -EINVAL; 584 } 585 586 if (irq_base) { 587 irq_base = irq_alloc_descs(irq_base, 0, chip->num_irqs, 0); 588 if (irq_base < 0) { 589 dev_warn(map->dev, "Failed to allocate IRQs: %d\n", 590 irq_base); 591 return irq_base; 592 } 593 } 594 595 d = kzalloc(sizeof(*d), GFP_KERNEL); 596 if (!d) 597 return -ENOMEM; 598 599 if (chip->num_main_regs) { 600 d->main_status_buf = kcalloc(chip->num_main_regs, 601 sizeof(unsigned int), 602 GFP_KERNEL); 603 604 if (!d->main_status_buf) 605 goto err_alloc; 606 } 607 608 d->status_buf = kcalloc(chip->num_regs, sizeof(unsigned int), 609 GFP_KERNEL); 610 if (!d->status_buf) 611 goto err_alloc; 612 613 d->mask_buf = kcalloc(chip->num_regs, sizeof(unsigned int), 614 GFP_KERNEL); 615 if (!d->mask_buf) 616 goto err_alloc; 617 618 d->mask_buf_def = kcalloc(chip->num_regs, sizeof(unsigned int), 619 GFP_KERNEL); 620 if (!d->mask_buf_def) 621 goto err_alloc; 622 623 if (chip->wake_base) { 624 d->wake_buf = kcalloc(chip->num_regs, sizeof(unsigned int), 625 GFP_KERNEL); 626 if (!d->wake_buf) 627 goto err_alloc; 628 } 629 630 num_type_reg = chip->type_in_mask ? chip->num_regs : chip->num_type_reg; 631 if (num_type_reg) { 632 d->type_buf_def = kcalloc(num_type_reg, 633 sizeof(unsigned int), GFP_KERNEL); 634 if (!d->type_buf_def) 635 goto err_alloc; 636 637 d->type_buf = kcalloc(num_type_reg, sizeof(unsigned int), 638 GFP_KERNEL); 639 if (!d->type_buf) 640 goto err_alloc; 641 } 642 643 d->irq_chip = regmap_irq_chip; 644 d->irq_chip.name = chip->name; 645 d->irq = irq; 646 d->map = map; 647 d->chip = chip; 648 d->irq_base = irq_base; 649 650 if (chip->irq_reg_stride) 651 d->irq_reg_stride = chip->irq_reg_stride; 652 else 653 d->irq_reg_stride = 1; 654 655 if (chip->type_reg_stride) 656 d->type_reg_stride = chip->type_reg_stride; 657 else 658 d->type_reg_stride = 1; 659 660 if (!map->use_single_read && map->reg_stride == 1 && 661 d->irq_reg_stride == 1) { 662 d->status_reg_buf = kmalloc_array(chip->num_regs, 663 map->format.val_bytes, 664 GFP_KERNEL); 665 if (!d->status_reg_buf) 666 goto err_alloc; 667 } 668 669 mutex_init(&d->lock); 670 671 for (i = 0; i < chip->num_irqs; i++) 672 d->mask_buf_def[chip->irqs[i].reg_offset / map->reg_stride] 673 |= chip->irqs[i].mask; 674 675 /* Mask all the interrupts by default */ 676 for (i = 0; i < chip->num_regs; i++) { 677 d->mask_buf[i] = d->mask_buf_def[i]; 678 if (!chip->mask_base) 679 continue; 680 681 reg = chip->mask_base + 682 (i * map->reg_stride * d->irq_reg_stride); 683 if (chip->mask_invert) 684 ret = regmap_irq_update_bits(d, reg, 685 d->mask_buf[i], ~d->mask_buf[i]); 686 else if (d->chip->unmask_base) { 687 unmask_offset = d->chip->unmask_base - 688 d->chip->mask_base; 689 ret = regmap_irq_update_bits(d, 690 reg + unmask_offset, 691 d->mask_buf[i], 692 d->mask_buf[i]); 693 } else 694 ret = regmap_irq_update_bits(d, reg, 695 d->mask_buf[i], d->mask_buf[i]); 696 if (ret != 0) { 697 dev_err(map->dev, "Failed to set masks in 0x%x: %d\n", 698 reg, ret); 699 goto err_alloc; 700 } 701 702 if (!chip->init_ack_masked) 703 continue; 704 705 /* Ack masked but set interrupts */ 706 reg = chip->status_base + 707 (i * map->reg_stride * d->irq_reg_stride); 708 ret = regmap_read(map, reg, &d->status_buf[i]); 709 if (ret != 0) { 710 dev_err(map->dev, "Failed to read IRQ status: %d\n", 711 ret); 712 goto err_alloc; 713 } 714 715 if (d->status_buf[i] && (chip->ack_base || chip->use_ack)) { 716 reg = chip->ack_base + 717 (i * map->reg_stride * d->irq_reg_stride); 718 if (chip->ack_invert) 719 ret = regmap_write(map, reg, 720 ~(d->status_buf[i] & d->mask_buf[i])); 721 else 722 ret = regmap_write(map, reg, 723 d->status_buf[i] & d->mask_buf[i]); 724 if (ret != 0) { 725 dev_err(map->dev, "Failed to ack 0x%x: %d\n", 726 reg, ret); 727 goto err_alloc; 728 } 729 } 730 } 731 732 /* Wake is disabled by default */ 733 if (d->wake_buf) { 734 for (i = 0; i < chip->num_regs; i++) { 735 d->wake_buf[i] = d->mask_buf_def[i]; 736 reg = chip->wake_base + 737 (i * map->reg_stride * d->irq_reg_stride); 738 739 if (chip->wake_invert) 740 ret = regmap_irq_update_bits(d, reg, 741 d->mask_buf_def[i], 742 0); 743 else 744 ret = regmap_irq_update_bits(d, reg, 745 d->mask_buf_def[i], 746 d->wake_buf[i]); 747 if (ret != 0) { 748 dev_err(map->dev, "Failed to set masks in 0x%x: %d\n", 749 reg, ret); 750 goto err_alloc; 751 } 752 } 753 } 754 755 if (chip->num_type_reg && !chip->type_in_mask) { 756 for (i = 0; i < chip->num_type_reg; ++i) { 757 reg = chip->type_base + 758 (i * map->reg_stride * d->type_reg_stride); 759 760 ret = regmap_read(map, reg, &d->type_buf_def[i]); 761 762 if (d->chip->type_invert) 763 d->type_buf_def[i] = ~d->type_buf_def[i]; 764 765 if (ret) { 766 dev_err(map->dev, "Failed to get type defaults at 0x%x: %d\n", 767 reg, ret); 768 goto err_alloc; 769 } 770 } 771 } 772 773 if (irq_base) 774 d->domain = irq_domain_add_legacy(np, chip->num_irqs, irq_base, 775 0, ®map_domain_ops, d); 776 else 777 d->domain = irq_domain_add_linear(np, chip->num_irqs, 778 ®map_domain_ops, d); 779 if (!d->domain) { 780 dev_err(map->dev, "Failed to create IRQ domain\n"); 781 ret = -ENOMEM; 782 goto err_alloc; 783 } 784 785 ret = request_threaded_irq(irq, NULL, regmap_irq_thread, 786 irq_flags | IRQF_ONESHOT, 787 chip->name, d); 788 if (ret != 0) { 789 dev_err(map->dev, "Failed to request IRQ %d for %s: %d\n", 790 irq, chip->name, ret); 791 goto err_domain; 792 } 793 794 *data = d; 795 796 return 0; 797 798 err_domain: 799 /* Should really dispose of the domain but... */ 800 err_alloc: 801 kfree(d->type_buf); 802 kfree(d->type_buf_def); 803 kfree(d->wake_buf); 804 kfree(d->mask_buf_def); 805 kfree(d->mask_buf); 806 kfree(d->status_buf); 807 kfree(d->status_reg_buf); 808 kfree(d); 809 return ret; 810 } 811 EXPORT_SYMBOL_GPL(regmap_add_irq_chip_np); 812 813 /** 814 * regmap_add_irq_chip() - Use standard regmap IRQ controller handling 815 * 816 * @map: The regmap for the device. 817 * @irq: The IRQ the device uses to signal interrupts. 818 * @irq_flags: The IRQF_ flags to use for the primary interrupt. 819 * @irq_base: Allocate at specific IRQ number if irq_base > 0. 820 * @chip: Configuration for the interrupt controller. 821 * @data: Runtime data structure for the controller, allocated on success. 822 * 823 * Returns 0 on success or an errno on failure. 824 * 825 * This is the same as regmap_add_irq_chip_np, except that the device 826 * node of the regmap is used. 827 */ 828 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 829 int irq_base, const struct regmap_irq_chip *chip, 830 struct regmap_irq_chip_data **data) 831 { 832 return regmap_add_irq_chip_np(map->dev->of_node, map, irq, irq_flags, 833 irq_base, chip, data); 834 } 835 EXPORT_SYMBOL_GPL(regmap_add_irq_chip); 836 837 /** 838 * regmap_del_irq_chip() - Stop interrupt handling for a regmap IRQ chip 839 * 840 * @irq: Primary IRQ for the device 841 * @d: ®map_irq_chip_data allocated by regmap_add_irq_chip() 842 * 843 * This function also disposes of all mapped IRQs on the chip. 844 */ 845 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d) 846 { 847 unsigned int virq; 848 int hwirq; 849 850 if (!d) 851 return; 852 853 free_irq(irq, d); 854 855 /* Dispose all virtual irq from irq domain before removing it */ 856 for (hwirq = 0; hwirq < d->chip->num_irqs; hwirq++) { 857 /* Ignore hwirq if holes in the IRQ list */ 858 if (!d->chip->irqs[hwirq].mask) 859 continue; 860 861 /* 862 * Find the virtual irq of hwirq on chip and if it is 863 * there then dispose it 864 */ 865 virq = irq_find_mapping(d->domain, hwirq); 866 if (virq) 867 irq_dispose_mapping(virq); 868 } 869 870 irq_domain_remove(d->domain); 871 kfree(d->type_buf); 872 kfree(d->type_buf_def); 873 kfree(d->wake_buf); 874 kfree(d->mask_buf_def); 875 kfree(d->mask_buf); 876 kfree(d->status_reg_buf); 877 kfree(d->status_buf); 878 kfree(d); 879 } 880 EXPORT_SYMBOL_GPL(regmap_del_irq_chip); 881 882 static void devm_regmap_irq_chip_release(struct device *dev, void *res) 883 { 884 struct regmap_irq_chip_data *d = *(struct regmap_irq_chip_data **)res; 885 886 regmap_del_irq_chip(d->irq, d); 887 } 888 889 static int devm_regmap_irq_chip_match(struct device *dev, void *res, void *data) 890 891 { 892 struct regmap_irq_chip_data **r = res; 893 894 if (!r || !*r) { 895 WARN_ON(!r || !*r); 896 return 0; 897 } 898 return *r == data; 899 } 900 901 /** 902 * devm_regmap_add_irq_chip_np() - Resource manager regmap_add_irq_chip_np() 903 * 904 * @dev: The device pointer on which irq_chip belongs to. 905 * @np: The device_node where the IRQ domain should be added to. 906 * @map: The regmap for the device. 907 * @irq: The IRQ the device uses to signal interrupts 908 * @irq_flags: The IRQF_ flags to use for the primary interrupt. 909 * @irq_base: Allocate at specific IRQ number if irq_base > 0. 910 * @chip: Configuration for the interrupt controller. 911 * @data: Runtime data structure for the controller, allocated on success 912 * 913 * Returns 0 on success or an errno on failure. 914 * 915 * The ®map_irq_chip_data will be automatically released when the device is 916 * unbound. 917 */ 918 int devm_regmap_add_irq_chip_np(struct device *dev, struct device_node *np, 919 struct regmap *map, int irq, int irq_flags, 920 int irq_base, 921 const struct regmap_irq_chip *chip, 922 struct regmap_irq_chip_data **data) 923 { 924 struct regmap_irq_chip_data **ptr, *d; 925 int ret; 926 927 ptr = devres_alloc(devm_regmap_irq_chip_release, sizeof(*ptr), 928 GFP_KERNEL); 929 if (!ptr) 930 return -ENOMEM; 931 932 ret = regmap_add_irq_chip_np(np, map, irq, irq_flags, irq_base, 933 chip, &d); 934 if (ret < 0) { 935 devres_free(ptr); 936 return ret; 937 } 938 939 *ptr = d; 940 devres_add(dev, ptr); 941 *data = d; 942 return 0; 943 } 944 EXPORT_SYMBOL_GPL(devm_regmap_add_irq_chip_np); 945 946 /** 947 * devm_regmap_add_irq_chip() - Resource manager regmap_add_irq_chip() 948 * 949 * @dev: The device pointer on which irq_chip belongs to. 950 * @map: The regmap for the device. 951 * @irq: The IRQ the device uses to signal interrupts 952 * @irq_flags: The IRQF_ flags to use for the primary interrupt. 953 * @irq_base: Allocate at specific IRQ number if irq_base > 0. 954 * @chip: Configuration for the interrupt controller. 955 * @data: Runtime data structure for the controller, allocated on success 956 * 957 * Returns 0 on success or an errno on failure. 958 * 959 * The ®map_irq_chip_data will be automatically released when the device is 960 * unbound. 961 */ 962 int devm_regmap_add_irq_chip(struct device *dev, struct regmap *map, int irq, 963 int irq_flags, int irq_base, 964 const struct regmap_irq_chip *chip, 965 struct regmap_irq_chip_data **data) 966 { 967 return devm_regmap_add_irq_chip_np(dev, map->dev->of_node, map, irq, 968 irq_flags, irq_base, chip, data); 969 } 970 EXPORT_SYMBOL_GPL(devm_regmap_add_irq_chip); 971 972 /** 973 * devm_regmap_del_irq_chip() - Resource managed regmap_del_irq_chip() 974 * 975 * @dev: Device for which which resource was allocated. 976 * @irq: Primary IRQ for the device. 977 * @data: ®map_irq_chip_data allocated by regmap_add_irq_chip(). 978 * 979 * A resource managed version of regmap_del_irq_chip(). 980 */ 981 void devm_regmap_del_irq_chip(struct device *dev, int irq, 982 struct regmap_irq_chip_data *data) 983 { 984 int rc; 985 986 WARN_ON(irq != data->irq); 987 rc = devres_release(dev, devm_regmap_irq_chip_release, 988 devm_regmap_irq_chip_match, data); 989 990 if (rc != 0) 991 WARN_ON(rc); 992 } 993 EXPORT_SYMBOL_GPL(devm_regmap_del_irq_chip); 994 995 /** 996 * regmap_irq_chip_get_base() - Retrieve interrupt base for a regmap IRQ chip 997 * 998 * @data: regmap irq controller to operate on. 999 * 1000 * Useful for drivers to request their own IRQs. 1001 */ 1002 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data) 1003 { 1004 WARN_ON(!data->irq_base); 1005 return data->irq_base; 1006 } 1007 EXPORT_SYMBOL_GPL(regmap_irq_chip_get_base); 1008 1009 /** 1010 * regmap_irq_get_virq() - Map an interrupt on a chip to a virtual IRQ 1011 * 1012 * @data: regmap irq controller to operate on. 1013 * @irq: index of the interrupt requested in the chip IRQs. 1014 * 1015 * Useful for drivers to request their own IRQs. 1016 */ 1017 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq) 1018 { 1019 /* Handle holes in the IRQ list */ 1020 if (!data->chip->irqs[irq].mask) 1021 return -EINVAL; 1022 1023 return irq_create_mapping(data->domain, irq); 1024 } 1025 EXPORT_SYMBOL_GPL(regmap_irq_get_virq); 1026 1027 /** 1028 * regmap_irq_get_domain() - Retrieve the irq_domain for the chip 1029 * 1030 * @data: regmap_irq controller to operate on. 1031 * 1032 * Useful for drivers to request their own IRQs and for integration 1033 * with subsystems. For ease of integration NULL is accepted as a 1034 * domain, allowing devices to just call this even if no domain is 1035 * allocated. 1036 */ 1037 struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data) 1038 { 1039 if (data) 1040 return data->domain; 1041 else 1042 return NULL; 1043 } 1044 EXPORT_SYMBOL_GPL(regmap_irq_get_domain); 1045