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 static LIST_HEAD(irq_domain_list
);
20 static DEFINE_MUTEX(irq_domain_mutex
);
22 static DEFINE_MUTEX(revmap_trees_mutex
);
23 static struct irq_domain
*irq_default_domain
;
26 * irq_domain_alloc() - Allocate a new irq_domain data structure
27 * @of_node: optional device-tree node of the interrupt controller
28 * @ops: map/unmap domain callbacks
29 * @host_data: Controller private data pointer
31 * Allocates and initialize and irq_domain structure. Caller is expected to
32 * register allocated irq_domain with irq_domain_register(). Returns pointer
33 * to IRQ domain, or NULL on failure.
35 static struct irq_domain
*irq_domain_alloc(struct device_node
*of_node
,
37 const struct irq_domain_ops
*ops
,
40 struct irq_domain
*domain
;
42 domain
= kzalloc_node(sizeof(*domain
) + (sizeof(unsigned int) * size
),
43 GFP_KERNEL
, of_node_to_nid(of_node
));
48 INIT_RADIX_TREE(&domain
->revmap_tree
, GFP_KERNEL
);
50 domain
->host_data
= host_data
;
51 domain
->of_node
= of_node_get(of_node
);
52 domain
->revmap_size
= size
;
57 static void irq_domain_free(struct irq_domain
*domain
)
59 of_node_put(domain
->of_node
);
63 static void irq_domain_add(struct irq_domain
*domain
)
65 mutex_lock(&irq_domain_mutex
);
66 list_add(&domain
->link
, &irq_domain_list
);
67 mutex_unlock(&irq_domain_mutex
);
68 pr_debug("Added domain %s\n", domain
->name
);
72 * irq_domain_remove() - Remove an irq domain.
73 * @domain: domain to remove
75 * This routine is used to remove an irq domain. The caller must ensure
76 * that all mappings within the domain have been disposed of prior to
77 * use, depending on the revmap type.
79 void irq_domain_remove(struct irq_domain
*domain
)
81 mutex_lock(&irq_domain_mutex
);
84 * radix_tree_delete() takes care of destroying the root
85 * node when all entries are removed. Shout if there are
88 WARN_ON(domain
->revmap_tree
.height
);
90 list_del(&domain
->link
);
93 * If the going away domain is the default one, reset it.
95 if (unlikely(irq_default_domain
== domain
))
96 irq_set_default_host(NULL
);
98 mutex_unlock(&irq_domain_mutex
);
100 pr_debug("Removed domain %s\n", domain
->name
);
102 irq_domain_free(domain
);
104 EXPORT_SYMBOL_GPL(irq_domain_remove
);
107 * irq_domain_add_simple() - Allocate and register a simple irq_domain.
108 * @of_node: pointer to interrupt controller's device tree node.
109 * @size: total number of irqs in mapping
110 * @first_irq: first number of irq block assigned to the domain,
111 * pass zero to assign irqs on-the-fly. This will result in a
112 * linear IRQ domain so it is important to use irq_create_mapping()
113 * for each used IRQ, especially when SPARSE_IRQ is enabled.
114 * @ops: map/unmap domain callbacks
115 * @host_data: Controller private data pointer
117 * Allocates a legacy irq_domain if irq_base is positive or a linear
118 * domain otherwise. For the legacy domain, IRQ descriptors will also
121 * This is intended to implement the expected behaviour for most
122 * interrupt controllers which is that a linear mapping should
123 * normally be used unless the system requires a legacy mapping in
124 * order to support supplying interrupt numbers during non-DT
125 * registration of devices.
127 struct irq_domain
*irq_domain_add_simple(struct device_node
*of_node
,
129 unsigned int first_irq
,
130 const struct irq_domain_ops
*ops
,
136 if (IS_ENABLED(CONFIG_SPARSE_IRQ
)) {
138 * Set the descriptor allocator to search for a
139 * 1-to-1 mapping, such as irq_alloc_desc_at().
140 * Use of_node_to_nid() which is defined to
141 * numa_node_id() on platforms that have no custom
144 irq_base
= irq_alloc_descs(first_irq
, first_irq
, size
,
145 of_node_to_nid(of_node
));
147 pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
149 irq_base
= first_irq
;
152 irq_base
= first_irq
;
154 return irq_domain_add_legacy(of_node
, size
, irq_base
, 0,
158 /* A linear domain is the default */
159 return irq_domain_add_linear(of_node
, size
, ops
, host_data
);
161 EXPORT_SYMBOL_GPL(irq_domain_add_simple
);
164 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
165 * @of_node: pointer to interrupt controller's device tree node.
166 * @size: total number of irqs in legacy mapping
167 * @first_irq: first number of irq block assigned to the domain
168 * @first_hwirq: first hwirq number to use for the translation. Should normally
169 * be '0', but a positive integer can be used if the effective
170 * hwirqs numbering does not begin at zero.
171 * @ops: map/unmap domain callbacks
172 * @host_data: Controller private data pointer
174 * Note: the map() callback will be called before this function returns
175 * for all legacy interrupts except 0 (which is always the invalid irq for
176 * a legacy controller).
178 struct irq_domain
*irq_domain_add_legacy(struct device_node
*of_node
,
180 unsigned int first_irq
,
181 irq_hw_number_t first_hwirq
,
182 const struct irq_domain_ops
*ops
,
185 struct irq_domain
*domain
;
187 pr_debug("Setting up legacy domain virq[%i:%i] ==> hwirq[%i:%i]\n",
188 first_irq
, first_irq
+ size
- 1,
189 (int)first_hwirq
, (int)first_hwirq
+ size
-1);
191 domain
= irq_domain_add_linear(of_node
, first_hwirq
+ size
, ops
, host_data
);
195 WARN_ON(irq_domain_associate_many(domain
, first_irq
, first_hwirq
, size
));
199 EXPORT_SYMBOL_GPL(irq_domain_add_legacy
);
202 * irq_domain_add_linear() - Allocate and register a linear revmap irq_domain.
203 * @of_node: pointer to interrupt controller's device tree node.
204 * @size: Number of interrupts in the domain.
205 * @ops: map/unmap domain callbacks
206 * @host_data: Controller private data pointer
208 struct irq_domain
*irq_domain_add_linear(struct device_node
*of_node
,
210 const struct irq_domain_ops
*ops
,
213 struct irq_domain
*domain
;
215 domain
= irq_domain_alloc(of_node
, size
, ops
, host_data
);
219 irq_domain_add(domain
);
222 EXPORT_SYMBOL_GPL(irq_domain_add_linear
);
224 struct irq_domain
*irq_domain_add_nomap(struct device_node
*of_node
,
225 unsigned int max_irq
,
226 const struct irq_domain_ops
*ops
,
229 struct irq_domain
*domain
= irq_domain_alloc(of_node
, 0, ops
, host_data
);
231 domain
->revmap_direct_max_irq
= max_irq
? max_irq
: ~0;
232 irq_domain_add(domain
);
236 EXPORT_SYMBOL_GPL(irq_domain_add_nomap
);
239 * irq_find_host() - Locates a domain for a given device node
240 * @node: device-tree node of the interrupt controller
242 struct irq_domain
*irq_find_host(struct device_node
*node
)
244 struct irq_domain
*h
, *found
= NULL
;
247 /* We might want to match the legacy controller last since
248 * it might potentially be set to match all interrupts in
249 * the absence of a device node. This isn't a problem so far
252 mutex_lock(&irq_domain_mutex
);
253 list_for_each_entry(h
, &irq_domain_list
, link
) {
255 rc
= h
->ops
->match(h
, node
);
257 rc
= (h
->of_node
!= NULL
) && (h
->of_node
== node
);
264 mutex_unlock(&irq_domain_mutex
);
267 EXPORT_SYMBOL_GPL(irq_find_host
);
270 * irq_set_default_host() - Set a "default" irq domain
271 * @domain: default domain pointer
273 * For convenience, it's possible to set a "default" domain that will be used
274 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
275 * platforms that want to manipulate a few hard coded interrupt numbers that
276 * aren't properly represented in the device-tree.
278 void irq_set_default_host(struct irq_domain
*domain
)
280 pr_debug("Default domain set to @0x%p\n", domain
);
282 irq_default_domain
= domain
;
284 EXPORT_SYMBOL_GPL(irq_set_default_host
);
286 static void irq_domain_disassociate_many(struct irq_domain
*domain
,
287 unsigned int irq_base
, int count
)
290 * disassociate in reverse order;
291 * not strictly necessary, but nice for unwinding
294 int irq
= irq_base
+ count
;
295 struct irq_data
*irq_data
= irq_get_irq_data(irq
);
296 irq_hw_number_t hwirq
;
298 if (WARN_ON(!irq_data
|| irq_data
->domain
!= domain
))
301 hwirq
= irq_data
->hwirq
;
302 irq_set_status_flags(irq
, IRQ_NOREQUEST
);
304 /* remove chip and handler */
305 irq_set_chip_and_handler(irq
, NULL
, NULL
);
307 /* Make sure it's completed */
308 synchronize_irq(irq
);
310 /* Tell the PIC about it */
311 if (domain
->ops
->unmap
)
312 domain
->ops
->unmap(domain
, irq
);
315 irq_data
->domain
= NULL
;
318 /* Clear reverse map for this hwirq */
319 if (hwirq
< domain
->revmap_size
) {
320 domain
->linear_revmap
[hwirq
] = 0;
322 mutex_lock(&revmap_trees_mutex
);
323 radix_tree_delete(&domain
->revmap_tree
, hwirq
);
324 mutex_unlock(&revmap_trees_mutex
);
329 int irq_domain_associate_many(struct irq_domain
*domain
, unsigned int irq_base
,
330 irq_hw_number_t hwirq_base
, int count
)
332 unsigned int virq
= irq_base
;
333 irq_hw_number_t hwirq
= hwirq_base
;
336 pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__
,
337 of_node_full_name(domain
->of_node
), irq_base
, (int)hwirq_base
, count
);
339 for (i
= 0; i
< count
; i
++) {
340 struct irq_data
*irq_data
= irq_get_irq_data(virq
+ i
);
342 if (WARN(!irq_data
, "error: irq_desc not allocated; "
343 "irq=%i hwirq=0x%x\n", virq
+ i
, (int)hwirq
+ i
))
345 if (WARN(irq_data
->domain
, "error: irq_desc already associated; "
346 "irq=%i hwirq=0x%x\n", virq
+ i
, (int)hwirq
+ i
))
350 for (i
= 0; i
< count
; i
++, virq
++, hwirq
++) {
351 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
353 irq_data
->hwirq
= hwirq
;
354 irq_data
->domain
= domain
;
355 if (domain
->ops
->map
) {
356 ret
= domain
->ops
->map(domain
, virq
, hwirq
);
359 * If map() returns -EPERM, this interrupt is protected
360 * by the firmware or some other service and shall not
361 * be mapped. Don't bother telling the user about it.
364 pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
365 domain
->name
, hwirq
, virq
, ret
);
367 irq_data
->domain
= NULL
;
371 /* If not already assigned, give the domain the chip's name */
372 if (!domain
->name
&& irq_data
->chip
)
373 domain
->name
= irq_data
->chip
->name
;
376 if (hwirq
< domain
->revmap_size
) {
377 domain
->linear_revmap
[hwirq
] = virq
;
379 mutex_lock(&revmap_trees_mutex
);
380 radix_tree_insert(&domain
->revmap_tree
, hwirq
, irq_data
);
381 mutex_unlock(&revmap_trees_mutex
);
384 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
389 EXPORT_SYMBOL_GPL(irq_domain_associate_many
);
392 * irq_create_direct_mapping() - Allocate an irq for direct mapping
393 * @domain: domain to allocate the irq for or NULL for default domain
395 * This routine is used for irq controllers which can choose the hardware
396 * interrupt numbers they generate. In such a case it's simplest to use
397 * the linux irq as the hardware interrupt number. It still uses the linear
398 * or radix tree to store the mapping, but the irq controller can optimize
399 * the revmap path by using the hwirq directly.
401 unsigned int irq_create_direct_mapping(struct irq_domain
*domain
)
406 domain
= irq_default_domain
;
408 virq
= irq_alloc_desc_from(1, of_node_to_nid(domain
->of_node
));
410 pr_debug("create_direct virq allocation failed\n");
413 if (virq
>= domain
->revmap_direct_max_irq
) {
414 pr_err("ERROR: no free irqs available below %i maximum\n",
415 domain
->revmap_direct_max_irq
);
419 pr_debug("create_direct obtained virq %d\n", virq
);
421 if (irq_domain_associate(domain
, virq
, virq
)) {
428 EXPORT_SYMBOL_GPL(irq_create_direct_mapping
);
431 * irq_create_mapping() - Map a hardware interrupt into linux irq space
432 * @domain: domain owning this hardware interrupt or NULL for default domain
433 * @hwirq: hardware irq number in that domain space
435 * Only one mapping per hardware interrupt is permitted. Returns a linux
437 * If the sense/trigger is to be specified, set_irq_type() should be called
438 * on the number returned from that call.
440 unsigned int irq_create_mapping(struct irq_domain
*domain
,
441 irq_hw_number_t hwirq
)
446 pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain
, hwirq
);
448 /* Look for default domain if nececssary */
450 domain
= irq_default_domain
;
451 if (domain
== NULL
) {
452 pr_warning("irq_create_mapping called for"
453 " NULL domain, hwirq=%lx\n", hwirq
);
457 pr_debug("-> using domain @%p\n", domain
);
459 /* Check if mapping already exists */
460 virq
= irq_find_mapping(domain
, hwirq
);
462 pr_debug("-> existing mapping on virq %d\n", virq
);
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_domain_associate(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
);
491 * irq_create_strict_mappings() - Map a range of hw irqs to fixed linux irqs
492 * @domain: domain owning the interrupt range
493 * @irq_base: beginning of linux IRQ range
494 * @hwirq_base: beginning of hardware IRQ range
495 * @count: Number of interrupts to map
497 * This routine is used for allocating and mapping a range of hardware
498 * irqs to linux irqs where the linux irq numbers are at pre-defined
499 * locations. For use by controllers that already have static mappings
500 * to insert in to the domain.
502 * Non-linear users can use irq_create_identity_mapping() for IRQ-at-a-time
505 * 0 is returned upon success, while any failure to establish a static
506 * mapping is treated as an error.
508 int irq_create_strict_mappings(struct irq_domain
*domain
, unsigned int irq_base
,
509 irq_hw_number_t hwirq_base
, int count
)
513 ret
= irq_alloc_descs(irq_base
, irq_base
, count
,
514 of_node_to_nid(domain
->of_node
));
515 if (unlikely(ret
< 0))
518 ret
= irq_domain_associate_many(domain
, irq_base
, hwirq_base
, count
);
519 if (unlikely(ret
< 0)) {
520 irq_free_descs(irq_base
, count
);
526 EXPORT_SYMBOL_GPL(irq_create_strict_mappings
);
528 unsigned int irq_create_of_mapping(struct device_node
*controller
,
529 const u32
*intspec
, unsigned int intsize
)
531 struct irq_domain
*domain
;
532 irq_hw_number_t hwirq
;
533 unsigned int type
= IRQ_TYPE_NONE
;
536 domain
= controller
? irq_find_host(controller
) : irq_default_domain
;
540 * Workaround to avoid breaking interrupt controller drivers
541 * that don't yet register an irq_domain. This is temporary
542 * code. ~~~gcl, Feb 24, 2012
544 * Scheduled for removal in Linux v3.6. That should be enough
550 pr_warning("no irq domain found for %s !\n",
551 of_node_full_name(controller
));
555 /* If domain has no translation, then we assume interrupt line */
556 if (domain
->ops
->xlate
== NULL
)
559 if (domain
->ops
->xlate(domain
, controller
, intspec
, intsize
,
565 virq
= irq_create_mapping(domain
, hwirq
);
569 /* Set type if specified and different than the current one */
570 if (type
!= IRQ_TYPE_NONE
&&
571 type
!= (irqd_get_trigger_type(irq_get_irq_data(virq
))))
572 irq_set_irq_type(virq
, type
);
575 EXPORT_SYMBOL_GPL(irq_create_of_mapping
);
578 * irq_dispose_mapping() - Unmap an interrupt
579 * @virq: linux irq number of the interrupt to unmap
581 void irq_dispose_mapping(unsigned int virq
)
583 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
584 struct irq_domain
*domain
;
586 if (!virq
|| !irq_data
)
589 domain
= irq_data
->domain
;
590 if (WARN_ON(domain
== NULL
))
593 irq_domain_disassociate_many(domain
, virq
, 1);
596 EXPORT_SYMBOL_GPL(irq_dispose_mapping
);
599 * irq_find_mapping() - Find a linux irq from an hw irq number.
600 * @domain: domain owning this hardware interrupt
601 * @hwirq: hardware irq number in that domain space
603 unsigned int irq_find_mapping(struct irq_domain
*domain
,
604 irq_hw_number_t hwirq
)
606 struct irq_data
*data
;
608 /* Look for default domain if nececssary */
610 domain
= irq_default_domain
;
614 if (hwirq
< domain
->revmap_direct_max_irq
) {
615 data
= irq_get_irq_data(hwirq
);
616 if (data
&& (data
->domain
== domain
) && (data
->hwirq
== hwirq
))
620 return irq_linear_revmap(domain
, hwirq
);
622 EXPORT_SYMBOL_GPL(irq_find_mapping
);
625 * irq_linear_revmap() - Find a linux irq from a hw irq number.
626 * @domain: domain owning this hardware interrupt
627 * @hwirq: hardware irq number in that domain space
629 * This is a fast path that can be called directly by irq controller code to
630 * save a handful of instructions.
632 unsigned int irq_linear_revmap(struct irq_domain
*domain
,
633 irq_hw_number_t hwirq
)
635 struct irq_data
*data
;
637 /* Check revmap bounds; complain if exceeded */
638 if (hwirq
>= domain
->revmap_size
) {
640 data
= radix_tree_lookup(&domain
->revmap_tree
, hwirq
);
642 return data
? data
->irq
: 0;
645 return domain
->linear_revmap
[hwirq
];
647 EXPORT_SYMBOL_GPL(irq_linear_revmap
);
649 #ifdef CONFIG_IRQ_DOMAIN_DEBUG
650 static int virq_debug_show(struct seq_file
*m
, void *private)
653 struct irq_desc
*desc
;
657 seq_printf(m
, "%-5s %-7s %-15s %-*s %s\n", "irq", "hwirq",
658 "chip name", (int)(2 * sizeof(void *) + 2), "chip data",
661 for (i
= 1; i
< nr_irqs
; i
++) {
662 desc
= irq_to_desc(i
);
666 raw_spin_lock_irqsave(&desc
->lock
, flags
);
668 if (desc
->action
&& desc
->action
->handler
) {
669 struct irq_chip
*chip
;
671 seq_printf(m
, "%5d ", i
);
672 seq_printf(m
, "0x%05lx ", desc
->irq_data
.hwirq
);
674 chip
= irq_desc_get_chip(desc
);
675 seq_printf(m
, "%-15s ", (chip
&& chip
->name
) ? chip
->name
: "none");
677 data
= irq_desc_get_chip_data(desc
);
678 seq_printf(m
, data
? "0x%p " : " %p ", data
);
680 seq_printf(m
, "%s\n", desc
->irq_data
.domain
->name
);
683 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
689 static int virq_debug_open(struct inode
*inode
, struct file
*file
)
691 return single_open(file
, virq_debug_show
, inode
->i_private
);
694 static const struct file_operations virq_debug_fops
= {
695 .open
= virq_debug_open
,
698 .release
= single_release
,
701 static int __init
irq_debugfs_init(void)
703 if (debugfs_create_file("irq_domain_mapping", S_IRUGO
, NULL
,
704 NULL
, &virq_debug_fops
) == NULL
)
709 __initcall(irq_debugfs_init
);
710 #endif /* CONFIG_IRQ_DOMAIN_DEBUG */
713 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
715 * Device Tree IRQ specifier translation function which works with one cell
716 * bindings where the cell value maps directly to the hwirq number.
718 int irq_domain_xlate_onecell(struct irq_domain
*d
, struct device_node
*ctrlr
,
719 const u32
*intspec
, unsigned int intsize
,
720 unsigned long *out_hwirq
, unsigned int *out_type
)
722 if (WARN_ON(intsize
< 1))
724 *out_hwirq
= intspec
[0];
725 *out_type
= IRQ_TYPE_NONE
;
728 EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell
);
731 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
733 * Device Tree IRQ specifier translation function which works with two cell
734 * bindings where the cell values map directly to the hwirq number
735 * and linux irq flags.
737 int irq_domain_xlate_twocell(struct irq_domain
*d
, struct device_node
*ctrlr
,
738 const u32
*intspec
, unsigned int intsize
,
739 irq_hw_number_t
*out_hwirq
, unsigned int *out_type
)
741 if (WARN_ON(intsize
< 2))
743 *out_hwirq
= intspec
[0];
744 *out_type
= intspec
[1] & IRQ_TYPE_SENSE_MASK
;
747 EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell
);
750 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
752 * Device Tree IRQ specifier translation function which works with either one
753 * or two cell bindings where the cell values map directly to the hwirq number
754 * and linux irq flags.
756 * Note: don't use this function unless your interrupt controller explicitly
757 * supports both one and two cell bindings. For the majority of controllers
758 * the _onecell() or _twocell() variants above should be used.
760 int irq_domain_xlate_onetwocell(struct irq_domain
*d
,
761 struct device_node
*ctrlr
,
762 const u32
*intspec
, unsigned int intsize
,
763 unsigned long *out_hwirq
, unsigned int *out_type
)
765 if (WARN_ON(intsize
< 1))
767 *out_hwirq
= intspec
[0];
768 *out_type
= (intsize
> 1) ? intspec
[1] : IRQ_TYPE_NONE
;
771 EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell
);
773 const struct irq_domain_ops irq_domain_simple_ops
= {
774 .xlate
= irq_domain_xlate_onetwocell
,
776 EXPORT_SYMBOL_GPL(irq_domain_simple_ops
);
779 void irq_domain_generate_simple(const struct of_device_id
*match
,
780 u64 phys_base
, unsigned int irq_start
)
782 struct device_node
*node
;
783 pr_debug("looking for phys_base=%llx, irq_start=%i\n",
784 (unsigned long long) phys_base
, (int) irq_start
);
785 node
= of_find_matching_node_by_address(NULL
, match
, phys_base
);
787 irq_domain_add_legacy(node
, 32, irq_start
, 0,
788 &irq_domain_simple_ops
, NULL
);
790 EXPORT_SYMBOL_GPL(irq_domain_generate_simple
);