1 /* 2 * Derived from arch/i386/kernel/irq.c 3 * Copyright (C) 1992 Linus Torvalds 4 * Adapted from arch/i386 by Gary Thomas 5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 6 * Updated and modified by Cort Dougan <cort@fsmlabs.com> 7 * Copyright (C) 1996-2001 Cort Dougan 8 * Adapted for Power Macintosh by Paul Mackerras 9 * Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au) 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 * 16 * This file contains the code used to make IRQ descriptions in the 17 * device tree to actual irq numbers on an interrupt controller 18 * driver. 19 */ 20 21 #define pr_fmt(fmt) "OF: " fmt 22 23 #include <linux/device.h> 24 #include <linux/errno.h> 25 #include <linux/list.h> 26 #include <linux/module.h> 27 #include <linux/of.h> 28 #include <linux/of_irq.h> 29 #include <linux/of_pci.h> 30 #include <linux/string.h> 31 #include <linux/slab.h> 32 33 /** 34 * irq_of_parse_and_map - Parse and map an interrupt into linux virq space 35 * @dev: Device node of the device whose interrupt is to be mapped 36 * @index: Index of the interrupt to map 37 * 38 * This function is a wrapper that chains of_irq_parse_one() and 39 * irq_create_of_mapping() to make things easier to callers 40 */ 41 unsigned int irq_of_parse_and_map(struct device_node *dev, int index) 42 { 43 struct of_phandle_args oirq; 44 45 if (of_irq_parse_one(dev, index, &oirq)) 46 return 0; 47 48 return irq_create_of_mapping(&oirq); 49 } 50 EXPORT_SYMBOL_GPL(irq_of_parse_and_map); 51 52 /** 53 * of_irq_find_parent - Given a device node, find its interrupt parent node 54 * @child: pointer to device node 55 * 56 * Returns a pointer to the interrupt parent node, or NULL if the interrupt 57 * parent could not be determined. 58 */ 59 struct device_node *of_irq_find_parent(struct device_node *child) 60 { 61 struct device_node *p; 62 const __be32 *parp; 63 64 if (!of_node_get(child)) 65 return NULL; 66 67 do { 68 parp = of_get_property(child, "interrupt-parent", NULL); 69 if (parp == NULL) 70 p = of_get_parent(child); 71 else { 72 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) 73 p = of_node_get(of_irq_dflt_pic); 74 else 75 p = of_find_node_by_phandle(be32_to_cpup(parp)); 76 } 77 of_node_put(child); 78 child = p; 79 } while (p && of_get_property(p, "#interrupt-cells", NULL) == NULL); 80 81 return p; 82 } 83 EXPORT_SYMBOL_GPL(of_irq_find_parent); 84 85 /** 86 * of_irq_parse_raw - Low level interrupt tree parsing 87 * @parent: the device interrupt parent 88 * @addr: address specifier (start of "reg" property of the device) in be32 format 89 * @out_irq: structure of_irq updated by this function 90 * 91 * Returns 0 on success and a negative number on error 92 * 93 * This function is a low-level interrupt tree walking function. It 94 * can be used to do a partial walk with synthetized reg and interrupts 95 * properties, for example when resolving PCI interrupts when no device 96 * node exist for the parent. It takes an interrupt specifier structure as 97 * input, walks the tree looking for any interrupt-map properties, translates 98 * the specifier for each map, and then returns the translated map. 99 */ 100 int of_irq_parse_raw(const __be32 *addr, struct of_phandle_args *out_irq) 101 { 102 struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL; 103 __be32 initial_match_array[MAX_PHANDLE_ARGS]; 104 const __be32 *match_array = initial_match_array; 105 const __be32 *tmp, *imap, *imask, dummy_imask[] = { [0 ... MAX_PHANDLE_ARGS] = cpu_to_be32(~0) }; 106 u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0; 107 int imaplen, match, i, rc = -EINVAL; 108 109 #ifdef DEBUG 110 of_print_phandle_args("of_irq_parse_raw: ", out_irq); 111 #endif 112 113 ipar = of_node_get(out_irq->np); 114 115 /* First get the #interrupt-cells property of the current cursor 116 * that tells us how to interpret the passed-in intspec. If there 117 * is none, we are nice and just walk up the tree 118 */ 119 do { 120 tmp = of_get_property(ipar, "#interrupt-cells", NULL); 121 if (tmp != NULL) { 122 intsize = be32_to_cpu(*tmp); 123 break; 124 } 125 tnode = ipar; 126 ipar = of_irq_find_parent(ipar); 127 of_node_put(tnode); 128 } while (ipar); 129 if (ipar == NULL) { 130 pr_debug(" -> no parent found !\n"); 131 goto fail; 132 } 133 134 pr_debug("of_irq_parse_raw: ipar=%pOF, size=%d\n", ipar, intsize); 135 136 if (out_irq->args_count != intsize) 137 goto fail; 138 139 /* Look for this #address-cells. We have to implement the old linux 140 * trick of looking for the parent here as some device-trees rely on it 141 */ 142 old = of_node_get(ipar); 143 do { 144 tmp = of_get_property(old, "#address-cells", NULL); 145 tnode = of_get_parent(old); 146 of_node_put(old); 147 old = tnode; 148 } while (old && tmp == NULL); 149 of_node_put(old); 150 old = NULL; 151 addrsize = (tmp == NULL) ? 2 : be32_to_cpu(*tmp); 152 153 pr_debug(" -> addrsize=%d\n", addrsize); 154 155 /* Range check so that the temporary buffer doesn't overflow */ 156 if (WARN_ON(addrsize + intsize > MAX_PHANDLE_ARGS)) { 157 rc = -EFAULT; 158 goto fail; 159 } 160 161 /* Precalculate the match array - this simplifies match loop */ 162 for (i = 0; i < addrsize; i++) 163 initial_match_array[i] = addr ? addr[i] : 0; 164 for (i = 0; i < intsize; i++) 165 initial_match_array[addrsize + i] = cpu_to_be32(out_irq->args[i]); 166 167 /* Now start the actual "proper" walk of the interrupt tree */ 168 while (ipar != NULL) { 169 /* Now check if cursor is an interrupt-controller and if it is 170 * then we are done 171 */ 172 if (of_property_read_bool(ipar, "interrupt-controller")) { 173 pr_debug(" -> got it !\n"); 174 return 0; 175 } 176 177 /* 178 * interrupt-map parsing does not work without a reg 179 * property when #address-cells != 0 180 */ 181 if (addrsize && !addr) { 182 pr_debug(" -> no reg passed in when needed !\n"); 183 goto fail; 184 } 185 186 /* Now look for an interrupt-map */ 187 imap = of_get_property(ipar, "interrupt-map", &imaplen); 188 /* No interrupt map, check for an interrupt parent */ 189 if (imap == NULL) { 190 pr_debug(" -> no map, getting parent\n"); 191 newpar = of_irq_find_parent(ipar); 192 goto skiplevel; 193 } 194 imaplen /= sizeof(u32); 195 196 /* Look for a mask */ 197 imask = of_get_property(ipar, "interrupt-map-mask", NULL); 198 if (!imask) 199 imask = dummy_imask; 200 201 /* Parse interrupt-map */ 202 match = 0; 203 while (imaplen > (addrsize + intsize + 1) && !match) { 204 /* Compare specifiers */ 205 match = 1; 206 for (i = 0; i < (addrsize + intsize); i++, imaplen--) 207 match &= !((match_array[i] ^ *imap++) & imask[i]); 208 209 pr_debug(" -> match=%d (imaplen=%d)\n", match, imaplen); 210 211 /* Get the interrupt parent */ 212 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) 213 newpar = of_node_get(of_irq_dflt_pic); 214 else 215 newpar = of_find_node_by_phandle(be32_to_cpup(imap)); 216 imap++; 217 --imaplen; 218 219 /* Check if not found */ 220 if (newpar == NULL) { 221 pr_debug(" -> imap parent not found !\n"); 222 goto fail; 223 } 224 225 if (!of_device_is_available(newpar)) 226 match = 0; 227 228 /* Get #interrupt-cells and #address-cells of new 229 * parent 230 */ 231 tmp = of_get_property(newpar, "#interrupt-cells", NULL); 232 if (tmp == NULL) { 233 pr_debug(" -> parent lacks #interrupt-cells!\n"); 234 goto fail; 235 } 236 newintsize = be32_to_cpu(*tmp); 237 tmp = of_get_property(newpar, "#address-cells", NULL); 238 newaddrsize = (tmp == NULL) ? 0 : be32_to_cpu(*tmp); 239 240 pr_debug(" -> newintsize=%d, newaddrsize=%d\n", 241 newintsize, newaddrsize); 242 243 /* Check for malformed properties */ 244 if (WARN_ON(newaddrsize + newintsize > MAX_PHANDLE_ARGS) 245 || (imaplen < (newaddrsize + newintsize))) { 246 rc = -EFAULT; 247 goto fail; 248 } 249 250 imap += newaddrsize + newintsize; 251 imaplen -= newaddrsize + newintsize; 252 253 pr_debug(" -> imaplen=%d\n", imaplen); 254 } 255 if (!match) 256 goto fail; 257 258 /* 259 * Successfully parsed an interrrupt-map translation; copy new 260 * interrupt specifier into the out_irq structure 261 */ 262 match_array = imap - newaddrsize - newintsize; 263 for (i = 0; i < newintsize; i++) 264 out_irq->args[i] = be32_to_cpup(imap - newintsize + i); 265 out_irq->args_count = intsize = newintsize; 266 addrsize = newaddrsize; 267 268 skiplevel: 269 /* Iterate again with new parent */ 270 out_irq->np = newpar; 271 pr_debug(" -> new parent: %pOF\n", newpar); 272 of_node_put(ipar); 273 ipar = newpar; 274 newpar = NULL; 275 } 276 rc = -ENOENT; /* No interrupt-map found */ 277 278 fail: 279 of_node_put(ipar); 280 of_node_put(newpar); 281 282 return rc; 283 } 284 EXPORT_SYMBOL_GPL(of_irq_parse_raw); 285 286 /** 287 * of_irq_parse_one - Resolve an interrupt for a device 288 * @device: the device whose interrupt is to be resolved 289 * @index: index of the interrupt to resolve 290 * @out_irq: structure of_irq filled by this function 291 * 292 * This function resolves an interrupt for a node by walking the interrupt tree, 293 * finding which interrupt controller node it is attached to, and returning the 294 * interrupt specifier that can be used to retrieve a Linux IRQ number. 295 */ 296 int of_irq_parse_one(struct device_node *device, int index, struct of_phandle_args *out_irq) 297 { 298 struct device_node *p; 299 const __be32 *intspec, *tmp, *addr; 300 u32 intsize, intlen; 301 int i, res; 302 303 pr_debug("of_irq_parse_one: dev=%pOF, index=%d\n", device, index); 304 305 /* OldWorld mac stuff is "special", handle out of line */ 306 if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC) 307 return of_irq_parse_oldworld(device, index, out_irq); 308 309 /* Get the reg property (if any) */ 310 addr = of_get_property(device, "reg", NULL); 311 312 /* Try the new-style interrupts-extended first */ 313 res = of_parse_phandle_with_args(device, "interrupts-extended", 314 "#interrupt-cells", index, out_irq); 315 if (!res) 316 return of_irq_parse_raw(addr, out_irq); 317 318 /* Get the interrupts property */ 319 intspec = of_get_property(device, "interrupts", &intlen); 320 if (intspec == NULL) 321 return -EINVAL; 322 323 intlen /= sizeof(*intspec); 324 325 pr_debug(" intspec=%d intlen=%d\n", be32_to_cpup(intspec), intlen); 326 327 /* Look for the interrupt parent. */ 328 p = of_irq_find_parent(device); 329 if (p == NULL) 330 return -EINVAL; 331 332 /* Get size of interrupt specifier */ 333 tmp = of_get_property(p, "#interrupt-cells", NULL); 334 if (tmp == NULL) { 335 res = -EINVAL; 336 goto out; 337 } 338 intsize = be32_to_cpu(*tmp); 339 340 pr_debug(" intsize=%d intlen=%d\n", intsize, intlen); 341 342 /* Check index */ 343 if ((index + 1) * intsize > intlen) { 344 res = -EINVAL; 345 goto out; 346 } 347 348 /* Copy intspec into irq structure */ 349 intspec += index * intsize; 350 out_irq->np = p; 351 out_irq->args_count = intsize; 352 for (i = 0; i < intsize; i++) 353 out_irq->args[i] = be32_to_cpup(intspec++); 354 355 /* Check if there are any interrupt-map translations to process */ 356 res = of_irq_parse_raw(addr, out_irq); 357 out: 358 of_node_put(p); 359 return res; 360 } 361 EXPORT_SYMBOL_GPL(of_irq_parse_one); 362 363 /** 364 * of_irq_to_resource - Decode a node's IRQ and return it as a resource 365 * @dev: pointer to device tree node 366 * @index: zero-based index of the irq 367 * @r: pointer to resource structure to return result into. 368 */ 369 int of_irq_to_resource(struct device_node *dev, int index, struct resource *r) 370 { 371 int irq = of_irq_get(dev, index); 372 373 if (irq < 0) 374 return irq; 375 376 /* Only dereference the resource if both the 377 * resource and the irq are valid. */ 378 if (r && irq) { 379 const char *name = NULL; 380 381 memset(r, 0, sizeof(*r)); 382 /* 383 * Get optional "interrupt-names" property to add a name 384 * to the resource. 385 */ 386 of_property_read_string_index(dev, "interrupt-names", index, 387 &name); 388 389 r->start = r->end = irq; 390 r->flags = IORESOURCE_IRQ | irqd_get_trigger_type(irq_get_irq_data(irq)); 391 r->name = name ? name : of_node_full_name(dev); 392 } 393 394 return irq; 395 } 396 EXPORT_SYMBOL_GPL(of_irq_to_resource); 397 398 /** 399 * of_irq_get - Decode a node's IRQ and return it as a Linux IRQ number 400 * @dev: pointer to device tree node 401 * @index: zero-based index of the IRQ 402 * 403 * Returns Linux IRQ number on success, or 0 on the IRQ mapping failure, or 404 * -EPROBE_DEFER if the IRQ domain is not yet created, or error code in case 405 * of any other failure. 406 */ 407 int of_irq_get(struct device_node *dev, int index) 408 { 409 int rc; 410 struct of_phandle_args oirq; 411 struct irq_domain *domain; 412 413 rc = of_irq_parse_one(dev, index, &oirq); 414 if (rc) 415 return rc; 416 417 domain = irq_find_host(oirq.np); 418 if (!domain) 419 return -EPROBE_DEFER; 420 421 return irq_create_of_mapping(&oirq); 422 } 423 EXPORT_SYMBOL_GPL(of_irq_get); 424 425 /** 426 * of_irq_get_byname - Decode a node's IRQ and return it as a Linux IRQ number 427 * @dev: pointer to device tree node 428 * @name: IRQ name 429 * 430 * Returns Linux IRQ number on success, or 0 on the IRQ mapping failure, or 431 * -EPROBE_DEFER if the IRQ domain is not yet created, or error code in case 432 * of any other failure. 433 */ 434 int of_irq_get_byname(struct device_node *dev, const char *name) 435 { 436 int index; 437 438 if (unlikely(!name)) 439 return -EINVAL; 440 441 index = of_property_match_string(dev, "interrupt-names", name); 442 if (index < 0) 443 return index; 444 445 return of_irq_get(dev, index); 446 } 447 EXPORT_SYMBOL_GPL(of_irq_get_byname); 448 449 /** 450 * of_irq_count - Count the number of IRQs a node uses 451 * @dev: pointer to device tree node 452 */ 453 int of_irq_count(struct device_node *dev) 454 { 455 struct of_phandle_args irq; 456 int nr = 0; 457 458 while (of_irq_parse_one(dev, nr, &irq) == 0) 459 nr++; 460 461 return nr; 462 } 463 464 /** 465 * of_irq_to_resource_table - Fill in resource table with node's IRQ info 466 * @dev: pointer to device tree node 467 * @res: array of resources to fill in 468 * @nr_irqs: the number of IRQs (and upper bound for num of @res elements) 469 * 470 * Returns the size of the filled in table (up to @nr_irqs). 471 */ 472 int of_irq_to_resource_table(struct device_node *dev, struct resource *res, 473 int nr_irqs) 474 { 475 int i; 476 477 for (i = 0; i < nr_irqs; i++, res++) 478 if (!of_irq_to_resource(dev, i, res)) 479 break; 480 481 return i; 482 } 483 EXPORT_SYMBOL_GPL(of_irq_to_resource_table); 484 485 struct of_intc_desc { 486 struct list_head list; 487 of_irq_init_cb_t irq_init_cb; 488 struct device_node *dev; 489 struct device_node *interrupt_parent; 490 }; 491 492 /** 493 * of_irq_init - Scan and init matching interrupt controllers in DT 494 * @matches: 0 terminated array of nodes to match and init function to call 495 * 496 * This function scans the device tree for matching interrupt controller nodes, 497 * and calls their initialization functions in order with parents first. 498 */ 499 void __init of_irq_init(const struct of_device_id *matches) 500 { 501 const struct of_device_id *match; 502 struct device_node *np, *parent = NULL; 503 struct of_intc_desc *desc, *temp_desc; 504 struct list_head intc_desc_list, intc_parent_list; 505 506 INIT_LIST_HEAD(&intc_desc_list); 507 INIT_LIST_HEAD(&intc_parent_list); 508 509 for_each_matching_node_and_match(np, matches, &match) { 510 if (!of_property_read_bool(np, "interrupt-controller") || 511 !of_device_is_available(np)) 512 continue; 513 514 if (WARN(!match->data, "of_irq_init: no init function for %s\n", 515 match->compatible)) 516 continue; 517 518 /* 519 * Here, we allocate and populate an of_intc_desc with the node 520 * pointer, interrupt-parent device_node etc. 521 */ 522 desc = kzalloc(sizeof(*desc), GFP_KERNEL); 523 if (WARN_ON(!desc)) { 524 of_node_put(np); 525 goto err; 526 } 527 528 desc->irq_init_cb = match->data; 529 desc->dev = of_node_get(np); 530 desc->interrupt_parent = of_irq_find_parent(np); 531 if (desc->interrupt_parent == np) 532 desc->interrupt_parent = NULL; 533 list_add_tail(&desc->list, &intc_desc_list); 534 } 535 536 /* 537 * The root irq controller is the one without an interrupt-parent. 538 * That one goes first, followed by the controllers that reference it, 539 * followed by the ones that reference the 2nd level controllers, etc. 540 */ 541 while (!list_empty(&intc_desc_list)) { 542 /* 543 * Process all controllers with the current 'parent'. 544 * First pass will be looking for NULL as the parent. 545 * The assumption is that NULL parent means a root controller. 546 */ 547 list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) { 548 int ret; 549 550 if (desc->interrupt_parent != parent) 551 continue; 552 553 list_del(&desc->list); 554 555 of_node_set_flag(desc->dev, OF_POPULATED); 556 557 pr_debug("of_irq_init: init %pOF (%p), parent %p\n", 558 desc->dev, 559 desc->dev, desc->interrupt_parent); 560 ret = desc->irq_init_cb(desc->dev, 561 desc->interrupt_parent); 562 if (ret) { 563 of_node_clear_flag(desc->dev, OF_POPULATED); 564 kfree(desc); 565 continue; 566 } 567 568 /* 569 * This one is now set up; add it to the parent list so 570 * its children can get processed in a subsequent pass. 571 */ 572 list_add_tail(&desc->list, &intc_parent_list); 573 } 574 575 /* Get the next pending parent that might have children */ 576 desc = list_first_entry_or_null(&intc_parent_list, 577 typeof(*desc), list); 578 if (!desc) { 579 pr_err("of_irq_init: children remain, but no parents\n"); 580 break; 581 } 582 list_del(&desc->list); 583 parent = desc->dev; 584 kfree(desc); 585 } 586 587 list_for_each_entry_safe(desc, temp_desc, &intc_parent_list, list) { 588 list_del(&desc->list); 589 kfree(desc); 590 } 591 err: 592 list_for_each_entry_safe(desc, temp_desc, &intc_desc_list, list) { 593 list_del(&desc->list); 594 of_node_put(desc->dev); 595 kfree(desc); 596 } 597 } 598 599 static u32 __of_msi_map_rid(struct device *dev, struct device_node **np, 600 u32 rid_in) 601 { 602 struct device *parent_dev; 603 u32 rid_out = rid_in; 604 605 /* 606 * Walk up the device parent links looking for one with a 607 * "msi-map" property. 608 */ 609 for (parent_dev = dev; parent_dev; parent_dev = parent_dev->parent) 610 if (!of_pci_map_rid(parent_dev->of_node, rid_in, "msi-map", 611 "msi-map-mask", np, &rid_out)) 612 break; 613 return rid_out; 614 } 615 616 /** 617 * of_msi_map_rid - Map a MSI requester ID for a device. 618 * @dev: device for which the mapping is to be done. 619 * @msi_np: device node of the expected msi controller. 620 * @rid_in: unmapped MSI requester ID for the device. 621 * 622 * Walk up the device hierarchy looking for devices with a "msi-map" 623 * property. If found, apply the mapping to @rid_in. 624 * 625 * Returns the mapped MSI requester ID. 626 */ 627 u32 of_msi_map_rid(struct device *dev, struct device_node *msi_np, u32 rid_in) 628 { 629 return __of_msi_map_rid(dev, &msi_np, rid_in); 630 } 631 632 /** 633 * of_msi_map_get_device_domain - Use msi-map to find the relevant MSI domain 634 * @dev: device for which the mapping is to be done. 635 * @rid: Requester ID for the device. 636 * 637 * Walk up the device hierarchy looking for devices with a "msi-map" 638 * property. 639 * 640 * Returns: the MSI domain for this device (or NULL on failure) 641 */ 642 struct irq_domain *of_msi_map_get_device_domain(struct device *dev, u32 rid) 643 { 644 struct device_node *np = NULL; 645 646 __of_msi_map_rid(dev, &np, rid); 647 return irq_find_matching_host(np, DOMAIN_BUS_PCI_MSI); 648 } 649 650 /** 651 * of_msi_get_domain - Use msi-parent to find the relevant MSI domain 652 * @dev: device for which the domain is requested 653 * @np: device node for @dev 654 * @token: bus type for this domain 655 * 656 * Parse the msi-parent property (both the simple and the complex 657 * versions), and returns the corresponding MSI domain. 658 * 659 * Returns: the MSI domain for this device (or NULL on failure). 660 */ 661 struct irq_domain *of_msi_get_domain(struct device *dev, 662 struct device_node *np, 663 enum irq_domain_bus_token token) 664 { 665 struct device_node *msi_np; 666 struct irq_domain *d; 667 668 /* Check for a single msi-parent property */ 669 msi_np = of_parse_phandle(np, "msi-parent", 0); 670 if (msi_np && !of_property_read_bool(msi_np, "#msi-cells")) { 671 d = irq_find_matching_host(msi_np, token); 672 if (!d) 673 of_node_put(msi_np); 674 return d; 675 } 676 677 if (token == DOMAIN_BUS_PLATFORM_MSI) { 678 /* Check for the complex msi-parent version */ 679 struct of_phandle_args args; 680 int index = 0; 681 682 while (!of_parse_phandle_with_args(np, "msi-parent", 683 "#msi-cells", 684 index, &args)) { 685 d = irq_find_matching_host(args.np, token); 686 if (d) 687 return d; 688 689 of_node_put(args.np); 690 index++; 691 } 692 } 693 694 return NULL; 695 } 696 697 /** 698 * of_msi_configure - Set the msi_domain field of a device 699 * @dev: device structure to associate with an MSI irq domain 700 * @np: device node for that device 701 */ 702 void of_msi_configure(struct device *dev, struct device_node *np) 703 { 704 dev_set_msi_domain(dev, 705 of_msi_get_domain(dev, np, DOMAIN_BUS_PLATFORM_MSI)); 706 } 707 EXPORT_SYMBOL_GPL(of_msi_configure); 708