1 #define pr_fmt(fmt) "irq: " fmt
3 #include <linux/debugfs.h>
4 #include <linux/hardirq.h>
5 #include <linux/interrupt.h>
7 #include <linux/irqdesc.h>
8 #include <linux/irqdomain.h>
9 #include <linux/module.h>
10 #include <linux/mutex.h>
12 #include <linux/of_address.h>
13 #include <linux/topology.h>
14 #include <linux/seq_file.h>
15 #include <linux/slab.h>
16 #include <linux/smp.h>
19 #define IRQ_DOMAIN_MAP_LEGACY 0 /* driver allocated fixed range of irqs.
20 * ie. legacy 8259, gets irqs 1..15 */
21 #define IRQ_DOMAIN_MAP_NOMAP 1 /* no fast reverse mapping */
22 #define IRQ_DOMAIN_MAP_LINEAR 2 /* linear map of interrupts */
23 #define IRQ_DOMAIN_MAP_TREE 3 /* radix tree */
25 static LIST_HEAD(irq_domain_list
);
26 static DEFINE_MUTEX(irq_domain_mutex
);
28 static DEFINE_MUTEX(revmap_trees_mutex
);
29 static struct irq_domain
*irq_default_domain
;
32 * irq_domain_alloc() - Allocate a new irq_domain data structure
33 * @of_node: optional device-tree node of the interrupt controller
34 * @revmap_type: type of reverse mapping to use
35 * @ops: map/unmap domain callbacks
36 * @host_data: Controller private data pointer
38 * Allocates and initialize and irq_domain structure. Caller is expected to
39 * register allocated irq_domain with irq_domain_register(). Returns pointer
40 * to IRQ domain, or NULL on failure.
42 static struct irq_domain
*irq_domain_alloc(struct device_node
*of_node
,
43 unsigned int revmap_type
,
44 const struct irq_domain_ops
*ops
,
47 struct irq_domain
*domain
;
49 domain
= kzalloc_node(sizeof(*domain
), GFP_KERNEL
,
50 of_node_to_nid(of_node
));
55 domain
->revmap_type
= revmap_type
;
57 domain
->host_data
= host_data
;
58 domain
->of_node
= of_node_get(of_node
);
63 static void irq_domain_free(struct irq_domain
*domain
)
65 of_node_put(domain
->of_node
);
69 static void irq_domain_add(struct irq_domain
*domain
)
71 mutex_lock(&irq_domain_mutex
);
72 list_add(&domain
->link
, &irq_domain_list
);
73 mutex_unlock(&irq_domain_mutex
);
74 pr_debug("Allocated domain of type %d @0x%p\n",
75 domain
->revmap_type
, domain
);
79 * irq_domain_remove() - Remove an irq domain.
80 * @domain: domain to remove
82 * This routine is used to remove an irq domain. The caller must ensure
83 * that all mappings within the domain have been disposed of prior to
84 * use, depending on the revmap type.
86 void irq_domain_remove(struct irq_domain
*domain
)
88 mutex_lock(&irq_domain_mutex
);
90 switch (domain
->revmap_type
) {
91 case IRQ_DOMAIN_MAP_LEGACY
:
93 * Legacy domains don't manage their own irq_desc
94 * allocations, we expect the caller to handle irq_desc
95 * freeing on their own.
98 case IRQ_DOMAIN_MAP_TREE
:
100 * radix_tree_delete() takes care of destroying the root
101 * node when all entries are removed. Shout if there are
104 WARN_ON(domain
->revmap_data
.tree
.height
);
106 case IRQ_DOMAIN_MAP_LINEAR
:
107 kfree(domain
->revmap_data
.linear
.revmap
);
108 domain
->revmap_data
.linear
.size
= 0;
110 case IRQ_DOMAIN_MAP_NOMAP
:
114 list_del(&domain
->link
);
117 * If the going away domain is the default one, reset it.
119 if (unlikely(irq_default_domain
== domain
))
120 irq_set_default_host(NULL
);
122 mutex_unlock(&irq_domain_mutex
);
124 pr_debug("Removed domain of type %d @0x%p\n",
125 domain
->revmap_type
, domain
);
127 irq_domain_free(domain
);
129 EXPORT_SYMBOL_GPL(irq_domain_remove
);
131 static unsigned int irq_domain_legacy_revmap(struct irq_domain
*domain
,
132 irq_hw_number_t hwirq
)
134 irq_hw_number_t first_hwirq
= domain
->revmap_data
.legacy
.first_hwirq
;
135 int size
= domain
->revmap_data
.legacy
.size
;
137 if (WARN_ON(hwirq
< first_hwirq
|| hwirq
>= first_hwirq
+ size
))
139 return hwirq
- first_hwirq
+ domain
->revmap_data
.legacy
.first_irq
;
143 * irq_domain_add_simple() - Allocate and register a simple irq_domain.
144 * @of_node: pointer to interrupt controller's device tree node.
145 * @size: total number of irqs in mapping
146 * @first_irq: first number of irq block assigned to the domain
147 * @ops: map/unmap domain callbacks
148 * @host_data: Controller private data pointer
150 * Allocates a legacy irq_domain if irq_base is positive or a linear
153 * This is intended to implement the expected behaviour for most
154 * interrupt controllers which is that a linear mapping should
155 * normally be used unless the system requires a legacy mapping in
156 * order to support supplying interrupt numbers during non-DT
157 * registration of devices.
159 struct irq_domain
*irq_domain_add_simple(struct device_node
*of_node
,
161 unsigned int first_irq
,
162 const struct irq_domain_ops
*ops
,
166 return irq_domain_add_legacy(of_node
, size
, first_irq
, 0,
169 return irq_domain_add_linear(of_node
, size
, ops
, host_data
);
173 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
174 * @of_node: pointer to interrupt controller's device tree node.
175 * @size: total number of irqs in legacy mapping
176 * @first_irq: first number of irq block assigned to the domain
177 * @first_hwirq: first hwirq number to use for the translation. Should normally
178 * be '0', but a positive integer can be used if the effective
179 * hwirqs numbering does not begin at zero.
180 * @ops: map/unmap domain callbacks
181 * @host_data: Controller private data pointer
183 * Note: the map() callback will be called before this function returns
184 * for all legacy interrupts except 0 (which is always the invalid irq for
185 * a legacy controller).
187 struct irq_domain
*irq_domain_add_legacy(struct device_node
*of_node
,
189 unsigned int first_irq
,
190 irq_hw_number_t first_hwirq
,
191 const struct irq_domain_ops
*ops
,
194 struct irq_domain
*domain
;
197 domain
= irq_domain_alloc(of_node
, IRQ_DOMAIN_MAP_LEGACY
, ops
, host_data
);
201 domain
->revmap_data
.legacy
.first_irq
= first_irq
;
202 domain
->revmap_data
.legacy
.first_hwirq
= first_hwirq
;
203 domain
->revmap_data
.legacy
.size
= size
;
205 mutex_lock(&irq_domain_mutex
);
206 /* Verify that all the irqs are available */
207 for (i
= 0; i
< size
; i
++) {
208 int irq
= first_irq
+ i
;
209 struct irq_data
*irq_data
= irq_get_irq_data(irq
);
211 if (WARN_ON(!irq_data
|| irq_data
->domain
)) {
212 mutex_unlock(&irq_domain_mutex
);
213 irq_domain_free(domain
);
218 /* Claim all of the irqs before registering a legacy domain */
219 for (i
= 0; i
< size
; i
++) {
220 struct irq_data
*irq_data
= irq_get_irq_data(first_irq
+ i
);
221 irq_data
->hwirq
= first_hwirq
+ i
;
222 irq_data
->domain
= domain
;
224 mutex_unlock(&irq_domain_mutex
);
226 for (i
= 0; i
< size
; i
++) {
227 int irq
= first_irq
+ i
;
228 int hwirq
= first_hwirq
+ i
;
230 /* IRQ0 gets ignored */
234 /* Legacy flags are left to default at this point,
235 * one can then use irq_create_mapping() to
236 * explicitly change them
239 ops
->map(domain
, irq
, hwirq
);
241 /* Clear norequest flags */
242 irq_clear_status_flags(irq
, IRQ_NOREQUEST
);
245 irq_domain_add(domain
);
248 EXPORT_SYMBOL_GPL(irq_domain_add_legacy
);
251 * irq_domain_add_linear() - Allocate and register a linear revmap irq_domain.
252 * @of_node: pointer to interrupt controller's device tree node.
253 * @size: Number of interrupts in the domain.
254 * @ops: map/unmap domain callbacks
255 * @host_data: Controller private data pointer
257 struct irq_domain
*irq_domain_add_linear(struct device_node
*of_node
,
259 const struct irq_domain_ops
*ops
,
262 struct irq_domain
*domain
;
263 unsigned int *revmap
;
265 revmap
= kzalloc_node(sizeof(*revmap
) * size
, GFP_KERNEL
,
266 of_node_to_nid(of_node
));
267 if (WARN_ON(!revmap
))
270 domain
= irq_domain_alloc(of_node
, IRQ_DOMAIN_MAP_LINEAR
, ops
, host_data
);
275 domain
->revmap_data
.linear
.size
= size
;
276 domain
->revmap_data
.linear
.revmap
= revmap
;
277 irq_domain_add(domain
);
280 EXPORT_SYMBOL_GPL(irq_domain_add_linear
);
282 struct irq_domain
*irq_domain_add_nomap(struct device_node
*of_node
,
283 unsigned int max_irq
,
284 const struct irq_domain_ops
*ops
,
287 struct irq_domain
*domain
= irq_domain_alloc(of_node
,
288 IRQ_DOMAIN_MAP_NOMAP
, ops
, host_data
);
290 domain
->revmap_data
.nomap
.max_irq
= max_irq
? max_irq
: ~0;
291 irq_domain_add(domain
);
295 EXPORT_SYMBOL_GPL(irq_domain_add_nomap
);
298 * irq_domain_add_tree()
299 * @of_node: pointer to interrupt controller's device tree node.
300 * @ops: map/unmap domain callbacks
302 * Note: The radix tree will be allocated later during boot automatically
303 * (the reverse mapping will use the slow path until that happens).
305 struct irq_domain
*irq_domain_add_tree(struct device_node
*of_node
,
306 const struct irq_domain_ops
*ops
,
309 struct irq_domain
*domain
= irq_domain_alloc(of_node
,
310 IRQ_DOMAIN_MAP_TREE
, ops
, host_data
);
312 INIT_RADIX_TREE(&domain
->revmap_data
.tree
, GFP_KERNEL
);
313 irq_domain_add(domain
);
317 EXPORT_SYMBOL_GPL(irq_domain_add_tree
);
320 * irq_find_host() - Locates a domain for a given device node
321 * @node: device-tree node of the interrupt controller
323 struct irq_domain
*irq_find_host(struct device_node
*node
)
325 struct irq_domain
*h
, *found
= NULL
;
328 /* We might want to match the legacy controller last since
329 * it might potentially be set to match all interrupts in
330 * the absence of a device node. This isn't a problem so far
333 mutex_lock(&irq_domain_mutex
);
334 list_for_each_entry(h
, &irq_domain_list
, link
) {
336 rc
= h
->ops
->match(h
, node
);
338 rc
= (h
->of_node
!= NULL
) && (h
->of_node
== node
);
345 mutex_unlock(&irq_domain_mutex
);
348 EXPORT_SYMBOL_GPL(irq_find_host
);
351 * irq_set_default_host() - Set a "default" irq domain
352 * @domain: default domain pointer
354 * For convenience, it's possible to set a "default" domain that will be used
355 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
356 * platforms that want to manipulate a few hard coded interrupt numbers that
357 * aren't properly represented in the device-tree.
359 void irq_set_default_host(struct irq_domain
*domain
)
361 pr_debug("Default domain set to @0x%p\n", domain
);
363 irq_default_domain
= domain
;
365 EXPORT_SYMBOL_GPL(irq_set_default_host
);
367 static int irq_setup_virq(struct irq_domain
*domain
, unsigned int virq
,
368 irq_hw_number_t hwirq
)
370 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
372 irq_data
->hwirq
= hwirq
;
373 irq_data
->domain
= domain
;
374 if (domain
->ops
->map
&& domain
->ops
->map(domain
, virq
, hwirq
)) {
375 pr_err("irq-%i==>hwirq-0x%lx mapping failed\n", virq
, hwirq
);
376 irq_data
->domain
= NULL
;
381 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
387 * irq_create_direct_mapping() - Allocate an irq for direct mapping
388 * @domain: domain to allocate the irq for or NULL for default domain
390 * This routine is used for irq controllers which can choose the hardware
391 * interrupt numbers they generate. In such a case it's simplest to use
392 * the linux irq as the hardware interrupt number.
394 unsigned int irq_create_direct_mapping(struct irq_domain
*domain
)
399 domain
= irq_default_domain
;
401 BUG_ON(domain
== NULL
);
402 WARN_ON(domain
->revmap_type
!= IRQ_DOMAIN_MAP_NOMAP
);
404 virq
= irq_alloc_desc_from(1, of_node_to_nid(domain
->of_node
));
406 pr_debug("create_direct virq allocation failed\n");
409 if (virq
>= domain
->revmap_data
.nomap
.max_irq
) {
410 pr_err("ERROR: no free irqs available below %i maximum\n",
411 domain
->revmap_data
.nomap
.max_irq
);
415 pr_debug("create_direct obtained virq %d\n", virq
);
417 if (irq_setup_virq(domain
, virq
, virq
)) {
424 EXPORT_SYMBOL_GPL(irq_create_direct_mapping
);
427 * irq_create_mapping() - Map a hardware interrupt into linux irq space
428 * @domain: domain owning this hardware interrupt or NULL for default domain
429 * @hwirq: hardware irq number in that domain space
431 * Only one mapping per hardware interrupt is permitted. Returns a linux
433 * If the sense/trigger is to be specified, set_irq_type() should be called
434 * on the number returned from that call.
436 unsigned int irq_create_mapping(struct irq_domain
*domain
,
437 irq_hw_number_t hwirq
)
442 pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain
, hwirq
);
444 /* Look for default domain if nececssary */
446 domain
= irq_default_domain
;
447 if (domain
== NULL
) {
448 pr_warning("irq_create_mapping called for"
449 " NULL domain, hwirq=%lx\n", hwirq
);
453 pr_debug("-> using domain @%p\n", domain
);
455 /* Check if mapping already exists */
456 virq
= irq_find_mapping(domain
, hwirq
);
458 pr_debug("-> existing mapping on virq %d\n", virq
);
462 /* Get a virtual interrupt number */
463 if (domain
->revmap_type
== IRQ_DOMAIN_MAP_LEGACY
)
464 return irq_domain_legacy_revmap(domain
, hwirq
);
466 /* Allocate a virtual interrupt number */
467 hint
= hwirq
% nr_irqs
;
470 virq
= irq_alloc_desc_from(hint
, of_node_to_nid(domain
->of_node
));
472 virq
= irq_alloc_desc_from(1, of_node_to_nid(domain
->of_node
));
474 pr_debug("-> virq allocation failed\n");
478 if (irq_setup_virq(domain
, virq
, hwirq
)) {
483 pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
484 hwirq
, of_node_full_name(domain
->of_node
), virq
);
488 EXPORT_SYMBOL_GPL(irq_create_mapping
);
490 unsigned int irq_create_of_mapping(struct device_node
*controller
,
491 const u32
*intspec
, unsigned int intsize
)
493 struct irq_domain
*domain
;
494 irq_hw_number_t hwirq
;
495 unsigned int type
= IRQ_TYPE_NONE
;
498 domain
= controller
? irq_find_host(controller
) : irq_default_domain
;
502 * Workaround to avoid breaking interrupt controller drivers
503 * that don't yet register an irq_domain. This is temporary
504 * code. ~~~gcl, Feb 24, 2012
506 * Scheduled for removal in Linux v3.6. That should be enough
512 pr_warning("no irq domain found for %s !\n",
513 of_node_full_name(controller
));
517 /* If domain has no translation, then we assume interrupt line */
518 if (domain
->ops
->xlate
== NULL
)
521 if (domain
->ops
->xlate(domain
, controller
, intspec
, intsize
,
527 virq
= irq_create_mapping(domain
, hwirq
);
531 /* Set type if specified and different than the current one */
532 if (type
!= IRQ_TYPE_NONE
&&
533 type
!= (irqd_get_trigger_type(irq_get_irq_data(virq
))))
534 irq_set_irq_type(virq
, type
);
537 EXPORT_SYMBOL_GPL(irq_create_of_mapping
);
540 * irq_dispose_mapping() - Unmap an interrupt
541 * @virq: linux irq number of the interrupt to unmap
543 void irq_dispose_mapping(unsigned int virq
)
545 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
546 struct irq_domain
*domain
;
547 irq_hw_number_t hwirq
;
549 if (!virq
|| !irq_data
)
552 domain
= irq_data
->domain
;
553 if (WARN_ON(domain
== NULL
))
556 /* Never unmap legacy interrupts */
557 if (domain
->revmap_type
== IRQ_DOMAIN_MAP_LEGACY
)
560 irq_set_status_flags(virq
, IRQ_NOREQUEST
);
562 /* remove chip and handler */
563 irq_set_chip_and_handler(virq
, NULL
, NULL
);
565 /* Make sure it's completed */
566 synchronize_irq(virq
);
568 /* Tell the PIC about it */
569 if (domain
->ops
->unmap
)
570 domain
->ops
->unmap(domain
, virq
);
573 /* Clear reverse map */
574 hwirq
= irq_data
->hwirq
;
575 switch(domain
->revmap_type
) {
576 case IRQ_DOMAIN_MAP_LINEAR
:
577 if (hwirq
< domain
->revmap_data
.linear
.size
)
578 domain
->revmap_data
.linear
.revmap
[hwirq
] = 0;
580 case IRQ_DOMAIN_MAP_TREE
:
581 mutex_lock(&revmap_trees_mutex
);
582 radix_tree_delete(&domain
->revmap_data
.tree
, hwirq
);
583 mutex_unlock(&revmap_trees_mutex
);
589 EXPORT_SYMBOL_GPL(irq_dispose_mapping
);
592 * irq_find_mapping() - Find a linux irq from an hw irq number.
593 * @domain: domain owning this hardware interrupt
594 * @hwirq: hardware irq number in that domain space
596 * This is a slow path, for use by generic code. It's expected that an
597 * irq controller implementation directly calls the appropriate low level
600 unsigned int irq_find_mapping(struct irq_domain
*domain
,
601 irq_hw_number_t hwirq
)
604 unsigned int hint
= hwirq
% nr_irqs
;
606 /* Look for default domain if nececssary */
608 domain
= irq_default_domain
;
612 /* legacy -> bail early */
613 if (domain
->revmap_type
== IRQ_DOMAIN_MAP_LEGACY
)
614 return irq_domain_legacy_revmap(domain
, hwirq
);
616 /* Slow path does a linear search of the map */
621 struct irq_data
*data
= irq_get_irq_data(i
);
622 if (data
&& (data
->domain
== domain
) && (data
->hwirq
== hwirq
))
630 EXPORT_SYMBOL_GPL(irq_find_mapping
);
633 * irq_radix_revmap_lookup() - Find a linux irq from a hw irq number.
634 * @domain: domain owning this hardware interrupt
635 * @hwirq: hardware irq number in that domain space
637 * This is a fast path, for use by irq controller code that uses radix tree
640 unsigned int irq_radix_revmap_lookup(struct irq_domain
*domain
,
641 irq_hw_number_t hwirq
)
643 struct irq_data
*irq_data
;
645 if (WARN_ON_ONCE(domain
->revmap_type
!= IRQ_DOMAIN_MAP_TREE
))
646 return irq_find_mapping(domain
, hwirq
);
649 * Freeing an irq can delete nodes along the path to
650 * do the lookup via call_rcu.
653 irq_data
= radix_tree_lookup(&domain
->revmap_data
.tree
, hwirq
);
657 * If found in radix tree, then fine.
658 * Else fallback to linear lookup - this should not happen in practice
659 * as it means that we failed to insert the node in the radix tree.
661 return irq_data
? irq_data
->irq
: irq_find_mapping(domain
, hwirq
);
663 EXPORT_SYMBOL_GPL(irq_radix_revmap_lookup
);
666 * irq_radix_revmap_insert() - Insert a hw irq to linux irq number mapping.
667 * @domain: domain owning this hardware interrupt
668 * @virq: linux irq number
669 * @hwirq: hardware irq number in that domain space
671 * This is for use by irq controllers that use a radix tree reverse
672 * mapping for fast lookup.
674 void irq_radix_revmap_insert(struct irq_domain
*domain
, unsigned int virq
,
675 irq_hw_number_t hwirq
)
677 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
679 if (WARN_ON(domain
->revmap_type
!= IRQ_DOMAIN_MAP_TREE
))
683 mutex_lock(&revmap_trees_mutex
);
684 radix_tree_insert(&domain
->revmap_data
.tree
, hwirq
, irq_data
);
685 mutex_unlock(&revmap_trees_mutex
);
688 EXPORT_SYMBOL_GPL(irq_radix_revmap_insert
);
691 * irq_linear_revmap() - Find a linux irq from a hw irq number.
692 * @domain: domain owning this hardware interrupt
693 * @hwirq: hardware irq number in that domain space
695 * This is a fast path, for use by irq controller code that uses linear
696 * revmaps. It does fallback to the slow path if the revmap doesn't exist
697 * yet and will create the revmap entry with appropriate locking
699 unsigned int irq_linear_revmap(struct irq_domain
*domain
,
700 irq_hw_number_t hwirq
)
702 unsigned int *revmap
;
704 if (WARN_ON_ONCE(domain
->revmap_type
!= IRQ_DOMAIN_MAP_LINEAR
))
705 return irq_find_mapping(domain
, hwirq
);
707 /* Check revmap bounds */
708 if (unlikely(hwirq
>= domain
->revmap_data
.linear
.size
))
709 return irq_find_mapping(domain
, hwirq
);
711 /* Check if revmap was allocated */
712 revmap
= domain
->revmap_data
.linear
.revmap
;
713 if (unlikely(revmap
== NULL
))
714 return irq_find_mapping(domain
, hwirq
);
716 /* Fill up revmap with slow path if no mapping found */
717 if (unlikely(!revmap
[hwirq
]))
718 revmap
[hwirq
] = irq_find_mapping(domain
, hwirq
);
720 return revmap
[hwirq
];
722 EXPORT_SYMBOL_GPL(irq_linear_revmap
);
724 #ifdef CONFIG_IRQ_DOMAIN_DEBUG
725 static int virq_debug_show(struct seq_file
*m
, void *private)
728 struct irq_desc
*desc
;
730 static const char none
[] = "none";
734 seq_printf(m
, "%-5s %-7s %-15s %-*s %s\n", "irq", "hwirq",
735 "chip name", (int)(2 * sizeof(void *) + 2), "chip data",
738 for (i
= 1; i
< nr_irqs
; i
++) {
739 desc
= irq_to_desc(i
);
743 raw_spin_lock_irqsave(&desc
->lock
, flags
);
745 if (desc
->action
&& desc
->action
->handler
) {
746 struct irq_chip
*chip
;
748 seq_printf(m
, "%5d ", i
);
749 seq_printf(m
, "0x%05lx ", desc
->irq_data
.hwirq
);
751 chip
= irq_desc_get_chip(desc
);
752 if (chip
&& chip
->name
)
756 seq_printf(m
, "%-15s ", p
);
758 data
= irq_desc_get_chip_data(desc
);
759 seq_printf(m
, data
? "0x%p " : " %p ", data
);
761 if (desc
->irq_data
.domain
)
762 p
= of_node_full_name(desc
->irq_data
.domain
->of_node
);
765 seq_printf(m
, "%s\n", p
);
768 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
774 static int virq_debug_open(struct inode
*inode
, struct file
*file
)
776 return single_open(file
, virq_debug_show
, inode
->i_private
);
779 static const struct file_operations virq_debug_fops
= {
780 .open
= virq_debug_open
,
783 .release
= single_release
,
786 static int __init
irq_debugfs_init(void)
788 if (debugfs_create_file("irq_domain_mapping", S_IRUGO
, NULL
,
789 NULL
, &virq_debug_fops
) == NULL
)
794 __initcall(irq_debugfs_init
);
795 #endif /* CONFIG_IRQ_DOMAIN_DEBUG */
798 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
800 * Device Tree IRQ specifier translation function which works with one cell
801 * bindings where the cell value maps directly to the hwirq number.
803 int irq_domain_xlate_onecell(struct irq_domain
*d
, struct device_node
*ctrlr
,
804 const u32
*intspec
, unsigned int intsize
,
805 unsigned long *out_hwirq
, unsigned int *out_type
)
807 if (WARN_ON(intsize
< 1))
809 *out_hwirq
= intspec
[0];
810 *out_type
= IRQ_TYPE_NONE
;
813 EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell
);
816 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
818 * Device Tree IRQ specifier translation function which works with two cell
819 * bindings where the cell values map directly to the hwirq number
820 * and linux irq flags.
822 int irq_domain_xlate_twocell(struct irq_domain
*d
, struct device_node
*ctrlr
,
823 const u32
*intspec
, unsigned int intsize
,
824 irq_hw_number_t
*out_hwirq
, unsigned int *out_type
)
826 if (WARN_ON(intsize
< 2))
828 *out_hwirq
= intspec
[0];
829 *out_type
= intspec
[1] & IRQ_TYPE_SENSE_MASK
;
832 EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell
);
835 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
837 * Device Tree IRQ specifier translation function which works with either one
838 * or two cell bindings where the cell values map directly to the hwirq number
839 * and linux irq flags.
841 * Note: don't use this function unless your interrupt controller explicitly
842 * supports both one and two cell bindings. For the majority of controllers
843 * the _onecell() or _twocell() variants above should be used.
845 int irq_domain_xlate_onetwocell(struct irq_domain
*d
,
846 struct device_node
*ctrlr
,
847 const u32
*intspec
, unsigned int intsize
,
848 unsigned long *out_hwirq
, unsigned int *out_type
)
850 if (WARN_ON(intsize
< 1))
852 *out_hwirq
= intspec
[0];
853 *out_type
= (intsize
> 1) ? intspec
[1] : IRQ_TYPE_NONE
;
856 EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell
);
858 const struct irq_domain_ops irq_domain_simple_ops
= {
859 .xlate
= irq_domain_xlate_onetwocell
,
861 EXPORT_SYMBOL_GPL(irq_domain_simple_ops
);
864 void irq_domain_generate_simple(const struct of_device_id
*match
,
865 u64 phys_base
, unsigned int irq_start
)
867 struct device_node
*node
;
868 pr_debug("looking for phys_base=%llx, irq_start=%i\n",
869 (unsigned long long) phys_base
, (int) irq_start
);
870 node
= of_find_matching_node_by_address(NULL
, match
, phys_base
);
872 irq_domain_add_legacy(node
, 32, irq_start
, 0,
873 &irq_domain_simple_ops
, NULL
);
875 EXPORT_SYMBOL_GPL(irq_domain_generate_simple
);