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)
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.
16 * This file contains the code used to make IRQ descriptions in the
17 * device tree to actual irq numbers on an interrupt controller
21 #include <linux/errno.h>
22 #include <linux/module.h>
24 #include <linux/of_irq.h>
25 #include <linux/string.h>
28 * irq_of_parse_and_map - Parse and map an interrupt into linux virq space
29 * @device: Device node of the device whose interrupt is to be mapped
30 * @index: Index of the interrupt to map
32 * This function is a wrapper that chains of_irq_map_one() and
33 * irq_create_of_mapping() to make things easier to callers
35 unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
39 if (of_irq_map_one(dev, index, &oirq))
42 return irq_create_of_mapping(oirq.controller, oirq.specifier,
45 EXPORT_SYMBOL_GPL(irq_of_parse_and_map);
48 * of_irq_find_parent - Given a device node, find its interrupt parent node
49 * @child: pointer to device node
51 * Returns a pointer to the interrupt parent node, or NULL if the interrupt
52 * parent could not be determined.
54 static struct device_node *of_irq_find_parent(struct device_node *child)
56 struct device_node *p;
59 if (!of_node_get(child))
63 parp = of_get_property(child, "interrupt-parent", NULL);
65 p = of_get_parent(child);
67 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
68 p = of_node_get(of_irq_dflt_pic);
70 p = of_find_node_by_phandle(*parp);
74 } while (p && of_get_property(p, "#interrupt-cells", NULL) == NULL);
80 * of_irq_map_raw - Low level interrupt tree parsing
81 * @parent: the device interrupt parent
82 * @intspec: interrupt specifier ("interrupts" property of the device)
83 * @ointsize: size of the passed in interrupt specifier
84 * @addr: address specifier (start of "reg" property of the device)
85 * @out_irq: structure of_irq filled by this function
87 * Returns 0 on success and a negative number on error
89 * This function is a low-level interrupt tree walking function. It
90 * can be used to do a partial walk with synthetized reg and interrupts
91 * properties, for example when resolving PCI interrupts when no device
92 * node exist for the parent.
94 int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize,
95 const u32 *addr, struct of_irq *out_irq)
97 struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL;
98 const __be32 *tmp, *imap, *imask;
99 u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
100 int imaplen, match, i;
102 pr_debug("of_irq_map_raw: par=%s,intspec=[0x%08x 0x%08x...],ointsize=%d\n",
103 parent->full_name, intspec[0], intspec[1], ointsize);
105 ipar = of_node_get(parent);
107 /* First get the #interrupt-cells property of the current cursor
108 * that tells us how to interpret the passed-in intspec. If there
109 * is none, we are nice and just walk up the tree
112 tmp = of_get_property(ipar, "#interrupt-cells", NULL);
114 intsize = be32_to_cpu(*tmp);
118 ipar = of_irq_find_parent(ipar);
122 pr_debug(" -> no parent found !\n");
126 pr_debug("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize);
128 if (ointsize != intsize)
131 /* Look for this #address-cells. We have to implement the old linux
132 * trick of looking for the parent here as some device-trees rely on it
134 old = of_node_get(ipar);
136 tmp = of_get_property(old, "#address-cells", NULL);
137 tnode = of_get_parent(old);
140 } while (old && tmp == NULL);
143 addrsize = (tmp == NULL) ? 2 : be32_to_cpu(*tmp);
145 pr_debug(" -> addrsize=%d\n", addrsize);
147 /* Now start the actual "proper" walk of the interrupt tree */
148 while (ipar != NULL) {
149 /* Now check if cursor is an interrupt-controller and if it is
152 if (of_get_property(ipar, "interrupt-controller", NULL) !=
154 pr_debug(" -> got it !\n");
155 for (i = 0; i < intsize; i++)
156 out_irq->specifier[i] =
157 of_read_number(intspec +i, 1);
158 out_irq->size = intsize;
159 out_irq->controller = ipar;
164 /* Now look for an interrupt-map */
165 imap = of_get_property(ipar, "interrupt-map", &imaplen);
166 /* No interrupt map, check for an interrupt parent */
168 pr_debug(" -> no map, getting parent\n");
169 newpar = of_irq_find_parent(ipar);
172 imaplen /= sizeof(u32);
174 /* Look for a mask */
175 imask = of_get_property(ipar, "interrupt-map-mask", NULL);
177 /* If we were passed no "reg" property and we attempt to parse
178 * an interrupt-map, then #address-cells must be 0.
181 if (addr == NULL && addrsize != 0) {
182 pr_debug(" -> no reg passed in when needed !\n");
186 /* Parse interrupt-map */
188 while (imaplen > (addrsize + intsize + 1) && !match) {
189 /* Compare specifiers */
191 for (i = 0; i < addrsize && match; ++i) {
192 u32 mask = imask ? imask[i] : 0xffffffffu;
193 match = ((addr[i] ^ imap[i]) & mask) == 0;
195 for (; i < (addrsize + intsize) && match; ++i) {
196 u32 mask = imask ? imask[i] : 0xffffffffu;
198 ((intspec[i-addrsize] ^ imap[i]) & mask) == 0;
200 imap += addrsize + intsize;
201 imaplen -= addrsize + intsize;
203 pr_debug(" -> match=%d (imaplen=%d)\n", match, imaplen);
205 /* Get the interrupt parent */
206 if (of_irq_workarounds & OF_IMAP_NO_PHANDLE)
207 newpar = of_node_get(of_irq_dflt_pic);
209 newpar = of_find_node_by_phandle((phandle)*imap);
213 /* Check if not found */
214 if (newpar == NULL) {
215 pr_debug(" -> imap parent not found !\n");
219 /* Get #interrupt-cells and #address-cells of new
222 tmp = of_get_property(newpar, "#interrupt-cells", NULL);
224 pr_debug(" -> parent lacks #interrupt-cells!\n");
227 newintsize = be32_to_cpu(*tmp);
228 tmp = of_get_property(newpar, "#address-cells", NULL);
229 newaddrsize = (tmp == NULL) ? 0 : be32_to_cpu(*tmp);
231 pr_debug(" -> newintsize=%d, newaddrsize=%d\n",
232 newintsize, newaddrsize);
234 /* Check for malformed properties */
235 if (imaplen < (newaddrsize + newintsize))
238 imap += newaddrsize + newintsize;
239 imaplen -= newaddrsize + newintsize;
241 pr_debug(" -> imaplen=%d\n", imaplen);
247 old = of_node_get(newpar);
248 addrsize = newaddrsize;
249 intsize = newintsize;
250 intspec = imap - intsize;
251 addr = intspec - addrsize;
254 /* Iterate again with new parent */
255 pr_debug(" -> new parent: %s\n", newpar ? newpar->full_name : "<>");
267 EXPORT_SYMBOL_GPL(of_irq_map_raw);
270 * of_irq_map_one - Resolve an interrupt for a device
271 * @device: the device whose interrupt is to be resolved
272 * @index: index of the interrupt to resolve
273 * @out_irq: structure of_irq filled by this function
275 * This function resolves an interrupt, walking the tree, for a given
276 * device-tree node. It's the high level pendant to of_irq_map_raw().
278 int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
280 struct device_node *p;
281 const u32 *intspec, *tmp, *addr;
285 pr_debug("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);
287 /* OldWorld mac stuff is "special", handle out of line */
288 if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
289 return of_irq_map_oldworld(device, index, out_irq);
291 /* Get the interrupts property */
292 intspec = of_get_property(device, "interrupts", &intlen);
295 intlen /= sizeof(u32);
297 pr_debug(" intspec=%d intlen=%d\n", *intspec, intlen);
299 /* Get the reg property (if any) */
300 addr = of_get_property(device, "reg", NULL);
302 /* Look for the interrupt parent. */
303 p = of_irq_find_parent(device);
307 /* Get size of interrupt specifier */
308 tmp = of_get_property(p, "#interrupt-cells", NULL);
311 intsize = be32_to_cpu(*tmp);
313 pr_debug(" intsize=%d intlen=%d\n", intsize, intlen);
316 if ((index + 1) * intsize > intlen)
319 /* Get new specifier and map it */
320 res = of_irq_map_raw(p, intspec + index * intsize, intsize,
326 EXPORT_SYMBOL_GPL(of_irq_map_one);
329 * of_irq_to_resource - Decode a node's IRQ and return it as a resource
330 * @dev: pointer to device tree node
331 * @index: zero-based index of the irq
332 * @r: pointer to resource structure to return result into.
334 int of_irq_to_resource(struct device_node *dev, int index, struct resource *r)
336 int irq = irq_of_parse_and_map(dev, index);
338 /* Only dereference the resource if both the
339 * resource and the irq are valid. */
340 if (r && irq != NO_IRQ) {
341 r->start = r->end = irq;
342 r->flags = IORESOURCE_IRQ;
343 r->name = dev->full_name;
348 EXPORT_SYMBOL_GPL(of_irq_to_resource);