1// SPDX-License-Identifier: GPL-2.0 2 3#define pr_fmt(fmt) "irq: " fmt 4 5#include <linux/acpi.h> 6#include <linux/debugfs.h> 7#include <linux/hardirq.h> 8#include <linux/interrupt.h> 9#include <linux/irq.h> 10#include <linux/irqdesc.h> 11#include <linux/irqdomain.h> 12#include <linux/module.h> 13#include <linux/mutex.h> 14#include <linux/of.h> 15#include <linux/of_address.h> 16#include <linux/of_irq.h> 17#include <linux/topology.h> 18#include <linux/seq_file.h> 19#include <linux/slab.h> 20#include <linux/smp.h> 21#include <linux/fs.h> 22 23static LIST_HEAD(irq_domain_list); 24static DEFINE_MUTEX(irq_domain_mutex); 25 26static struct irq_domain *irq_default_domain; 27 28static int irq_domain_alloc_irqs_locked(struct irq_domain *domain, int irq_base, 29 unsigned int nr_irqs, int node, void *arg, 30 bool realloc, const struct irq_affinity_desc *affinity); 31static void irq_domain_check_hierarchy(struct irq_domain *domain); 32static void irq_domain_free_one_irq(struct irq_domain *domain, unsigned int virq); 33 34struct irqchip_fwid { 35 struct fwnode_handle fwnode; 36 unsigned int type; 37 char *name; 38 phys_addr_t *pa; 39}; 40 41#ifdef CONFIG_GENERIC_IRQ_DEBUGFS 42static void debugfs_add_domain_dir(struct irq_domain *d); 43static void debugfs_remove_domain_dir(struct irq_domain *d); 44#else 45static inline void debugfs_add_domain_dir(struct irq_domain *d) { } 46static inline void debugfs_remove_domain_dir(struct irq_domain *d) { } 47#endif 48 49static const char *irqchip_fwnode_get_name(const struct fwnode_handle *fwnode) 50{ 51 struct irqchip_fwid *fwid = container_of(fwnode, struct irqchip_fwid, fwnode); 52 53 return fwid->name; 54} 55 56const struct fwnode_operations irqchip_fwnode_ops = { 57 .get_name = irqchip_fwnode_get_name, 58}; 59EXPORT_SYMBOL_GPL(irqchip_fwnode_ops); 60 61/** 62 * __irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for 63 * identifying an irq domain 64 * @type: Type of irqchip_fwnode. See linux/irqdomain.h 65 * @id: Optional user provided id if name != NULL 66 * @name: Optional user provided domain name 67 * @pa: Optional user-provided physical address 68 * 69 * Allocate a struct irqchip_fwid, and return a pointer to the embedded 70 * fwnode_handle (or NULL on failure). 71 * 72 * Note: The types IRQCHIP_FWNODE_NAMED and IRQCHIP_FWNODE_NAMED_ID are 73 * solely to transport name information to irqdomain creation code. The 74 * node is not stored. For other types the pointer is kept in the irq 75 * domain struct. 76 */ 77struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id, 78 const char *name, 79 phys_addr_t *pa) 80{ 81 struct irqchip_fwid *fwid; 82 char *n; 83 84 fwid = kzalloc(sizeof(*fwid), GFP_KERNEL); 85 86 switch (type) { 87 case IRQCHIP_FWNODE_NAMED: 88 n = kasprintf(GFP_KERNEL, "%s", name); 89 break; 90 case IRQCHIP_FWNODE_NAMED_ID: 91 n = kasprintf(GFP_KERNEL, "%s-%d", name, id); 92 break; 93 default: 94 n = kasprintf(GFP_KERNEL, "irqchip@%pa", pa); 95 break; 96 } 97 98 if (!fwid || !n) { 99 kfree(fwid); 100 kfree(n); 101 return NULL; 102 } 103 104 fwid->type = type; 105 fwid->name = n; 106 fwid->pa = pa; 107 fwnode_init(&fwid->fwnode, &irqchip_fwnode_ops); 108 return &fwid->fwnode; 109} 110EXPORT_SYMBOL_GPL(__irq_domain_alloc_fwnode); 111 112/** 113 * irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle 114 * 115 * Free a fwnode_handle allocated with irq_domain_alloc_fwnode. 116 */ 117void irq_domain_free_fwnode(struct fwnode_handle *fwnode) 118{ 119 struct irqchip_fwid *fwid; 120 121 if (!fwnode || WARN_ON(!is_fwnode_irqchip(fwnode))) 122 return; 123 124 fwid = container_of(fwnode, struct irqchip_fwid, fwnode); 125 kfree(fwid->name); 126 kfree(fwid); 127} 128EXPORT_SYMBOL_GPL(irq_domain_free_fwnode); 129 130static struct irq_domain *__irq_domain_create(struct fwnode_handle *fwnode, 131 unsigned int size, 132 irq_hw_number_t hwirq_max, 133 int direct_max, 134 const struct irq_domain_ops *ops, 135 void *host_data) 136{ 137 struct irqchip_fwid *fwid; 138 struct irq_domain *domain; 139 140 static atomic_t unknown_domains; 141 142 if (WARN_ON((size && direct_max) || 143 (!IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP) && direct_max) || 144 (direct_max && (direct_max != hwirq_max)))) 145 return NULL; 146 147 domain = kzalloc_node(struct_size(domain, revmap, size), 148 GFP_KERNEL, of_node_to_nid(to_of_node(fwnode))); 149 if (!domain) 150 return NULL; 151 152 if (is_fwnode_irqchip(fwnode)) { 153 fwid = container_of(fwnode, struct irqchip_fwid, fwnode); 154 155 switch (fwid->type) { 156 case IRQCHIP_FWNODE_NAMED: 157 case IRQCHIP_FWNODE_NAMED_ID: 158 domain->fwnode = fwnode; 159 domain->name = kstrdup(fwid->name, GFP_KERNEL); 160 if (!domain->name) { 161 kfree(domain); 162 return NULL; 163 } 164 domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED; 165 break; 166 default: 167 domain->fwnode = fwnode; 168 domain->name = fwid->name; 169 break; 170 } 171 } else if (is_of_node(fwnode) || is_acpi_device_node(fwnode) || 172 is_software_node(fwnode)) { 173 char *name; 174 175 /* 176 * fwnode paths contain '/', which debugfs is legitimately 177 * unhappy about. Replace them with ':', which does 178 * the trick and is not as offensive as '\'... 179 */ 180 name = kasprintf(GFP_KERNEL, "%pfw", fwnode); 181 if (!name) { 182 kfree(domain); 183 return NULL; 184 } 185 186 domain->name = strreplace(name, '/', ':'); 187 domain->fwnode = fwnode; 188 domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED; 189 } 190 191 if (!domain->name) { 192 if (fwnode) 193 pr_err("Invalid fwnode type for irqdomain\n"); 194 domain->name = kasprintf(GFP_KERNEL, "unknown-%d", 195 atomic_inc_return(&unknown_domains)); 196 if (!domain->name) { 197 kfree(domain); 198 return NULL; 199 } 200 domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED; 201 } 202 203 fwnode_handle_get(fwnode); 204 fwnode_dev_initialized(fwnode, true); 205 206 /* Fill structure */ 207 INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL); 208 domain->ops = ops; 209 domain->host_data = host_data; 210 domain->hwirq_max = hwirq_max; 211 212 if (direct_max) 213 domain->flags |= IRQ_DOMAIN_FLAG_NO_MAP; 214 215 domain->revmap_size = size; 216 217 /* 218 * Hierarchical domains use the domain lock of the root domain 219 * (innermost domain). 220 * 221 * For non-hierarchical domains (as for root domains), the root 222 * pointer is set to the domain itself so that &domain->root->mutex 223 * always points to the right lock. 224 */ 225 mutex_init(&domain->mutex); 226 domain->root = domain; 227 228 irq_domain_check_hierarchy(domain); 229 230 return domain; 231} 232 233static void __irq_domain_publish(struct irq_domain *domain) 234{ 235 mutex_lock(&irq_domain_mutex); 236 debugfs_add_domain_dir(domain); 237 list_add(&domain->link, &irq_domain_list); 238 mutex_unlock(&irq_domain_mutex); 239 240 pr_debug("Added domain %s\n", domain->name); 241} 242 243/** 244 * __irq_domain_add() - Allocate a new irq_domain data structure 245 * @fwnode: firmware node for the interrupt controller 246 * @size: Size of linear map; 0 for radix mapping only 247 * @hwirq_max: Maximum number of interrupts supported by controller 248 * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no 249 * direct mapping 250 * @ops: domain callbacks 251 * @host_data: Controller private data pointer 252 * 253 * Allocates and initializes an irq_domain structure. 254 * Returns pointer to IRQ domain, or NULL on failure. 255 */ 256struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, unsigned int size, 257 irq_hw_number_t hwirq_max, int direct_max, 258 const struct irq_domain_ops *ops, 259 void *host_data) 260{ 261 struct irq_domain *domain; 262 263 domain = __irq_domain_create(fwnode, size, hwirq_max, direct_max, 264 ops, host_data); 265 if (domain) 266 __irq_domain_publish(domain); 267 268 return domain; 269} 270EXPORT_SYMBOL_GPL(__irq_domain_add); 271 272/** 273 * irq_domain_remove() - Remove an irq domain. 274 * @domain: domain to remove 275 * 276 * This routine is used to remove an irq domain. The caller must ensure 277 * that all mappings within the domain have been disposed of prior to 278 * use, depending on the revmap type. 279 */ 280void irq_domain_remove(struct irq_domain *domain) 281{ 282 mutex_lock(&irq_domain_mutex); 283 debugfs_remove_domain_dir(domain); 284 285 WARN_ON(!radix_tree_empty(&domain->revmap_tree)); 286 287 list_del(&domain->link); 288 289 /* 290 * If the going away domain is the default one, reset it. 291 */ 292 if (unlikely(irq_default_domain == domain)) 293 irq_set_default_host(NULL); 294 295 mutex_unlock(&irq_domain_mutex); 296 297 pr_debug("Removed domain %s\n", domain->name); 298 299 fwnode_dev_initialized(domain->fwnode, false); 300 fwnode_handle_put(domain->fwnode); 301 if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED) 302 kfree(domain->name); 303 kfree(domain); 304} 305EXPORT_SYMBOL_GPL(irq_domain_remove); 306 307void irq_domain_update_bus_token(struct irq_domain *domain, 308 enum irq_domain_bus_token bus_token) 309{ 310 char *name; 311 312 if (domain->bus_token == bus_token) 313 return; 314 315 mutex_lock(&irq_domain_mutex); 316 317 domain->bus_token = bus_token; 318 319 name = kasprintf(GFP_KERNEL, "%s-%d", domain->name, bus_token); 320 if (!name) { 321 mutex_unlock(&irq_domain_mutex); 322 return; 323 } 324 325 debugfs_remove_domain_dir(domain); 326 327 if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED) 328 kfree(domain->name); 329 else 330 domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED; 331 332 domain->name = name; 333 debugfs_add_domain_dir(domain); 334 335 mutex_unlock(&irq_domain_mutex); 336} 337EXPORT_SYMBOL_GPL(irq_domain_update_bus_token); 338 339/** 340 * irq_domain_create_simple() - Register an irq_domain and optionally map a range of irqs 341 * @fwnode: firmware node for the interrupt controller 342 * @size: total number of irqs in mapping 343 * @first_irq: first number of irq block assigned to the domain, 344 * pass zero to assign irqs on-the-fly. If first_irq is non-zero, then 345 * pre-map all of the irqs in the domain to virqs starting at first_irq. 346 * @ops: domain callbacks 347 * @host_data: Controller private data pointer 348 * 349 * Allocates an irq_domain, and optionally if first_irq is positive then also 350 * allocate irq_descs and map all of the hwirqs to virqs starting at first_irq. 351 * 352 * This is intended to implement the expected behaviour for most 353 * interrupt controllers. If device tree is used, then first_irq will be 0 and 354 * irqs get mapped dynamically on the fly. However, if the controller requires 355 * static virq assignments (non-DT boot) then it will set that up correctly. 356 */ 357struct irq_domain *irq_domain_create_simple(struct fwnode_handle *fwnode, 358 unsigned int size, 359 unsigned int first_irq, 360 const struct irq_domain_ops *ops, 361 void *host_data) 362{ 363 struct irq_domain *domain; 364 365 domain = __irq_domain_add(fwnode, size, size, 0, ops, host_data); 366 if (!domain) 367 return NULL; 368 369 if (first_irq > 0) { 370 if (IS_ENABLED(CONFIG_SPARSE_IRQ)) { 371 /* attempt to allocated irq_descs */ 372 int rc = irq_alloc_descs(first_irq, first_irq, size, 373 of_node_to_nid(to_of_node(fwnode))); 374 if (rc < 0) 375 pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n", 376 first_irq); 377 } 378 irq_domain_associate_many(domain, first_irq, 0, size); 379 } 380 381 return domain; 382} 383EXPORT_SYMBOL_GPL(irq_domain_create_simple); 384 385/** 386 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain. 387 * @of_node: pointer to interrupt controller's device tree node. 388 * @size: total number of irqs in legacy mapping 389 * @first_irq: first number of irq block assigned to the domain 390 * @first_hwirq: first hwirq number to use for the translation. Should normally 391 * be '0', but a positive integer can be used if the effective 392 * hwirqs numbering does not begin at zero. 393 * @ops: map/unmap domain callbacks 394 * @host_data: Controller private data pointer 395 * 396 * Note: the map() callback will be called before this function returns 397 * for all legacy interrupts except 0 (which is always the invalid irq for 398 * a legacy controller). 399 */ 400struct irq_domain *irq_domain_add_legacy(struct device_node *of_node, 401 unsigned int size, 402 unsigned int first_irq, 403 irq_hw_number_t first_hwirq, 404 const struct irq_domain_ops *ops, 405 void *host_data) 406{ 407 return irq_domain_create_legacy(of_node_to_fwnode(of_node), size, 408 first_irq, first_hwirq, ops, host_data); 409} 410EXPORT_SYMBOL_GPL(irq_domain_add_legacy); 411 412struct irq_domain *irq_domain_create_legacy(struct fwnode_handle *fwnode, 413 unsigned int size, 414 unsigned int first_irq, 415 irq_hw_number_t first_hwirq, 416 const struct irq_domain_ops *ops, 417 void *host_data) 418{ 419 struct irq_domain *domain; 420 421 domain = __irq_domain_add(fwnode, first_hwirq + size, first_hwirq + size, 0, ops, host_data); 422 if (domain) 423 irq_domain_associate_many(domain, first_irq, first_hwirq, size); 424 425 return domain; 426} 427EXPORT_SYMBOL_GPL(irq_domain_create_legacy); 428 429/** 430 * irq_find_matching_fwspec() - Locates a domain for a given fwspec 431 * @fwspec: FW specifier for an interrupt 432 * @bus_token: domain-specific data 433 */ 434struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec, 435 enum irq_domain_bus_token bus_token) 436{ 437 struct irq_domain *h, *found = NULL; 438 struct fwnode_handle *fwnode = fwspec->fwnode; 439 int rc; 440 441 /* We might want to match the legacy controller last since 442 * it might potentially be set to match all interrupts in 443 * the absence of a device node. This isn't a problem so far 444 * yet though... 445 * 446 * bus_token == DOMAIN_BUS_ANY matches any domain, any other 447 * values must generate an exact match for the domain to be 448 * selected. 449 */ 450 mutex_lock(&irq_domain_mutex); 451 list_for_each_entry(h, &irq_domain_list, link) { 452 if (h->ops->select && bus_token != DOMAIN_BUS_ANY) 453 rc = h->ops->select(h, fwspec, bus_token); 454 else if (h->ops->match) 455 rc = h->ops->match(h, to_of_node(fwnode), bus_token); 456 else 457 rc = ((fwnode != NULL) && (h->fwnode == fwnode) && 458 ((bus_token == DOMAIN_BUS_ANY) || 459 (h->bus_token == bus_token))); 460 461 if (rc) { 462 found = h; 463 break; 464 } 465 } 466 mutex_unlock(&irq_domain_mutex); 467 return found; 468} 469EXPORT_SYMBOL_GPL(irq_find_matching_fwspec); 470 471/** 472 * irq_set_default_host() - Set a "default" irq domain 473 * @domain: default domain pointer 474 * 475 * For convenience, it's possible to set a "default" domain that will be used 476 * whenever NULL is passed to irq_create_mapping(). It makes life easier for 477 * platforms that want to manipulate a few hard coded interrupt numbers that 478 * aren't properly represented in the device-tree. 479 */ 480void irq_set_default_host(struct irq_domain *domain) 481{ 482 pr_debug("Default domain set to @0x%p\n", domain); 483 484 irq_default_domain = domain; 485} 486EXPORT_SYMBOL_GPL(irq_set_default_host); 487 488/** 489 * irq_get_default_host() - Retrieve the "default" irq domain 490 * 491 * Returns: the default domain, if any. 492 * 493 * Modern code should never use this. This should only be used on 494 * systems that cannot implement a firmware->fwnode mapping (which 495 * both DT and ACPI provide). 496 */ 497struct irq_domain *irq_get_default_host(void) 498{ 499 return irq_default_domain; 500} 501EXPORT_SYMBOL_GPL(irq_get_default_host); 502 503static bool irq_domain_is_nomap(struct irq_domain *domain) 504{ 505 return IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP) && 506 (domain->flags & IRQ_DOMAIN_FLAG_NO_MAP); 507} 508 509static void irq_domain_clear_mapping(struct irq_domain *domain, 510 irq_hw_number_t hwirq) 511{ 512 lockdep_assert_held(&domain->root->mutex); 513 514 if (irq_domain_is_nomap(domain)) 515 return; 516 517 if (hwirq < domain->revmap_size) 518 rcu_assign_pointer(domain->revmap[hwirq], NULL); 519 else 520 radix_tree_delete(&domain->revmap_tree, hwirq); 521} 522 523static void irq_domain_set_mapping(struct irq_domain *domain, 524 irq_hw_number_t hwirq, 525 struct irq_data *irq_data) 526{ 527 /* 528 * This also makes sure that all domains point to the same root when 529 * called from irq_domain_insert_irq() for each domain in a hierarchy. 530 */ 531 lockdep_assert_held(&domain->root->mutex); 532 533 if (irq_domain_is_nomap(domain)) 534 return; 535 536 if (hwirq < domain->revmap_size) 537 rcu_assign_pointer(domain->revmap[hwirq], irq_data); 538 else 539 radix_tree_insert(&domain->revmap_tree, hwirq, irq_data); 540} 541 542static void irq_domain_disassociate(struct irq_domain *domain, unsigned int irq) 543{ 544 struct irq_data *irq_data = irq_get_irq_data(irq); 545 irq_hw_number_t hwirq; 546 547 if (WARN(!irq_data || irq_data->domain != domain, 548 "virq%i doesn't exist; cannot disassociate\n", irq)) 549 return; 550 551 hwirq = irq_data->hwirq; 552 553 mutex_lock(&domain->root->mutex); 554 555 irq_set_status_flags(irq, IRQ_NOREQUEST); 556 557 /* remove chip and handler */ 558 irq_set_chip_and_handler(irq, NULL, NULL); 559 560 /* Make sure it's completed */ 561 synchronize_irq(irq); 562 563 /* Tell the PIC about it */ 564 if (domain->ops->unmap) 565 domain->ops->unmap(domain, irq); 566 smp_mb(); 567 568 irq_data->domain = NULL; 569 irq_data->hwirq = 0; 570 domain->mapcount--; 571 572 /* Clear reverse map for this hwirq */ 573 irq_domain_clear_mapping(domain, hwirq); 574 575 mutex_unlock(&domain->root->mutex); 576} 577 578static int irq_domain_associate_locked(struct irq_domain *domain, unsigned int virq, 579 irq_hw_number_t hwirq) 580{ 581 struct irq_data *irq_data = irq_get_irq_data(virq); 582 int ret; 583 584 if (WARN(hwirq >= domain->hwirq_max, 585 "error: hwirq 0x%x is too large for %s\n", (int)hwirq, domain->name)) 586 return -EINVAL; 587 if (WARN(!irq_data, "error: virq%i is not allocated", virq)) 588 return -EINVAL; 589 if (WARN(irq_data->domain, "error: virq%i is already associated", virq)) 590 return -EINVAL; 591 592 irq_data->hwirq = hwirq; 593 irq_data->domain = domain; 594 if (domain->ops->map) { 595 ret = domain->ops->map(domain, virq, hwirq); 596 if (ret != 0) { 597 /* 598 * If map() returns -EPERM, this interrupt is protected 599 * by the firmware or some other service and shall not 600 * be mapped. Don't bother telling the user about it. 601 */ 602 if (ret != -EPERM) { 603 pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n", 604 domain->name, hwirq, virq, ret); 605 } 606 irq_data->domain = NULL; 607 irq_data->hwirq = 0; 608 return ret; 609 } 610 } 611 612 domain->mapcount++; 613 irq_domain_set_mapping(domain, hwirq, irq_data); 614 615 irq_clear_status_flags(virq, IRQ_NOREQUEST); 616 617 return 0; 618} 619 620int irq_domain_associate(struct irq_domain *domain, unsigned int virq, 621 irq_hw_number_t hwirq) 622{ 623 int ret; 624 625 mutex_lock(&domain->root->mutex); 626 ret = irq_domain_associate_locked(domain, virq, hwirq); 627 mutex_unlock(&domain->root->mutex); 628 629 return ret; 630} 631EXPORT_SYMBOL_GPL(irq_domain_associate); 632 633void irq_domain_associate_many(struct irq_domain *domain, unsigned int irq_base, 634 irq_hw_number_t hwirq_base, int count) 635{ 636 struct device_node *of_node; 637 int i; 638 639 of_node = irq_domain_get_of_node(domain); 640 pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__, 641 of_node_full_name(of_node), irq_base, (int)hwirq_base, count); 642 643 for (i = 0; i < count; i++) 644 irq_domain_associate(domain, irq_base + i, hwirq_base + i); 645} 646EXPORT_SYMBOL_GPL(irq_domain_associate_many); 647 648#ifdef CONFIG_IRQ_DOMAIN_NOMAP 649/** 650 * irq_create_direct_mapping() - Allocate an irq for direct mapping 651 * @domain: domain to allocate the irq for or NULL for default domain 652 * 653 * This routine is used for irq controllers which can choose the hardware 654 * interrupt numbers they generate. In such a case it's simplest to use 655 * the linux irq as the hardware interrupt number. It still uses the linear 656 * or radix tree to store the mapping, but the irq controller can optimize 657 * the revmap path by using the hwirq directly. 658 */ 659unsigned int irq_create_direct_mapping(struct irq_domain *domain) 660{ 661 struct device_node *of_node; 662 unsigned int virq; 663 664 if (domain == NULL) 665 domain = irq_default_domain; 666 667 of_node = irq_domain_get_of_node(domain); 668 virq = irq_alloc_desc_from(1, of_node_to_nid(of_node)); 669 if (!virq) { 670 pr_debug("create_direct virq allocation failed\n"); 671 return 0; 672 } 673 if (virq >= domain->hwirq_max) { 674 pr_err("ERROR: no free irqs available below %lu maximum\n", 675 domain->hwirq_max); 676 irq_free_desc(virq); 677 return 0; 678 } 679 pr_debug("create_direct obtained virq %d\n", virq); 680 681 if (irq_domain_associate(domain, virq, virq)) { 682 irq_free_desc(virq); 683 return 0; 684 } 685 686 return virq; 687} 688EXPORT_SYMBOL_GPL(irq_create_direct_mapping); 689#endif 690 691static unsigned int irq_create_mapping_affinity_locked(struct irq_domain *domain, 692 irq_hw_number_t hwirq, 693 const struct irq_affinity_desc *affinity) 694{ 695 struct device_node *of_node = irq_domain_get_of_node(domain); 696 int virq; 697 698 pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq); 699 700 /* Allocate a virtual interrupt number */ 701 virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node), 702 affinity); 703 if (virq <= 0) { 704 pr_debug("-> virq allocation failed\n"); 705 return 0; 706 } 707 708 if (irq_domain_associate_locked(domain, virq, hwirq)) { 709 irq_free_desc(virq); 710 return 0; 711 } 712 713 pr_debug("irq %lu on domain %s mapped to virtual irq %u\n", 714 hwirq, of_node_full_name(of_node), virq); 715 716 return virq; 717} 718 719/** 720 * irq_create_mapping_affinity() - Map a hardware interrupt into linux irq space 721 * @domain: domain owning this hardware interrupt or NULL for default domain 722 * @hwirq: hardware irq number in that domain space 723 * @affinity: irq affinity 724 * 725 * Only one mapping per hardware interrupt is permitted. Returns a linux 726 * irq number. 727 * If the sense/trigger is to be specified, set_irq_type() should be called 728 * on the number returned from that call. 729 */ 730unsigned int irq_create_mapping_affinity(struct irq_domain *domain, 731 irq_hw_number_t hwirq, 732 const struct irq_affinity_desc *affinity) 733{ 734 int virq; 735 736 /* Look for default domain if necessary */ 737 if (domain == NULL) 738 domain = irq_default_domain; 739 if (domain == NULL) { 740 WARN(1, "%s(, %lx) called with NULL domain\n", __func__, hwirq); 741 return 0; 742 } 743 744 mutex_lock(&domain->root->mutex); 745 746 /* Check if mapping already exists */ 747 virq = irq_find_mapping(domain, hwirq); 748 if (virq) { 749 pr_debug("existing mapping on virq %d\n", virq); 750 goto out; 751 } 752 753 virq = irq_create_mapping_affinity_locked(domain, hwirq, affinity); 754out: 755 mutex_unlock(&domain->root->mutex); 756 757 return virq; 758} 759EXPORT_SYMBOL_GPL(irq_create_mapping_affinity); 760 761static int irq_domain_translate(struct irq_domain *d, 762 struct irq_fwspec *fwspec, 763 irq_hw_number_t *hwirq, unsigned int *type) 764{ 765#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY 766 if (d->ops->translate) 767 return d->ops->translate(d, fwspec, hwirq, type); 768#endif 769 if (d->ops->xlate) 770 return d->ops->xlate(d, to_of_node(fwspec->fwnode), 771 fwspec->param, fwspec->param_count, 772 hwirq, type); 773 774 /* If domain has no translation, then we assume interrupt line */ 775 *hwirq = fwspec->param[0]; 776 return 0; 777} 778 779void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args, 780 unsigned int count, struct irq_fwspec *fwspec) 781{ 782 int i; 783 784 fwspec->fwnode = of_node_to_fwnode(np); 785 fwspec->param_count = count; 786 787 for (i = 0; i < count; i++) 788 fwspec->param[i] = args[i]; 789} 790EXPORT_SYMBOL_GPL(of_phandle_args_to_fwspec); 791 792unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec) 793{ 794 struct irq_domain *domain; 795 struct irq_data *irq_data; 796 irq_hw_number_t hwirq; 797 unsigned int type = IRQ_TYPE_NONE; 798 int virq; 799 800 if (fwspec->fwnode) { 801 domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_WIRED); 802 if (!domain) 803 domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_ANY); 804 } else { 805 domain = irq_default_domain; 806 } 807 808 if (!domain) { 809 pr_warn("no irq domain found for %s !\n", 810 of_node_full_name(to_of_node(fwspec->fwnode))); 811 return 0; 812 } 813 814 if (irq_domain_translate(domain, fwspec, &hwirq, &type)) 815 return 0; 816 817 /* 818 * WARN if the irqchip returns a type with bits 819 * outside the sense mask set and clear these bits. 820 */ 821 if (WARN_ON(type & ~IRQ_TYPE_SENSE_MASK)) 822 type &= IRQ_TYPE_SENSE_MASK; 823 824 mutex_lock(&domain->root->mutex); 825 826 /* 827 * If we've already configured this interrupt, 828 * don't do it again, or hell will break loose. 829 */ 830 virq = irq_find_mapping(domain, hwirq); 831 if (virq) { 832 /* 833 * If the trigger type is not specified or matches the 834 * current trigger type then we are done so return the 835 * interrupt number. 836 */ 837 if (type == IRQ_TYPE_NONE || type == irq_get_trigger_type(virq)) 838 goto out; 839 840 /* 841 * If the trigger type has not been set yet, then set 842 * it now and return the interrupt number. 843 */ 844 if (irq_get_trigger_type(virq) == IRQ_TYPE_NONE) { 845 irq_data = irq_get_irq_data(virq); 846 if (!irq_data) { 847 virq = 0; 848 goto out; 849 } 850 851 irqd_set_trigger_type(irq_data, type); 852 goto out; 853 } 854 855 pr_warn("type mismatch, failed to map hwirq-%lu for %s!\n", 856 hwirq, of_node_full_name(to_of_node(fwspec->fwnode))); 857 virq = 0; 858 goto out; 859 } 860 861 if (irq_domain_is_hierarchy(domain)) { 862 if (irq_domain_is_msi_device(domain)) { 863 mutex_unlock(&domain->root->mutex); 864 virq = msi_device_domain_alloc_wired(domain, hwirq, type); 865 mutex_lock(&domain->root->mutex); 866 } else 867 virq = irq_domain_alloc_irqs_locked(domain, -1, 1, NUMA_NO_NODE, 868 fwspec, false, NULL); 869 if (virq <= 0) { 870 virq = 0; 871 goto out; 872 } 873 } else { 874 /* Create mapping */ 875 virq = irq_create_mapping_affinity_locked(domain, hwirq, NULL); 876 if (!virq) 877 goto out; 878 } 879 880 irq_data = irq_get_irq_data(virq); 881 if (WARN_ON(!irq_data)) { 882 virq = 0; 883 goto out; 884 } 885 886 /* Store trigger type */ 887 irqd_set_trigger_type(irq_data, type); 888out: 889 mutex_unlock(&domain->root->mutex); 890 891 return virq; 892} 893EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping); 894 895unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data) 896{ 897 struct irq_fwspec fwspec; 898 899 of_phandle_args_to_fwspec(irq_data->np, irq_data->args, 900 irq_data->args_count, &fwspec); 901 902 return irq_create_fwspec_mapping(&fwspec); 903} 904EXPORT_SYMBOL_GPL(irq_create_of_mapping); 905 906/** 907 * irq_dispose_mapping() - Unmap an interrupt 908 * @virq: linux irq number of the interrupt to unmap 909 */ 910void irq_dispose_mapping(unsigned int virq) 911{ 912 struct irq_data *irq_data = irq_get_irq_data(virq); 913 struct irq_domain *domain; 914 915 if (!virq || !irq_data) 916 return; 917 918 domain = irq_data->domain; 919 if (WARN_ON(domain == NULL)) 920 return; 921 922 if (irq_domain_is_hierarchy(domain)) { 923 irq_domain_free_one_irq(domain, virq); 924 } else { 925 irq_domain_disassociate(domain, virq); 926 irq_free_desc(virq); 927 } 928} 929EXPORT_SYMBOL_GPL(irq_dispose_mapping); 930 931/** 932 * __irq_resolve_mapping() - Find a linux irq from a hw irq number. 933 * @domain: domain owning this hardware interrupt 934 * @hwirq: hardware irq number in that domain space 935 * @irq: optional pointer to return the Linux irq if required 936 * 937 * Returns the interrupt descriptor. 938 */ 939struct irq_desc *__irq_resolve_mapping(struct irq_domain *domain, 940 irq_hw_number_t hwirq, 941 unsigned int *irq) 942{ 943 struct irq_desc *desc = NULL; 944 struct irq_data *data; 945 946 /* Look for default domain if necessary */ 947 if (domain == NULL) 948 domain = irq_default_domain; 949 if (domain == NULL) 950 return desc; 951 952 if (irq_domain_is_nomap(domain)) { 953 if (hwirq < domain->hwirq_max) { 954 data = irq_domain_get_irq_data(domain, hwirq); 955 if (data && data->hwirq == hwirq) 956 desc = irq_data_to_desc(data); 957 if (irq && desc) 958 *irq = hwirq; 959 } 960 961 return desc; 962 } 963 964 rcu_read_lock(); 965 /* Check if the hwirq is in the linear revmap. */ 966 if (hwirq < domain->revmap_size) 967 data = rcu_dereference(domain->revmap[hwirq]); 968 else 969 data = radix_tree_lookup(&domain->revmap_tree, hwirq); 970 971 if (likely(data)) { 972 desc = irq_data_to_desc(data); 973 if (irq) 974 *irq = data->irq; 975 } 976 977 rcu_read_unlock(); 978 return desc; 979} 980EXPORT_SYMBOL_GPL(__irq_resolve_mapping); 981 982/** 983 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings 984 * 985 * Device Tree IRQ specifier translation function which works with one cell 986 * bindings where the cell value maps directly to the hwirq number. 987 */ 988int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr, 989 const u32 *intspec, unsigned int intsize, 990 unsigned long *out_hwirq, unsigned int *out_type) 991{ 992 if (WARN_ON(intsize < 1)) 993 return -EINVAL; 994 *out_hwirq = intspec[0]; 995 *out_type = IRQ_TYPE_NONE; 996 return 0; 997} 998EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell); 999 1000/** 1001 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings 1002 * 1003 * Device Tree IRQ specifier translation function which works with two cell 1004 * bindings where the cell values map directly to the hwirq number 1005 * and linux irq flags. 1006 */ 1007int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr, 1008 const u32 *intspec, unsigned int intsize, 1009 irq_hw_number_t *out_hwirq, unsigned int *out_type) 1010{ 1011 struct irq_fwspec fwspec; 1012 1013 of_phandle_args_to_fwspec(ctrlr, intspec, intsize, &fwspec); 1014 return irq_domain_translate_twocell(d, &fwspec, out_hwirq, out_type); 1015} 1016EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell); 1017 1018/** 1019 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings 1020 * 1021 * Device Tree IRQ specifier translation function which works with either one 1022 * or two cell bindings where the cell values map directly to the hwirq number 1023 * and linux irq flags. 1024 * 1025 * Note: don't use this function unless your interrupt controller explicitly 1026 * supports both one and two cell bindings. For the majority of controllers 1027 * the _onecell() or _twocell() variants above should be used. 1028 */ 1029int irq_domain_xlate_onetwocell(struct irq_domain *d, 1030 struct device_node *ctrlr, 1031 const u32 *intspec, unsigned int intsize, 1032 unsigned long *out_hwirq, unsigned int *out_type) 1033{ 1034 if (WARN_ON(intsize < 1)) 1035 return -EINVAL; 1036 *out_hwirq = intspec[0]; 1037 if (intsize > 1) 1038 *out_type = intspec[1] & IRQ_TYPE_SENSE_MASK; 1039 else 1040 *out_type = IRQ_TYPE_NONE; 1041 return 0; 1042} 1043EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell); 1044 1045const struct irq_domain_ops irq_domain_simple_ops = { 1046 .xlate = irq_domain_xlate_onetwocell, 1047}; 1048EXPORT_SYMBOL_GPL(irq_domain_simple_ops); 1049 1050/** 1051 * irq_domain_translate_onecell() - Generic translate for direct one cell 1052 * bindings 1053 */ 1054int irq_domain_translate_onecell(struct irq_domain *d, 1055 struct irq_fwspec *fwspec, 1056 unsigned long *out_hwirq, 1057 unsigned int *out_type) 1058{ 1059 if (WARN_ON(fwspec->param_count < 1)) 1060 return -EINVAL; 1061 *out_hwirq = fwspec->param[0]; 1062 *out_type = IRQ_TYPE_NONE; 1063 return 0; 1064} 1065EXPORT_SYMBOL_GPL(irq_domain_translate_onecell); 1066 1067/** 1068 * irq_domain_translate_twocell() - Generic translate for direct two cell 1069 * bindings 1070 * 1071 * Device Tree IRQ specifier translation function which works with two cell 1072 * bindings where the cell values map directly to the hwirq number 1073 * and linux irq flags. 1074 */ 1075int irq_domain_translate_twocell(struct irq_domain *d, 1076 struct irq_fwspec *fwspec, 1077 unsigned long *out_hwirq, 1078 unsigned int *out_type) 1079{ 1080 if (WARN_ON(fwspec->param_count < 2)) 1081 return -EINVAL; 1082 *out_hwirq = fwspec->param[0]; 1083 *out_type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK; 1084 return 0; 1085} 1086EXPORT_SYMBOL_GPL(irq_domain_translate_twocell); 1087 1088int irq_domain_alloc_descs(int virq, unsigned int cnt, irq_hw_number_t hwirq, 1089 int node, const struct irq_affinity_desc *affinity) 1090{ 1091 unsigned int hint; 1092 1093 if (virq >= 0) { 1094 virq = __irq_alloc_descs(virq, virq, cnt, node, THIS_MODULE, 1095 affinity); 1096 } else { 1097 hint = hwirq % nr_irqs; 1098 if (hint == 0) 1099 hint++; 1100 virq = __irq_alloc_descs(-1, hint, cnt, node, THIS_MODULE, 1101 affinity); 1102 if (virq <= 0 && hint > 1) { 1103 virq = __irq_alloc_descs(-1, 1, cnt, node, THIS_MODULE, 1104 affinity); 1105 } 1106 } 1107 1108 return virq; 1109} 1110 1111/** 1112 * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data 1113 * @irq_data: The pointer to irq_data 1114 */ 1115void irq_domain_reset_irq_data(struct irq_data *irq_data) 1116{ 1117 irq_data->hwirq = 0; 1118 irq_data->chip = &no_irq_chip; 1119 irq_data->chip_data = NULL; 1120} 1121EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data); 1122 1123#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY 1124/** 1125 * irq_domain_create_hierarchy - Add a irqdomain into the hierarchy 1126 * @parent: Parent irq domain to associate with the new domain 1127 * @flags: Irq domain flags associated to the domain 1128 * @size: Size of the domain. See below 1129 * @fwnode: Optional fwnode of the interrupt controller 1130 * @ops: Pointer to the interrupt domain callbacks 1131 * @host_data: Controller private data pointer 1132 * 1133 * If @size is 0 a tree domain is created, otherwise a linear domain. 1134 * 1135 * If successful the parent is associated to the new domain and the 1136 * domain flags are set. 1137 * Returns pointer to IRQ domain, or NULL on failure. 1138 */ 1139struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent, 1140 unsigned int flags, 1141 unsigned int size, 1142 struct fwnode_handle *fwnode, 1143 const struct irq_domain_ops *ops, 1144 void *host_data) 1145{ 1146 struct irq_domain *domain; 1147 1148 if (size) 1149 domain = __irq_domain_create(fwnode, size, size, 0, ops, host_data); 1150 else 1151 domain = __irq_domain_create(fwnode, 0, ~0, 0, ops, host_data); 1152 1153 if (domain) { 1154 if (parent) 1155 domain->root = parent->root; 1156 domain->parent = parent; 1157 domain->flags |= flags; 1158 1159 __irq_domain_publish(domain); 1160 } 1161 1162 return domain; 1163} 1164EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy); 1165 1166static void irq_domain_insert_irq(int virq) 1167{ 1168 struct irq_data *data; 1169 1170 for (data = irq_get_irq_data(virq); data; data = data->parent_data) { 1171 struct irq_domain *domain = data->domain; 1172 1173 domain->mapcount++; 1174 irq_domain_set_mapping(domain, data->hwirq, data); 1175 } 1176 1177 irq_clear_status_flags(virq, IRQ_NOREQUEST); 1178} 1179 1180static void irq_domain_remove_irq(int virq) 1181{ 1182 struct irq_data *data; 1183 1184 irq_set_status_flags(virq, IRQ_NOREQUEST); 1185 irq_set_chip_and_handler(virq, NULL, NULL); 1186 synchronize_irq(virq); 1187 smp_mb(); 1188 1189 for (data = irq_get_irq_data(virq); data; data = data->parent_data) { 1190 struct irq_domain *domain = data->domain; 1191 irq_hw_number_t hwirq = data->hwirq; 1192 1193 domain->mapcount--; 1194 irq_domain_clear_mapping(domain, hwirq); 1195 } 1196} 1197 1198static struct irq_data *irq_domain_insert_irq_data(struct irq_domain *domain, 1199 struct irq_data *child) 1200{ 1201 struct irq_data *irq_data; 1202 1203 irq_data = kzalloc_node(sizeof(*irq_data), GFP_KERNEL, 1204 irq_data_get_node(child)); 1205 if (irq_data) { 1206 child->parent_data = irq_data; 1207 irq_data->irq = child->irq; 1208 irq_data->common = child->common; 1209 irq_data->domain = domain; 1210 } 1211 1212 return irq_data; 1213} 1214 1215static void __irq_domain_free_hierarchy(struct irq_data *irq_data) 1216{ 1217 struct irq_data *tmp; 1218 1219 while (irq_data) { 1220 tmp = irq_data; 1221 irq_data = irq_data->parent_data; 1222 kfree(tmp); 1223 } 1224} 1225 1226static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs) 1227{ 1228 struct irq_data *irq_data, *tmp; 1229 int i; 1230 1231 for (i = 0; i < nr_irqs; i++) { 1232 irq_data = irq_get_irq_data(virq + i); 1233 tmp = irq_data->parent_data; 1234 irq_data->parent_data = NULL; 1235 irq_data->domain = NULL; 1236 1237 __irq_domain_free_hierarchy(tmp); 1238 } 1239} 1240 1241/** 1242 * irq_domain_disconnect_hierarchy - Mark the first unused level of a hierarchy 1243 * @domain: IRQ domain from which the hierarchy is to be disconnected 1244 * @virq: IRQ number where the hierarchy is to be trimmed 1245 * 1246 * Marks the @virq level belonging to @domain as disconnected. 1247 * Returns -EINVAL if @virq doesn't have a valid irq_data pointing 1248 * to @domain. 1249 * 1250 * Its only use is to be able to trim levels of hierarchy that do not 1251 * have any real meaning for this interrupt, and that the driver marks 1252 * as such from its .alloc() callback. 1253 */ 1254int irq_domain_disconnect_hierarchy(struct irq_domain *domain, 1255 unsigned int virq) 1256{ 1257 struct irq_data *irqd; 1258 1259 irqd = irq_domain_get_irq_data(domain, virq); 1260 if (!irqd) 1261 return -EINVAL; 1262 1263 irqd->chip = ERR_PTR(-ENOTCONN); 1264 return 0; 1265} 1266EXPORT_SYMBOL_GPL(irq_domain_disconnect_hierarchy); 1267 1268static int irq_domain_trim_hierarchy(unsigned int virq) 1269{ 1270 struct irq_data *tail, *irqd, *irq_data; 1271 1272 irq_data = irq_get_irq_data(virq); 1273 tail = NULL; 1274 1275 /* The first entry must have a valid irqchip */ 1276 if (!irq_data->chip || IS_ERR(irq_data->chip)) 1277 return -EINVAL; 1278 1279 /* 1280 * Validate that the irq_data chain is sane in the presence of 1281 * a hierarchy trimming marker. 1282 */ 1283 for (irqd = irq_data->parent_data; irqd; irq_data = irqd, irqd = irqd->parent_data) { 1284 /* Can't have a valid irqchip after a trim marker */ 1285 if (irqd->chip && tail) 1286 return -EINVAL; 1287 1288 /* Can't have an empty irqchip before a trim marker */ 1289 if (!irqd->chip && !tail) 1290 return -EINVAL; 1291 1292 if (IS_ERR(irqd->chip)) { 1293 /* Only -ENOTCONN is a valid trim marker */ 1294 if (PTR_ERR(irqd->chip) != -ENOTCONN) 1295 return -EINVAL; 1296 1297 tail = irq_data; 1298 } 1299 } 1300 1301 /* No trim marker, nothing to do */ 1302 if (!tail) 1303 return 0; 1304 1305 pr_info("IRQ%d: trimming hierarchy from %s\n", 1306 virq, tail->parent_data->domain->name); 1307 1308 /* Sever the inner part of the hierarchy... */ 1309 irqd = tail; 1310 tail = tail->parent_data; 1311 irqd->parent_data = NULL; 1312 __irq_domain_free_hierarchy(tail); 1313 1314 return 0; 1315} 1316 1317static int irq_domain_alloc_irq_data(struct irq_domain *domain, 1318 unsigned int virq, unsigned int nr_irqs) 1319{ 1320 struct irq_data *irq_data; 1321 struct irq_domain *parent; 1322 int i; 1323 1324 /* The outermost irq_data is embedded in struct irq_desc */ 1325 for (i = 0; i < nr_irqs; i++) { 1326 irq_data = irq_get_irq_data(virq + i); 1327 irq_data->domain = domain; 1328 1329 for (parent = domain->parent; parent; parent = parent->parent) { 1330 irq_data = irq_domain_insert_irq_data(parent, irq_data); 1331 if (!irq_data) { 1332 irq_domain_free_irq_data(virq, i + 1); 1333 return -ENOMEM; 1334 } 1335 } 1336 } 1337 1338 return 0; 1339} 1340 1341/** 1342 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain 1343 * @domain: domain to match 1344 * @virq: IRQ number to get irq_data 1345 */ 1346struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain, 1347 unsigned int virq) 1348{ 1349 struct irq_data *irq_data; 1350 1351 for (irq_data = irq_get_irq_data(virq); irq_data; 1352 irq_data = irq_data->parent_data) 1353 if (irq_data->domain == domain) 1354 return irq_data; 1355 1356 return NULL; 1357} 1358EXPORT_SYMBOL_GPL(irq_domain_get_irq_data); 1359 1360/** 1361 * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain 1362 * @domain: Interrupt domain to match 1363 * @virq: IRQ number 1364 * @hwirq: The hwirq number 1365 * @chip: The associated interrupt chip 1366 * @chip_data: The associated chip data 1367 */ 1368int irq_domain_set_hwirq_and_chip(struct irq_domain *domain, unsigned int virq, 1369 irq_hw_number_t hwirq, 1370 const struct irq_chip *chip, 1371 void *chip_data) 1372{ 1373 struct irq_data *irq_data = irq_domain_get_irq_data(domain, virq); 1374 1375 if (!irq_data) 1376 return -ENOENT; 1377 1378 irq_data->hwirq = hwirq; 1379 irq_data->chip = (struct irq_chip *)(chip ? chip : &no_irq_chip); 1380 irq_data->chip_data = chip_data; 1381 1382 return 0; 1383} 1384EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip); 1385 1386/** 1387 * irq_domain_set_info - Set the complete data for a @virq in @domain 1388 * @domain: Interrupt domain to match 1389 * @virq: IRQ number 1390 * @hwirq: The hardware interrupt number 1391 * @chip: The associated interrupt chip 1392 * @chip_data: The associated interrupt chip data 1393 * @handler: The interrupt flow handler 1394 * @handler_data: The interrupt flow handler data 1395 * @handler_name: The interrupt handler name 1396 */ 1397void irq_domain_set_info(struct irq_domain *domain, unsigned int virq, 1398 irq_hw_number_t hwirq, const struct irq_chip *chip, 1399 void *chip_data, irq_flow_handler_t handler, 1400 void *handler_data, const char *handler_name) 1401{ 1402 irq_domain_set_hwirq_and_chip(domain, virq, hwirq, chip, chip_data); 1403 __irq_set_handler(virq, handler, 0, handler_name); 1404 irq_set_handler_data(virq, handler_data); 1405} 1406EXPORT_SYMBOL(irq_domain_set_info); 1407 1408/** 1409 * irq_domain_free_irqs_common - Clear irq_data and free the parent 1410 * @domain: Interrupt domain to match 1411 * @virq: IRQ number to start with 1412 * @nr_irqs: The number of irqs to free 1413 */ 1414void irq_domain_free_irqs_common(struct irq_domain *domain, unsigned int virq, 1415 unsigned int nr_irqs) 1416{ 1417 struct irq_data *irq_data; 1418 int i; 1419 1420 for (i = 0; i < nr_irqs; i++) { 1421 irq_data = irq_domain_get_irq_data(domain, virq + i); 1422 if (irq_data) 1423 irq_domain_reset_irq_data(irq_data); 1424 } 1425 irq_domain_free_irqs_parent(domain, virq, nr_irqs); 1426} 1427EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common); 1428 1429/** 1430 * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent 1431 * @domain: Interrupt domain to match 1432 * @virq: IRQ number to start with 1433 * @nr_irqs: The number of irqs to free 1434 */ 1435void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq, 1436 unsigned int nr_irqs) 1437{ 1438 int i; 1439 1440 for (i = 0; i < nr_irqs; i++) { 1441 irq_set_handler_data(virq + i, NULL); 1442 irq_set_handler(virq + i, NULL); 1443 } 1444 irq_domain_free_irqs_common(domain, virq, nr_irqs); 1445} 1446 1447static void irq_domain_free_irqs_hierarchy(struct irq_domain *domain, 1448 unsigned int irq_base, 1449 unsigned int nr_irqs) 1450{ 1451 unsigned int i; 1452 1453 if (!domain->ops->free) 1454 return; 1455 1456 for (i = 0; i < nr_irqs; i++) { 1457 if (irq_domain_get_irq_data(domain, irq_base + i)) 1458 domain->ops->free(domain, irq_base + i, 1); 1459 } 1460} 1461 1462int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain, 1463 unsigned int irq_base, 1464 unsigned int nr_irqs, void *arg) 1465{ 1466 if (!domain->ops->alloc) { 1467 pr_debug("domain->ops->alloc() is NULL\n"); 1468 return -ENOSYS; 1469 } 1470 1471 return domain->ops->alloc(domain, irq_base, nr_irqs, arg); 1472} 1473 1474static int irq_domain_alloc_irqs_locked(struct irq_domain *domain, int irq_base, 1475 unsigned int nr_irqs, int node, void *arg, 1476 bool realloc, const struct irq_affinity_desc *affinity) 1477{ 1478 int i, ret, virq; 1479 1480 if (realloc && irq_base >= 0) { 1481 virq = irq_base; 1482 } else { 1483 virq = irq_domain_alloc_descs(irq_base, nr_irqs, 0, node, 1484 affinity); 1485 if (virq < 0) { 1486 pr_debug("cannot allocate IRQ(base %d, count %d)\n", 1487 irq_base, nr_irqs); 1488 return virq; 1489 } 1490 } 1491 1492 if (irq_domain_alloc_irq_data(domain, virq, nr_irqs)) { 1493 pr_debug("cannot allocate memory for IRQ%d\n", virq); 1494 ret = -ENOMEM; 1495 goto out_free_desc; 1496 } 1497 1498 ret = irq_domain_alloc_irqs_hierarchy(domain, virq, nr_irqs, arg); 1499 if (ret < 0) 1500 goto out_free_irq_data; 1501 1502 for (i = 0; i < nr_irqs; i++) { 1503 ret = irq_domain_trim_hierarchy(virq + i); 1504 if (ret) 1505 goto out_free_irq_data; 1506 } 1507 1508 for (i = 0; i < nr_irqs; i++) 1509 irq_domain_insert_irq(virq + i); 1510 1511 return virq; 1512 1513out_free_irq_data: 1514 irq_domain_free_irq_data(virq, nr_irqs); 1515out_free_desc: 1516 irq_free_descs(virq, nr_irqs); 1517 return ret; 1518} 1519 1520/** 1521 * __irq_domain_alloc_irqs - Allocate IRQs from domain 1522 * @domain: domain to allocate from 1523 * @irq_base: allocate specified IRQ number if irq_base >= 0 1524 * @nr_irqs: number of IRQs to allocate 1525 * @node: NUMA node id for memory allocation 1526 * @arg: domain specific argument 1527 * @realloc: IRQ descriptors have already been allocated if true 1528 * @affinity: Optional irq affinity mask for multiqueue devices 1529 * 1530 * Allocate IRQ numbers and initialized all data structures to support 1531 * hierarchy IRQ domains. 1532 * Parameter @realloc is mainly to support legacy IRQs. 1533 * Returns error code or allocated IRQ number 1534 * 1535 * The whole process to setup an IRQ has been split into two steps. 1536 * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ 1537 * descriptor and required hardware resources. The second step, 1538 * irq_domain_activate_irq(), is to program the hardware with preallocated 1539 * resources. In this way, it's easier to rollback when failing to 1540 * allocate resources. 1541 */ 1542int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base, 1543 unsigned int nr_irqs, int node, void *arg, 1544 bool realloc, const struct irq_affinity_desc *affinity) 1545{ 1546 int ret; 1547 1548 if (domain == NULL) { 1549 domain = irq_default_domain; 1550 if (WARN(!domain, "domain is NULL; cannot allocate IRQ\n")) 1551 return -EINVAL; 1552 } 1553 1554 mutex_lock(&domain->root->mutex); 1555 ret = irq_domain_alloc_irqs_locked(domain, irq_base, nr_irqs, node, arg, 1556 realloc, affinity); 1557 mutex_unlock(&domain->root->mutex); 1558 1559 return ret; 1560} 1561EXPORT_SYMBOL_GPL(__irq_domain_alloc_irqs); 1562 1563/* The irq_data was moved, fix the revmap to refer to the new location */ 1564static void irq_domain_fix_revmap(struct irq_data *d) 1565{ 1566 void __rcu **slot; 1567 1568 lockdep_assert_held(&d->domain->root->mutex); 1569 1570 if (irq_domain_is_nomap(d->domain)) 1571 return; 1572 1573 /* Fix up the revmap. */ 1574 if (d->hwirq < d->domain->revmap_size) { 1575 /* Not using radix tree */ 1576 rcu_assign_pointer(d->domain->revmap[d->hwirq], d); 1577 } else { 1578 slot = radix_tree_lookup_slot(&d->domain->revmap_tree, d->hwirq); 1579 if (slot) 1580 radix_tree_replace_slot(&d->domain->revmap_tree, slot, d); 1581 } 1582} 1583 1584/** 1585 * irq_domain_push_irq() - Push a domain in to the top of a hierarchy. 1586 * @domain: Domain to push. 1587 * @virq: Irq to push the domain in to. 1588 * @arg: Passed to the irq_domain_ops alloc() function. 1589 * 1590 * For an already existing irqdomain hierarchy, as might be obtained 1591 * via a call to pci_enable_msix(), add an additional domain to the 1592 * head of the processing chain. Must be called before request_irq() 1593 * has been called. 1594 */ 1595int irq_domain_push_irq(struct irq_domain *domain, int virq, void *arg) 1596{ 1597 struct irq_data *irq_data = irq_get_irq_data(virq); 1598 struct irq_data *parent_irq_data; 1599 struct irq_desc *desc; 1600 int rv = 0; 1601 1602 /* 1603 * Check that no action has been set, which indicates the virq 1604 * is in a state where this function doesn't have to deal with 1605 * races between interrupt handling and maintaining the 1606 * hierarchy. This will catch gross misuse. Attempting to 1607 * make the check race free would require holding locks across 1608 * calls to struct irq_domain_ops->alloc(), which could lead 1609 * to deadlock, so we just do a simple check before starting. 1610 */ 1611 desc = irq_to_desc(virq); 1612 if (!desc) 1613 return -EINVAL; 1614 if (WARN_ON(desc->action)) 1615 return -EBUSY; 1616 1617 if (domain == NULL) 1618 return -EINVAL; 1619 1620 if (WARN_ON(!irq_domain_is_hierarchy(domain))) 1621 return -EINVAL; 1622 1623 if (!irq_data) 1624 return -EINVAL; 1625 1626 if (domain->parent != irq_data->domain) 1627 return -EINVAL; 1628 1629 parent_irq_data = kzalloc_node(sizeof(*parent_irq_data), GFP_KERNEL, 1630 irq_data_get_node(irq_data)); 1631 if (!parent_irq_data) 1632 return -ENOMEM; 1633 1634 mutex_lock(&domain->root->mutex); 1635 1636 /* Copy the original irq_data. */ 1637 *parent_irq_data = *irq_data; 1638 1639 /* 1640 * Overwrite the irq_data, which is embedded in struct irq_desc, with 1641 * values for this domain. 1642 */ 1643 irq_data->parent_data = parent_irq_data; 1644 irq_data->domain = domain; 1645 irq_data->mask = 0; 1646 irq_data->hwirq = 0; 1647 irq_data->chip = NULL; 1648 irq_data->chip_data = NULL; 1649 1650 /* May (probably does) set hwirq, chip, etc. */ 1651 rv = irq_domain_alloc_irqs_hierarchy(domain, virq, 1, arg); 1652 if (rv) { 1653 /* Restore the original irq_data. */ 1654 *irq_data = *parent_irq_data; 1655 kfree(parent_irq_data); 1656 goto error; 1657 } 1658 1659 irq_domain_fix_revmap(parent_irq_data); 1660 irq_domain_set_mapping(domain, irq_data->hwirq, irq_data); 1661error: 1662 mutex_unlock(&domain->root->mutex); 1663 1664 return rv; 1665} 1666EXPORT_SYMBOL_GPL(irq_domain_push_irq); 1667 1668/** 1669 * irq_domain_pop_irq() - Remove a domain from the top of a hierarchy. 1670 * @domain: Domain to remove. 1671 * @virq: Irq to remove the domain from. 1672 * 1673 * Undo the effects of a call to irq_domain_push_irq(). Must be 1674 * called either before request_irq() or after free_irq(). 1675 */ 1676int irq_domain_pop_irq(struct irq_domain *domain, int virq) 1677{ 1678 struct irq_data *irq_data = irq_get_irq_data(virq); 1679 struct irq_data *parent_irq_data; 1680 struct irq_data *tmp_irq_data; 1681 struct irq_desc *desc; 1682 1683 /* 1684 * Check that no action is set, which indicates the virq is in 1685 * a state where this function doesn't have to deal with races 1686 * between interrupt handling and maintaining the hierarchy. 1687 * This will catch gross misuse. Attempting to make the check 1688 * race free would require holding locks across calls to 1689 * struct irq_domain_ops->free(), which could lead to 1690 * deadlock, so we just do a simple check before starting. 1691 */ 1692 desc = irq_to_desc(virq); 1693 if (!desc) 1694 return -EINVAL; 1695 if (WARN_ON(desc->action)) 1696 return -EBUSY; 1697 1698 if (domain == NULL) 1699 return -EINVAL; 1700 1701 if (!irq_data) 1702 return -EINVAL; 1703 1704 tmp_irq_data = irq_domain_get_irq_data(domain, virq); 1705 1706 /* We can only "pop" if this domain is at the top of the list */ 1707 if (WARN_ON(irq_data != tmp_irq_data)) 1708 return -EINVAL; 1709 1710 if (WARN_ON(irq_data->domain != domain)) 1711 return -EINVAL; 1712 1713 parent_irq_data = irq_data->parent_data; 1714 if (WARN_ON(!parent_irq_data)) 1715 return -EINVAL; 1716 1717 mutex_lock(&domain->root->mutex); 1718 1719 irq_data->parent_data = NULL; 1720 1721 irq_domain_clear_mapping(domain, irq_data->hwirq); 1722 irq_domain_free_irqs_hierarchy(domain, virq, 1); 1723 1724 /* Restore the original irq_data. */ 1725 *irq_data = *parent_irq_data; 1726 1727 irq_domain_fix_revmap(irq_data); 1728 1729 mutex_unlock(&domain->root->mutex); 1730 1731 kfree(parent_irq_data); 1732 1733 return 0; 1734} 1735EXPORT_SYMBOL_GPL(irq_domain_pop_irq); 1736 1737/** 1738 * irq_domain_free_irqs - Free IRQ number and associated data structures 1739 * @virq: base IRQ number 1740 * @nr_irqs: number of IRQs to free 1741 */ 1742void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs) 1743{ 1744 struct irq_data *data = irq_get_irq_data(virq); 1745 struct irq_domain *domain; 1746 int i; 1747 1748 if (WARN(!data || !data->domain || !data->domain->ops->free, 1749 "NULL pointer, cannot free irq\n")) 1750 return; 1751 1752 domain = data->domain; 1753 1754 mutex_lock(&domain->root->mutex); 1755 for (i = 0; i < nr_irqs; i++) 1756 irq_domain_remove_irq(virq + i); 1757 irq_domain_free_irqs_hierarchy(domain, virq, nr_irqs); 1758 mutex_unlock(&domain->root->mutex); 1759 1760 irq_domain_free_irq_data(virq, nr_irqs); 1761 irq_free_descs(virq, nr_irqs); 1762} 1763 1764static void irq_domain_free_one_irq(struct irq_domain *domain, unsigned int virq) 1765{ 1766 if (irq_domain_is_msi_device(domain)) 1767 msi_device_domain_free_wired(domain, virq); 1768 else 1769 irq_domain_free_irqs(virq, 1); 1770} 1771 1772/** 1773 * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain 1774 * @domain: Domain below which interrupts must be allocated 1775 * @irq_base: Base IRQ number 1776 * @nr_irqs: Number of IRQs to allocate 1777 * @arg: Allocation data (arch/domain specific) 1778 */ 1779int irq_domain_alloc_irqs_parent(struct irq_domain *domain, 1780 unsigned int irq_base, unsigned int nr_irqs, 1781 void *arg) 1782{ 1783 if (!domain->parent) 1784 return -ENOSYS; 1785 1786 return irq_domain_alloc_irqs_hierarchy(domain->parent, irq_base, 1787 nr_irqs, arg); 1788} 1789EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent); 1790 1791/** 1792 * irq_domain_free_irqs_parent - Free interrupts from parent domain 1793 * @domain: Domain below which interrupts must be freed 1794 * @irq_base: Base IRQ number 1795 * @nr_irqs: Number of IRQs to free 1796 */ 1797void irq_domain_free_irqs_parent(struct irq_domain *domain, 1798 unsigned int irq_base, unsigned int nr_irqs) 1799{ 1800 if (!domain->parent) 1801 return; 1802 1803 irq_domain_free_irqs_hierarchy(domain->parent, irq_base, nr_irqs); 1804} 1805EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent); 1806 1807static void __irq_domain_deactivate_irq(struct irq_data *irq_data) 1808{ 1809 if (irq_data && irq_data->domain) { 1810 struct irq_domain *domain = irq_data->domain; 1811 1812 if (domain->ops->deactivate) 1813 domain->ops->deactivate(domain, irq_data); 1814 if (irq_data->parent_data) 1815 __irq_domain_deactivate_irq(irq_data->parent_data); 1816 } 1817} 1818 1819static int __irq_domain_activate_irq(struct irq_data *irqd, bool reserve) 1820{ 1821 int ret = 0; 1822 1823 if (irqd && irqd->domain) { 1824 struct irq_domain *domain = irqd->domain; 1825 1826 if (irqd->parent_data) 1827 ret = __irq_domain_activate_irq(irqd->parent_data, 1828 reserve); 1829 if (!ret && domain->ops->activate) { 1830 ret = domain->ops->activate(domain, irqd, reserve); 1831 /* Rollback in case of error */ 1832 if (ret && irqd->parent_data) 1833 __irq_domain_deactivate_irq(irqd->parent_data); 1834 } 1835 } 1836 return ret; 1837} 1838 1839/** 1840 * irq_domain_activate_irq - Call domain_ops->activate recursively to activate 1841 * interrupt 1842 * @irq_data: Outermost irq_data associated with interrupt 1843 * @reserve: If set only reserve an interrupt vector instead of assigning one 1844 * 1845 * This is the second step to call domain_ops->activate to program interrupt 1846 * controllers, so the interrupt could actually get delivered. 1847 */ 1848int irq_domain_activate_irq(struct irq_data *irq_data, bool reserve) 1849{ 1850 int ret = 0; 1851 1852 if (!irqd_is_activated(irq_data)) 1853 ret = __irq_domain_activate_irq(irq_data, reserve); 1854 if (!ret) 1855 irqd_set_activated(irq_data); 1856 return ret; 1857} 1858 1859/** 1860 * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to 1861 * deactivate interrupt 1862 * @irq_data: outermost irq_data associated with interrupt 1863 * 1864 * It calls domain_ops->deactivate to program interrupt controllers to disable 1865 * interrupt delivery. 1866 */ 1867void irq_domain_deactivate_irq(struct irq_data *irq_data) 1868{ 1869 if (irqd_is_activated(irq_data)) { 1870 __irq_domain_deactivate_irq(irq_data); 1871 irqd_clr_activated(irq_data); 1872 } 1873} 1874 1875static void irq_domain_check_hierarchy(struct irq_domain *domain) 1876{ 1877 /* Hierarchy irq_domains must implement callback alloc() */ 1878 if (domain->ops->alloc) 1879 domain->flags |= IRQ_DOMAIN_FLAG_HIERARCHY; 1880} 1881#else /* CONFIG_IRQ_DOMAIN_HIERARCHY */ 1882/** 1883 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain 1884 * @domain: domain to match 1885 * @virq: IRQ number to get irq_data 1886 */ 1887struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain, 1888 unsigned int virq) 1889{ 1890 struct irq_data *irq_data = irq_get_irq_data(virq); 1891 1892 return (irq_data && irq_data->domain == domain) ? irq_data : NULL; 1893} 1894EXPORT_SYMBOL_GPL(irq_domain_get_irq_data); 1895 1896/** 1897 * irq_domain_set_info - Set the complete data for a @virq in @domain 1898 * @domain: Interrupt domain to match 1899 * @virq: IRQ number 1900 * @hwirq: The hardware interrupt number 1901 * @chip: The associated interrupt chip 1902 * @chip_data: The associated interrupt chip data 1903 * @handler: The interrupt flow handler 1904 * @handler_data: The interrupt flow handler data 1905 * @handler_name: The interrupt handler name 1906 */ 1907void irq_domain_set_info(struct irq_domain *domain, unsigned int virq, 1908 irq_hw_number_t hwirq, const struct irq_chip *chip, 1909 void *chip_data, irq_flow_handler_t handler, 1910 void *handler_data, const char *handler_name) 1911{ 1912 irq_set_chip_and_handler_name(virq, chip, handler, handler_name); 1913 irq_set_chip_data(virq, chip_data); 1914 irq_set_handler_data(virq, handler_data); 1915} 1916 1917static int irq_domain_alloc_irqs_locked(struct irq_domain *domain, int irq_base, 1918 unsigned int nr_irqs, int node, void *arg, 1919 bool realloc, const struct irq_affinity_desc *affinity) 1920{ 1921 return -EINVAL; 1922} 1923 1924static void irq_domain_check_hierarchy(struct irq_domain *domain) { } 1925static void irq_domain_free_one_irq(struct irq_domain *domain, unsigned int virq) { } 1926 1927#endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */ 1928 1929#ifdef CONFIG_GENERIC_IRQ_DEBUGFS 1930#include "internals.h" 1931 1932static struct dentry *domain_dir; 1933 1934static void 1935irq_domain_debug_show_one(struct seq_file *m, struct irq_domain *d, int ind) 1936{ 1937 seq_printf(m, "%*sname: %s\n", ind, "", d->name); 1938 seq_printf(m, "%*ssize: %u\n", ind + 1, "", d->revmap_size); 1939 seq_printf(m, "%*smapped: %u\n", ind + 1, "", d->mapcount); 1940 seq_printf(m, "%*sflags: 0x%08x\n", ind +1 , "", d->flags); 1941 if (d->ops && d->ops->debug_show) 1942 d->ops->debug_show(m, d, NULL, ind + 1); 1943#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY 1944 if (!d->parent) 1945 return; 1946 seq_printf(m, "%*sparent: %s\n", ind + 1, "", d->parent->name); 1947 irq_domain_debug_show_one(m, d->parent, ind + 4); 1948#endif 1949} 1950 1951static int irq_domain_debug_show(struct seq_file *m, void *p) 1952{ 1953 struct irq_domain *d = m->private; 1954 1955 /* Default domain? Might be NULL */ 1956 if (!d) { 1957 if (!irq_default_domain) 1958 return 0; 1959 d = irq_default_domain; 1960 } 1961 irq_domain_debug_show_one(m, d, 0); 1962 return 0; 1963} 1964DEFINE_SHOW_ATTRIBUTE(irq_domain_debug); 1965 1966static void debugfs_add_domain_dir(struct irq_domain *d) 1967{ 1968 if (!d->name || !domain_dir) 1969 return; 1970 debugfs_create_file(d->name, 0444, domain_dir, d, 1971 &irq_domain_debug_fops); 1972} 1973 1974static void debugfs_remove_domain_dir(struct irq_domain *d) 1975{ 1976 debugfs_lookup_and_remove(d->name, domain_dir); 1977} 1978 1979void __init irq_domain_debugfs_init(struct dentry *root) 1980{ 1981 struct irq_domain *d; 1982 1983 domain_dir = debugfs_create_dir("domains", root); 1984 1985 debugfs_create_file("default", 0444, domain_dir, NULL, 1986 &irq_domain_debug_fops); 1987 mutex_lock(&irq_domain_mutex); 1988 list_for_each_entry(d, &irq_domain_list, link) 1989 debugfs_add_domain_dir(d); 1990 mutex_unlock(&irq_domain_mutex); 1991} 1992#endif 1993