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/of_irq.h>
14 #include <linux/topology.h>
15 #include <linux/seq_file.h>
16 #include <linux/slab.h>
17 #include <linux/smp.h>
20 static LIST_HEAD(irq_domain_list
);
21 static DEFINE_MUTEX(irq_domain_mutex
);
23 static DEFINE_MUTEX(revmap_trees_mutex
);
24 static struct irq_domain
*irq_default_domain
;
26 static void irq_domain_check_hierarchy(struct irq_domain
*domain
);
29 struct fwnode_handle fwnode
;
35 * irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for
36 * identifying an irq domain
37 * @data: optional user-provided data
39 * Allocate a struct device_node, and return a poiner to the embedded
40 * fwnode_handle (or NULL on failure).
42 struct fwnode_handle
*irq_domain_alloc_fwnode(void *data
)
44 struct irqchip_fwid
*fwid
;
47 fwid
= kzalloc(sizeof(*fwid
), GFP_KERNEL
);
48 name
= kasprintf(GFP_KERNEL
, "irqchip@%p", data
);
58 fwid
->fwnode
.type
= FWNODE_IRQCHIP
;
61 EXPORT_SYMBOL_GPL(irq_domain_alloc_fwnode
);
64 * irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle
66 * Free a fwnode_handle allocated with irq_domain_alloc_fwnode.
68 void irq_domain_free_fwnode(struct fwnode_handle
*fwnode
)
70 struct irqchip_fwid
*fwid
;
72 if (WARN_ON(!is_fwnode_irqchip(fwnode
)))
75 fwid
= container_of(fwnode
, struct irqchip_fwid
, fwnode
);
79 EXPORT_SYMBOL_GPL(irq_domain_free_fwnode
);
82 * __irq_domain_add() - Allocate a new irq_domain data structure
83 * @of_node: optional device-tree node of the interrupt controller
84 * @size: Size of linear map; 0 for radix mapping only
85 * @hwirq_max: Maximum number of interrupts supported by controller
86 * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
88 * @ops: domain callbacks
89 * @host_data: Controller private data pointer
91 * Allocates and initialize and irq_domain structure.
92 * Returns pointer to IRQ domain, or NULL on failure.
94 struct irq_domain
*__irq_domain_add(struct fwnode_handle
*fwnode
, int size
,
95 irq_hw_number_t hwirq_max
, int direct_max
,
96 const struct irq_domain_ops
*ops
,
99 struct irq_domain
*domain
;
100 struct device_node
*of_node
;
102 of_node
= to_of_node(fwnode
);
104 domain
= kzalloc_node(sizeof(*domain
) + (sizeof(unsigned int) * size
),
105 GFP_KERNEL
, of_node_to_nid(of_node
));
106 if (WARN_ON(!domain
))
109 of_node_get(of_node
);
112 INIT_RADIX_TREE(&domain
->revmap_tree
, GFP_KERNEL
);
114 domain
->host_data
= host_data
;
115 domain
->fwnode
= fwnode
;
116 domain
->hwirq_max
= hwirq_max
;
117 domain
->revmap_size
= size
;
118 domain
->revmap_direct_max_irq
= direct_max
;
119 irq_domain_check_hierarchy(domain
);
121 mutex_lock(&irq_domain_mutex
);
122 list_add(&domain
->link
, &irq_domain_list
);
123 mutex_unlock(&irq_domain_mutex
);
125 pr_debug("Added domain %s\n", domain
->name
);
128 EXPORT_SYMBOL_GPL(__irq_domain_add
);
131 * irq_domain_remove() - Remove an irq domain.
132 * @domain: domain to remove
134 * This routine is used to remove an irq domain. The caller must ensure
135 * that all mappings within the domain have been disposed of prior to
136 * use, depending on the revmap type.
138 void irq_domain_remove(struct irq_domain
*domain
)
140 mutex_lock(&irq_domain_mutex
);
142 WARN_ON(!radix_tree_empty(&domain
->revmap_tree
));
144 list_del(&domain
->link
);
147 * If the going away domain is the default one, reset it.
149 if (unlikely(irq_default_domain
== domain
))
150 irq_set_default_host(NULL
);
152 mutex_unlock(&irq_domain_mutex
);
154 pr_debug("Removed domain %s\n", domain
->name
);
156 of_node_put(irq_domain_get_of_node(domain
));
159 EXPORT_SYMBOL_GPL(irq_domain_remove
);
162 * irq_domain_add_simple() - Register an irq_domain and optionally map a range of irqs
163 * @of_node: pointer to interrupt controller's device tree node.
164 * @size: total number of irqs in mapping
165 * @first_irq: first number of irq block assigned to the domain,
166 * pass zero to assign irqs on-the-fly. If first_irq is non-zero, then
167 * pre-map all of the irqs in the domain to virqs starting at first_irq.
168 * @ops: domain callbacks
169 * @host_data: Controller private data pointer
171 * Allocates an irq_domain, and optionally if first_irq is positive then also
172 * allocate irq_descs and map all of the hwirqs to virqs starting at first_irq.
174 * This is intended to implement the expected behaviour for most
175 * interrupt controllers. If device tree is used, then first_irq will be 0 and
176 * irqs get mapped dynamically on the fly. However, if the controller requires
177 * static virq assignments (non-DT boot) then it will set that up correctly.
179 struct irq_domain
*irq_domain_add_simple(struct device_node
*of_node
,
181 unsigned int first_irq
,
182 const struct irq_domain_ops
*ops
,
185 struct irq_domain
*domain
;
187 domain
= __irq_domain_add(of_node_to_fwnode(of_node
), size
, size
, 0, ops
, host_data
);
192 if (IS_ENABLED(CONFIG_SPARSE_IRQ
)) {
193 /* attempt to allocated irq_descs */
194 int rc
= irq_alloc_descs(first_irq
, first_irq
, size
,
195 of_node_to_nid(of_node
));
197 pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
200 irq_domain_associate_many(domain
, first_irq
, 0, size
);
205 EXPORT_SYMBOL_GPL(irq_domain_add_simple
);
208 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
209 * @of_node: pointer to interrupt controller's device tree node.
210 * @size: total number of irqs in legacy mapping
211 * @first_irq: first number of irq block assigned to the domain
212 * @first_hwirq: first hwirq number to use for the translation. Should normally
213 * be '0', but a positive integer can be used if the effective
214 * hwirqs numbering does not begin at zero.
215 * @ops: map/unmap domain callbacks
216 * @host_data: Controller private data pointer
218 * Note: the map() callback will be called before this function returns
219 * for all legacy interrupts except 0 (which is always the invalid irq for
220 * a legacy controller).
222 struct irq_domain
*irq_domain_add_legacy(struct device_node
*of_node
,
224 unsigned int first_irq
,
225 irq_hw_number_t first_hwirq
,
226 const struct irq_domain_ops
*ops
,
229 struct irq_domain
*domain
;
231 domain
= __irq_domain_add(of_node_to_fwnode(of_node
), first_hwirq
+ size
,
232 first_hwirq
+ size
, 0, ops
, host_data
);
234 irq_domain_associate_many(domain
, first_irq
, first_hwirq
, size
);
238 EXPORT_SYMBOL_GPL(irq_domain_add_legacy
);
241 * irq_find_matching_fwspec() - Locates a domain for a given fwspec
242 * @fwspec: FW specifier for an interrupt
243 * @bus_token: domain-specific data
245 struct irq_domain
*irq_find_matching_fwspec(struct irq_fwspec
*fwspec
,
246 enum irq_domain_bus_token bus_token
)
248 struct irq_domain
*h
, *found
= NULL
;
249 struct fwnode_handle
*fwnode
= fwspec
->fwnode
;
252 /* We might want to match the legacy controller last since
253 * it might potentially be set to match all interrupts in
254 * the absence of a device node. This isn't a problem so far
257 * bus_token == DOMAIN_BUS_ANY matches any domain, any other
258 * values must generate an exact match for the domain to be
261 mutex_lock(&irq_domain_mutex
);
262 list_for_each_entry(h
, &irq_domain_list
, link
) {
263 if (h
->ops
->select
&& fwspec
->param_count
)
264 rc
= h
->ops
->select(h
, fwspec
, bus_token
);
265 else if (h
->ops
->match
)
266 rc
= h
->ops
->match(h
, to_of_node(fwnode
), bus_token
);
268 rc
= ((fwnode
!= NULL
) && (h
->fwnode
== fwnode
) &&
269 ((bus_token
== DOMAIN_BUS_ANY
) ||
270 (h
->bus_token
== bus_token
)));
277 mutex_unlock(&irq_domain_mutex
);
280 EXPORT_SYMBOL_GPL(irq_find_matching_fwspec
);
283 * irq_set_default_host() - Set a "default" irq domain
284 * @domain: default domain pointer
286 * For convenience, it's possible to set a "default" domain that will be used
287 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
288 * platforms that want to manipulate a few hard coded interrupt numbers that
289 * aren't properly represented in the device-tree.
291 void irq_set_default_host(struct irq_domain
*domain
)
293 pr_debug("Default domain set to @0x%p\n", domain
);
295 irq_default_domain
= domain
;
297 EXPORT_SYMBOL_GPL(irq_set_default_host
);
299 void irq_domain_disassociate(struct irq_domain
*domain
, unsigned int irq
)
301 struct irq_data
*irq_data
= irq_get_irq_data(irq
);
302 irq_hw_number_t hwirq
;
304 if (WARN(!irq_data
|| irq_data
->domain
!= domain
,
305 "virq%i doesn't exist; cannot disassociate\n", irq
))
308 hwirq
= irq_data
->hwirq
;
309 irq_set_status_flags(irq
, IRQ_NOREQUEST
);
311 /* remove chip and handler */
312 irq_set_chip_and_handler(irq
, NULL
, NULL
);
314 /* Make sure it's completed */
315 synchronize_irq(irq
);
317 /* Tell the PIC about it */
318 if (domain
->ops
->unmap
)
319 domain
->ops
->unmap(domain
, irq
);
322 irq_data
->domain
= NULL
;
325 /* Clear reverse map for this hwirq */
326 if (hwirq
< domain
->revmap_size
) {
327 domain
->linear_revmap
[hwirq
] = 0;
329 mutex_lock(&revmap_trees_mutex
);
330 radix_tree_delete(&domain
->revmap_tree
, hwirq
);
331 mutex_unlock(&revmap_trees_mutex
);
335 int irq_domain_associate(struct irq_domain
*domain
, unsigned int virq
,
336 irq_hw_number_t hwirq
)
338 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
341 if (WARN(hwirq
>= domain
->hwirq_max
,
342 "error: hwirq 0x%x is too large for %s\n", (int)hwirq
, domain
->name
))
344 if (WARN(!irq_data
, "error: virq%i is not allocated", virq
))
346 if (WARN(irq_data
->domain
, "error: virq%i is already associated", virq
))
349 mutex_lock(&irq_domain_mutex
);
350 irq_data
->hwirq
= hwirq
;
351 irq_data
->domain
= domain
;
352 if (domain
->ops
->map
) {
353 ret
= domain
->ops
->map(domain
, virq
, hwirq
);
356 * If map() returns -EPERM, this interrupt is protected
357 * by the firmware or some other service and shall not
358 * be mapped. Don't bother telling the user about it.
361 pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
362 domain
->name
, hwirq
, virq
, ret
);
364 irq_data
->domain
= NULL
;
366 mutex_unlock(&irq_domain_mutex
);
370 /* If not already assigned, give the domain the chip's name */
371 if (!domain
->name
&& irq_data
->chip
)
372 domain
->name
= irq_data
->chip
->name
;
375 if (hwirq
< domain
->revmap_size
) {
376 domain
->linear_revmap
[hwirq
] = virq
;
378 mutex_lock(&revmap_trees_mutex
);
379 radix_tree_insert(&domain
->revmap_tree
, hwirq
, irq_data
);
380 mutex_unlock(&revmap_trees_mutex
);
382 mutex_unlock(&irq_domain_mutex
);
384 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
388 EXPORT_SYMBOL_GPL(irq_domain_associate
);
390 void irq_domain_associate_many(struct irq_domain
*domain
, unsigned int irq_base
,
391 irq_hw_number_t hwirq_base
, int count
)
393 struct device_node
*of_node
;
396 of_node
= irq_domain_get_of_node(domain
);
397 pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__
,
398 of_node_full_name(of_node
), irq_base
, (int)hwirq_base
, count
);
400 for (i
= 0; i
< count
; i
++) {
401 irq_domain_associate(domain
, irq_base
+ i
, hwirq_base
+ i
);
404 EXPORT_SYMBOL_GPL(irq_domain_associate_many
);
407 * irq_create_direct_mapping() - Allocate an irq for direct mapping
408 * @domain: domain to allocate the irq for or NULL for default domain
410 * This routine is used for irq controllers which can choose the hardware
411 * interrupt numbers they generate. In such a case it's simplest to use
412 * the linux irq as the hardware interrupt number. It still uses the linear
413 * or radix tree to store the mapping, but the irq controller can optimize
414 * the revmap path by using the hwirq directly.
416 unsigned int irq_create_direct_mapping(struct irq_domain
*domain
)
418 struct device_node
*of_node
;
422 domain
= irq_default_domain
;
424 of_node
= irq_domain_get_of_node(domain
);
425 virq
= irq_alloc_desc_from(1, of_node_to_nid(of_node
));
427 pr_debug("create_direct virq allocation failed\n");
430 if (virq
>= domain
->revmap_direct_max_irq
) {
431 pr_err("ERROR: no free irqs available below %i maximum\n",
432 domain
->revmap_direct_max_irq
);
436 pr_debug("create_direct obtained virq %d\n", virq
);
438 if (irq_domain_associate(domain
, virq
, virq
)) {
445 EXPORT_SYMBOL_GPL(irq_create_direct_mapping
);
448 * irq_create_mapping() - Map a hardware interrupt into linux irq space
449 * @domain: domain owning this hardware interrupt or NULL for default domain
450 * @hwirq: hardware irq number in that domain space
452 * Only one mapping per hardware interrupt is permitted. Returns a linux
454 * If the sense/trigger is to be specified, set_irq_type() should be called
455 * on the number returned from that call.
457 unsigned int irq_create_mapping(struct irq_domain
*domain
,
458 irq_hw_number_t hwirq
)
460 struct device_node
*of_node
;
463 pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain
, hwirq
);
465 /* Look for default domain if nececssary */
467 domain
= irq_default_domain
;
468 if (domain
== NULL
) {
469 WARN(1, "%s(, %lx) called with NULL domain\n", __func__
, hwirq
);
472 pr_debug("-> using domain @%p\n", domain
);
474 of_node
= irq_domain_get_of_node(domain
);
476 /* Check if mapping already exists */
477 virq
= irq_find_mapping(domain
, hwirq
);
479 pr_debug("-> existing mapping on virq %d\n", virq
);
483 /* Allocate a virtual interrupt number */
484 virq
= irq_domain_alloc_descs(-1, 1, hwirq
, of_node_to_nid(of_node
), NULL
);
486 pr_debug("-> virq allocation failed\n");
490 if (irq_domain_associate(domain
, virq
, hwirq
)) {
495 pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
496 hwirq
, of_node_full_name(of_node
), virq
);
500 EXPORT_SYMBOL_GPL(irq_create_mapping
);
503 * irq_create_strict_mappings() - Map a range of hw irqs to fixed linux irqs
504 * @domain: domain owning the interrupt range
505 * @irq_base: beginning of linux IRQ range
506 * @hwirq_base: beginning of hardware IRQ range
507 * @count: Number of interrupts to map
509 * This routine is used for allocating and mapping a range of hardware
510 * irqs to linux irqs where the linux irq numbers are at pre-defined
511 * locations. For use by controllers that already have static mappings
512 * to insert in to the domain.
514 * Non-linear users can use irq_create_identity_mapping() for IRQ-at-a-time
517 * 0 is returned upon success, while any failure to establish a static
518 * mapping is treated as an error.
520 int irq_create_strict_mappings(struct irq_domain
*domain
, unsigned int irq_base
,
521 irq_hw_number_t hwirq_base
, int count
)
523 struct device_node
*of_node
;
526 of_node
= irq_domain_get_of_node(domain
);
527 ret
= irq_alloc_descs(irq_base
, irq_base
, count
,
528 of_node_to_nid(of_node
));
529 if (unlikely(ret
< 0))
532 irq_domain_associate_many(domain
, irq_base
, hwirq_base
, count
);
535 EXPORT_SYMBOL_GPL(irq_create_strict_mappings
);
537 static int irq_domain_translate(struct irq_domain
*d
,
538 struct irq_fwspec
*fwspec
,
539 irq_hw_number_t
*hwirq
, unsigned int *type
)
541 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
542 if (d
->ops
->translate
)
543 return d
->ops
->translate(d
, fwspec
, hwirq
, type
);
546 return d
->ops
->xlate(d
, to_of_node(fwspec
->fwnode
),
547 fwspec
->param
, fwspec
->param_count
,
550 /* If domain has no translation, then we assume interrupt line */
551 *hwirq
= fwspec
->param
[0];
555 static void of_phandle_args_to_fwspec(struct of_phandle_args
*irq_data
,
556 struct irq_fwspec
*fwspec
)
560 fwspec
->fwnode
= irq_data
->np
? &irq_data
->np
->fwnode
: NULL
;
561 fwspec
->param_count
= irq_data
->args_count
;
563 for (i
= 0; i
< irq_data
->args_count
; i
++)
564 fwspec
->param
[i
] = irq_data
->args
[i
];
567 unsigned int irq_create_fwspec_mapping(struct irq_fwspec
*fwspec
)
569 struct irq_domain
*domain
;
570 struct irq_data
*irq_data
;
571 irq_hw_number_t hwirq
;
572 unsigned int type
= IRQ_TYPE_NONE
;
575 if (fwspec
->fwnode
) {
576 domain
= irq_find_matching_fwspec(fwspec
, DOMAIN_BUS_WIRED
);
578 domain
= irq_find_matching_fwspec(fwspec
, DOMAIN_BUS_ANY
);
580 domain
= irq_default_domain
;
584 pr_warn("no irq domain found for %s !\n",
585 of_node_full_name(to_of_node(fwspec
->fwnode
)));
589 if (irq_domain_translate(domain
, fwspec
, &hwirq
, &type
))
593 * WARN if the irqchip returns a type with bits
594 * outside the sense mask set and clear these bits.
596 if (WARN_ON(type
& ~IRQ_TYPE_SENSE_MASK
))
597 type
&= IRQ_TYPE_SENSE_MASK
;
600 * If we've already configured this interrupt,
601 * don't do it again, or hell will break loose.
603 virq
= irq_find_mapping(domain
, hwirq
);
606 * If the trigger type is not specified or matches the
607 * current trigger type then we are done so return the
610 if (type
== IRQ_TYPE_NONE
|| type
== irq_get_trigger_type(virq
))
614 * If the trigger type has not been set yet, then set
615 * it now and return the interrupt number.
617 if (irq_get_trigger_type(virq
) == IRQ_TYPE_NONE
) {
618 irq_data
= irq_get_irq_data(virq
);
622 irqd_set_trigger_type(irq_data
, type
);
626 pr_warn("type mismatch, failed to map hwirq-%lu for %s!\n",
627 hwirq
, of_node_full_name(to_of_node(fwspec
->fwnode
)));
631 if (irq_domain_is_hierarchy(domain
)) {
632 virq
= irq_domain_alloc_irqs(domain
, 1, NUMA_NO_NODE
, fwspec
);
637 virq
= irq_create_mapping(domain
, hwirq
);
642 irq_data
= irq_get_irq_data(virq
);
644 if (irq_domain_is_hierarchy(domain
))
645 irq_domain_free_irqs(virq
, 1);
647 irq_dispose_mapping(virq
);
651 /* Store trigger type */
652 irqd_set_trigger_type(irq_data
, type
);
656 EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping
);
658 unsigned int irq_create_of_mapping(struct of_phandle_args
*irq_data
)
660 struct irq_fwspec fwspec
;
662 of_phandle_args_to_fwspec(irq_data
, &fwspec
);
663 return irq_create_fwspec_mapping(&fwspec
);
665 EXPORT_SYMBOL_GPL(irq_create_of_mapping
);
668 * irq_dispose_mapping() - Unmap an interrupt
669 * @virq: linux irq number of the interrupt to unmap
671 void irq_dispose_mapping(unsigned int virq
)
673 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
674 struct irq_domain
*domain
;
676 if (!virq
|| !irq_data
)
679 domain
= irq_data
->domain
;
680 if (WARN_ON(domain
== NULL
))
683 if (irq_domain_is_hierarchy(domain
)) {
684 irq_domain_free_irqs(virq
, 1);
686 irq_domain_disassociate(domain
, virq
);
690 EXPORT_SYMBOL_GPL(irq_dispose_mapping
);
693 * irq_find_mapping() - Find a linux irq from an hw irq number.
694 * @domain: domain owning this hardware interrupt
695 * @hwirq: hardware irq number in that domain space
697 unsigned int irq_find_mapping(struct irq_domain
*domain
,
698 irq_hw_number_t hwirq
)
700 struct irq_data
*data
;
702 /* Look for default domain if nececssary */
704 domain
= irq_default_domain
;
708 if (hwirq
< domain
->revmap_direct_max_irq
) {
709 data
= irq_domain_get_irq_data(domain
, hwirq
);
710 if (data
&& data
->hwirq
== hwirq
)
714 /* Check if the hwirq is in the linear revmap. */
715 if (hwirq
< domain
->revmap_size
)
716 return domain
->linear_revmap
[hwirq
];
719 data
= radix_tree_lookup(&domain
->revmap_tree
, hwirq
);
721 return data
? data
->irq
: 0;
723 EXPORT_SYMBOL_GPL(irq_find_mapping
);
725 #ifdef CONFIG_IRQ_DOMAIN_DEBUG
726 static int virq_debug_show(struct seq_file
*m
, void *private)
729 struct irq_desc
*desc
;
730 struct irq_domain
*domain
;
731 struct radix_tree_iter iter
;
735 seq_printf(m
, " %-16s %-6s %-10s %-10s %s\n",
736 "name", "mapped", "linear-max", "direct-max", "devtree-node");
737 mutex_lock(&irq_domain_mutex
);
738 list_for_each_entry(domain
, &irq_domain_list
, link
) {
739 struct device_node
*of_node
;
741 of_node
= irq_domain_get_of_node(domain
);
742 radix_tree_for_each_slot(slot
, &domain
->revmap_tree
, &iter
, 0)
744 seq_printf(m
, "%c%-16s %6u %10u %10u %s\n",
745 domain
== irq_default_domain
? '*' : ' ', domain
->name
,
746 domain
->revmap_size
+ count
, domain
->revmap_size
,
747 domain
->revmap_direct_max_irq
,
748 of_node
? of_node_full_name(of_node
) : "");
750 mutex_unlock(&irq_domain_mutex
);
752 seq_printf(m
, "%-5s %-7s %-15s %-*s %6s %-14s %s\n", "irq", "hwirq",
753 "chip name", (int)(2 * sizeof(void *) + 2), "chip data",
754 "active", "type", "domain");
756 for (i
= 1; i
< nr_irqs
; i
++) {
757 desc
= irq_to_desc(i
);
761 raw_spin_lock_irqsave(&desc
->lock
, flags
);
762 domain
= desc
->irq_data
.domain
;
765 struct irq_chip
*chip
;
766 int hwirq
= desc
->irq_data
.hwirq
;
769 seq_printf(m
, "%5d ", i
);
770 seq_printf(m
, "0x%05x ", hwirq
);
772 chip
= irq_desc_get_chip(desc
);
773 seq_printf(m
, "%-15s ", (chip
&& chip
->name
) ? chip
->name
: "none");
775 data
= irq_desc_get_chip_data(desc
);
776 seq_printf(m
, data
? "0x%p " : " %p ", data
);
778 seq_printf(m
, " %c ", (desc
->action
&& desc
->action
->handler
) ? '*' : ' ');
779 direct
= (i
== hwirq
) && (i
< domain
->revmap_direct_max_irq
);
780 seq_printf(m
, "%6s%-8s ",
781 (hwirq
< domain
->revmap_size
) ? "LINEAR" : "RADIX",
782 direct
? "(DIRECT)" : "");
783 seq_printf(m
, "%s\n", desc
->irq_data
.domain
->name
);
786 raw_spin_unlock_irqrestore(&desc
->lock
, flags
);
792 static int virq_debug_open(struct inode
*inode
, struct file
*file
)
794 return single_open(file
, virq_debug_show
, inode
->i_private
);
797 static const struct file_operations virq_debug_fops
= {
798 .open
= virq_debug_open
,
801 .release
= single_release
,
804 static int __init
irq_debugfs_init(void)
806 if (debugfs_create_file("irq_domain_mapping", S_IRUGO
, NULL
,
807 NULL
, &virq_debug_fops
) == NULL
)
812 __initcall(irq_debugfs_init
);
813 #endif /* CONFIG_IRQ_DOMAIN_DEBUG */
816 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
818 * Device Tree IRQ specifier translation function which works with one cell
819 * bindings where the cell value maps directly to the hwirq number.
821 int irq_domain_xlate_onecell(struct irq_domain
*d
, struct device_node
*ctrlr
,
822 const u32
*intspec
, unsigned int intsize
,
823 unsigned long *out_hwirq
, unsigned int *out_type
)
825 if (WARN_ON(intsize
< 1))
827 *out_hwirq
= intspec
[0];
828 *out_type
= IRQ_TYPE_NONE
;
831 EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell
);
834 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
836 * Device Tree IRQ specifier translation function which works with two cell
837 * bindings where the cell values map directly to the hwirq number
838 * and linux irq flags.
840 int irq_domain_xlate_twocell(struct irq_domain
*d
, struct device_node
*ctrlr
,
841 const u32
*intspec
, unsigned int intsize
,
842 irq_hw_number_t
*out_hwirq
, unsigned int *out_type
)
844 if (WARN_ON(intsize
< 2))
846 *out_hwirq
= intspec
[0];
847 *out_type
= intspec
[1] & IRQ_TYPE_SENSE_MASK
;
850 EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell
);
853 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
855 * Device Tree IRQ specifier translation function which works with either one
856 * or two cell bindings where the cell values map directly to the hwirq number
857 * and linux irq flags.
859 * Note: don't use this function unless your interrupt controller explicitly
860 * supports both one and two cell bindings. For the majority of controllers
861 * the _onecell() or _twocell() variants above should be used.
863 int irq_domain_xlate_onetwocell(struct irq_domain
*d
,
864 struct device_node
*ctrlr
,
865 const u32
*intspec
, unsigned int intsize
,
866 unsigned long *out_hwirq
, unsigned int *out_type
)
868 if (WARN_ON(intsize
< 1))
870 *out_hwirq
= intspec
[0];
871 *out_type
= (intsize
> 1) ? intspec
[1] : IRQ_TYPE_NONE
;
874 EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell
);
876 const struct irq_domain_ops irq_domain_simple_ops
= {
877 .xlate
= irq_domain_xlate_onetwocell
,
879 EXPORT_SYMBOL_GPL(irq_domain_simple_ops
);
881 int irq_domain_alloc_descs(int virq
, unsigned int cnt
, irq_hw_number_t hwirq
,
882 int node
, const struct cpumask
*affinity
)
887 virq
= __irq_alloc_descs(virq
, virq
, cnt
, node
, THIS_MODULE
,
890 hint
= hwirq
% nr_irqs
;
893 virq
= __irq_alloc_descs(-1, hint
, cnt
, node
, THIS_MODULE
,
895 if (virq
<= 0 && hint
> 1) {
896 virq
= __irq_alloc_descs(-1, 1, cnt
, node
, THIS_MODULE
,
904 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
906 * irq_domain_create_hierarchy - Add a irqdomain into the hierarchy
907 * @parent: Parent irq domain to associate with the new domain
908 * @flags: Irq domain flags associated to the domain
909 * @size: Size of the domain. See below
910 * @fwnode: Optional fwnode of the interrupt controller
911 * @ops: Pointer to the interrupt domain callbacks
912 * @host_data: Controller private data pointer
914 * If @size is 0 a tree domain is created, otherwise a linear domain.
916 * If successful the parent is associated to the new domain and the
917 * domain flags are set.
918 * Returns pointer to IRQ domain, or NULL on failure.
920 struct irq_domain
*irq_domain_create_hierarchy(struct irq_domain
*parent
,
923 struct fwnode_handle
*fwnode
,
924 const struct irq_domain_ops
*ops
,
927 struct irq_domain
*domain
;
930 domain
= irq_domain_create_linear(fwnode
, size
, ops
, host_data
);
932 domain
= irq_domain_create_tree(fwnode
, ops
, host_data
);
934 domain
->parent
= parent
;
935 domain
->flags
|= flags
;
940 EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy
);
942 static void irq_domain_insert_irq(int virq
)
944 struct irq_data
*data
;
946 for (data
= irq_get_irq_data(virq
); data
; data
= data
->parent_data
) {
947 struct irq_domain
*domain
= data
->domain
;
948 irq_hw_number_t hwirq
= data
->hwirq
;
950 if (hwirq
< domain
->revmap_size
) {
951 domain
->linear_revmap
[hwirq
] = virq
;
953 mutex_lock(&revmap_trees_mutex
);
954 radix_tree_insert(&domain
->revmap_tree
, hwirq
, data
);
955 mutex_unlock(&revmap_trees_mutex
);
958 /* If not already assigned, give the domain the chip's name */
959 if (!domain
->name
&& data
->chip
)
960 domain
->name
= data
->chip
->name
;
963 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
966 static void irq_domain_remove_irq(int virq
)
968 struct irq_data
*data
;
970 irq_set_status_flags(virq
, IRQ_NOREQUEST
);
971 irq_set_chip_and_handler(virq
, NULL
, NULL
);
972 synchronize_irq(virq
);
975 for (data
= irq_get_irq_data(virq
); data
; data
= data
->parent_data
) {
976 struct irq_domain
*domain
= data
->domain
;
977 irq_hw_number_t hwirq
= data
->hwirq
;
979 if (hwirq
< domain
->revmap_size
) {
980 domain
->linear_revmap
[hwirq
] = 0;
982 mutex_lock(&revmap_trees_mutex
);
983 radix_tree_delete(&domain
->revmap_tree
, hwirq
);
984 mutex_unlock(&revmap_trees_mutex
);
989 static struct irq_data
*irq_domain_insert_irq_data(struct irq_domain
*domain
,
990 struct irq_data
*child
)
992 struct irq_data
*irq_data
;
994 irq_data
= kzalloc_node(sizeof(*irq_data
), GFP_KERNEL
,
995 irq_data_get_node(child
));
997 child
->parent_data
= irq_data
;
998 irq_data
->irq
= child
->irq
;
999 irq_data
->common
= child
->common
;
1000 irq_data
->domain
= domain
;
1006 static void irq_domain_free_irq_data(unsigned int virq
, unsigned int nr_irqs
)
1008 struct irq_data
*irq_data
, *tmp
;
1011 for (i
= 0; i
< nr_irqs
; i
++) {
1012 irq_data
= irq_get_irq_data(virq
+ i
);
1013 tmp
= irq_data
->parent_data
;
1014 irq_data
->parent_data
= NULL
;
1015 irq_data
->domain
= NULL
;
1019 tmp
= tmp
->parent_data
;
1025 static int irq_domain_alloc_irq_data(struct irq_domain
*domain
,
1026 unsigned int virq
, unsigned int nr_irqs
)
1028 struct irq_data
*irq_data
;
1029 struct irq_domain
*parent
;
1032 /* The outermost irq_data is embedded in struct irq_desc */
1033 for (i
= 0; i
< nr_irqs
; i
++) {
1034 irq_data
= irq_get_irq_data(virq
+ i
);
1035 irq_data
->domain
= domain
;
1037 for (parent
= domain
->parent
; parent
; parent
= parent
->parent
) {
1038 irq_data
= irq_domain_insert_irq_data(parent
, irq_data
);
1040 irq_domain_free_irq_data(virq
, i
+ 1);
1050 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1051 * @domain: domain to match
1052 * @virq: IRQ number to get irq_data
1054 struct irq_data
*irq_domain_get_irq_data(struct irq_domain
*domain
,
1057 struct irq_data
*irq_data
;
1059 for (irq_data
= irq_get_irq_data(virq
); irq_data
;
1060 irq_data
= irq_data
->parent_data
)
1061 if (irq_data
->domain
== domain
)
1066 EXPORT_SYMBOL_GPL(irq_domain_get_irq_data
);
1069 * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
1070 * @domain: Interrupt domain to match
1072 * @hwirq: The hwirq number
1073 * @chip: The associated interrupt chip
1074 * @chip_data: The associated chip data
1076 int irq_domain_set_hwirq_and_chip(struct irq_domain
*domain
, unsigned int virq
,
1077 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1080 struct irq_data
*irq_data
= irq_domain_get_irq_data(domain
, virq
);
1085 irq_data
->hwirq
= hwirq
;
1086 irq_data
->chip
= chip
? chip
: &no_irq_chip
;
1087 irq_data
->chip_data
= chip_data
;
1091 EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip
);
1094 * irq_domain_set_info - Set the complete data for a @virq in @domain
1095 * @domain: Interrupt domain to match
1097 * @hwirq: The hardware interrupt number
1098 * @chip: The associated interrupt chip
1099 * @chip_data: The associated interrupt chip data
1100 * @handler: The interrupt flow handler
1101 * @handler_data: The interrupt flow handler data
1102 * @handler_name: The interrupt handler name
1104 void irq_domain_set_info(struct irq_domain
*domain
, unsigned int virq
,
1105 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1106 void *chip_data
, irq_flow_handler_t handler
,
1107 void *handler_data
, const char *handler_name
)
1109 irq_domain_set_hwirq_and_chip(domain
, virq
, hwirq
, chip
, chip_data
);
1110 __irq_set_handler(virq
, handler
, 0, handler_name
);
1111 irq_set_handler_data(virq
, handler_data
);
1113 EXPORT_SYMBOL(irq_domain_set_info
);
1116 * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
1117 * @irq_data: The pointer to irq_data
1119 void irq_domain_reset_irq_data(struct irq_data
*irq_data
)
1121 irq_data
->hwirq
= 0;
1122 irq_data
->chip
= &no_irq_chip
;
1123 irq_data
->chip_data
= NULL
;
1125 EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data
);
1128 * irq_domain_free_irqs_common - Clear irq_data and free the parent
1129 * @domain: Interrupt domain to match
1130 * @virq: IRQ number to start with
1131 * @nr_irqs: The number of irqs to free
1133 void irq_domain_free_irqs_common(struct irq_domain
*domain
, unsigned int virq
,
1134 unsigned int nr_irqs
)
1136 struct irq_data
*irq_data
;
1139 for (i
= 0; i
< nr_irqs
; i
++) {
1140 irq_data
= irq_domain_get_irq_data(domain
, virq
+ i
);
1142 irq_domain_reset_irq_data(irq_data
);
1144 irq_domain_free_irqs_parent(domain
, virq
, nr_irqs
);
1146 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common
);
1149 * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
1150 * @domain: Interrupt domain to match
1151 * @virq: IRQ number to start with
1152 * @nr_irqs: The number of irqs to free
1154 void irq_domain_free_irqs_top(struct irq_domain
*domain
, unsigned int virq
,
1155 unsigned int nr_irqs
)
1159 for (i
= 0; i
< nr_irqs
; i
++) {
1160 irq_set_handler_data(virq
+ i
, NULL
);
1161 irq_set_handler(virq
+ i
, NULL
);
1163 irq_domain_free_irqs_common(domain
, virq
, nr_irqs
);
1166 static bool irq_domain_is_auto_recursive(struct irq_domain
*domain
)
1168 return domain
->flags
& IRQ_DOMAIN_FLAG_AUTO_RECURSIVE
;
1171 static void irq_domain_free_irqs_recursive(struct irq_domain
*domain
,
1172 unsigned int irq_base
,
1173 unsigned int nr_irqs
)
1175 domain
->ops
->free(domain
, irq_base
, nr_irqs
);
1176 if (irq_domain_is_auto_recursive(domain
)) {
1177 BUG_ON(!domain
->parent
);
1178 irq_domain_free_irqs_recursive(domain
->parent
, irq_base
,
1183 int irq_domain_alloc_irqs_recursive(struct irq_domain
*domain
,
1184 unsigned int irq_base
,
1185 unsigned int nr_irqs
, void *arg
)
1188 struct irq_domain
*parent
= domain
->parent
;
1189 bool recursive
= irq_domain_is_auto_recursive(domain
);
1191 BUG_ON(recursive
&& !parent
);
1193 ret
= irq_domain_alloc_irqs_recursive(parent
, irq_base
,
1198 ret
= domain
->ops
->alloc(domain
, irq_base
, nr_irqs
, arg
);
1199 if (ret
< 0 && recursive
)
1200 irq_domain_free_irqs_recursive(parent
, irq_base
, nr_irqs
);
1206 * __irq_domain_alloc_irqs - Allocate IRQs from domain
1207 * @domain: domain to allocate from
1208 * @irq_base: allocate specified IRQ nubmer if irq_base >= 0
1209 * @nr_irqs: number of IRQs to allocate
1210 * @node: NUMA node id for memory allocation
1211 * @arg: domain specific argument
1212 * @realloc: IRQ descriptors have already been allocated if true
1213 * @affinity: Optional irq affinity mask for multiqueue devices
1215 * Allocate IRQ numbers and initialized all data structures to support
1216 * hierarchy IRQ domains.
1217 * Parameter @realloc is mainly to support legacy IRQs.
1218 * Returns error code or allocated IRQ number
1220 * The whole process to setup an IRQ has been split into two steps.
1221 * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
1222 * descriptor and required hardware resources. The second step,
1223 * irq_domain_activate_irq(), is to program hardwares with preallocated
1224 * resources. In this way, it's easier to rollback when failing to
1225 * allocate resources.
1227 int __irq_domain_alloc_irqs(struct irq_domain
*domain
, int irq_base
,
1228 unsigned int nr_irqs
, int node
, void *arg
,
1229 bool realloc
, const struct cpumask
*affinity
)
1233 if (domain
== NULL
) {
1234 domain
= irq_default_domain
;
1235 if (WARN(!domain
, "domain is NULL; cannot allocate IRQ\n"))
1239 if (!domain
->ops
->alloc
) {
1240 pr_debug("domain->ops->alloc() is NULL\n");
1244 if (realloc
&& irq_base
>= 0) {
1247 virq
= irq_domain_alloc_descs(irq_base
, nr_irqs
, 0, node
,
1250 pr_debug("cannot allocate IRQ(base %d, count %d)\n",
1256 if (irq_domain_alloc_irq_data(domain
, virq
, nr_irqs
)) {
1257 pr_debug("cannot allocate memory for IRQ%d\n", virq
);
1262 mutex_lock(&irq_domain_mutex
);
1263 ret
= irq_domain_alloc_irqs_recursive(domain
, virq
, nr_irqs
, arg
);
1265 mutex_unlock(&irq_domain_mutex
);
1266 goto out_free_irq_data
;
1268 for (i
= 0; i
< nr_irqs
; i
++)
1269 irq_domain_insert_irq(virq
+ i
);
1270 mutex_unlock(&irq_domain_mutex
);
1275 irq_domain_free_irq_data(virq
, nr_irqs
);
1277 irq_free_descs(virq
, nr_irqs
);
1282 * irq_domain_free_irqs - Free IRQ number and associated data structures
1283 * @virq: base IRQ number
1284 * @nr_irqs: number of IRQs to free
1286 void irq_domain_free_irqs(unsigned int virq
, unsigned int nr_irqs
)
1288 struct irq_data
*data
= irq_get_irq_data(virq
);
1291 if (WARN(!data
|| !data
->domain
|| !data
->domain
->ops
->free
,
1292 "NULL pointer, cannot free irq\n"))
1295 mutex_lock(&irq_domain_mutex
);
1296 for (i
= 0; i
< nr_irqs
; i
++)
1297 irq_domain_remove_irq(virq
+ i
);
1298 irq_domain_free_irqs_recursive(data
->domain
, virq
, nr_irqs
);
1299 mutex_unlock(&irq_domain_mutex
);
1301 irq_domain_free_irq_data(virq
, nr_irqs
);
1302 irq_free_descs(virq
, nr_irqs
);
1306 * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
1307 * @irq_base: Base IRQ number
1308 * @nr_irqs: Number of IRQs to allocate
1309 * @arg: Allocation data (arch/domain specific)
1311 * Check whether the domain has been setup recursive. If not allocate
1312 * through the parent domain.
1314 int irq_domain_alloc_irqs_parent(struct irq_domain
*domain
,
1315 unsigned int irq_base
, unsigned int nr_irqs
,
1318 /* irq_domain_alloc_irqs_recursive() has called parent's alloc() */
1319 if (irq_domain_is_auto_recursive(domain
))
1322 domain
= domain
->parent
;
1324 return irq_domain_alloc_irqs_recursive(domain
, irq_base
,
1328 EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent
);
1331 * irq_domain_free_irqs_parent - Free interrupts from parent domain
1332 * @irq_base: Base IRQ number
1333 * @nr_irqs: Number of IRQs to free
1335 * Check whether the domain has been setup recursive. If not free
1336 * through the parent domain.
1338 void irq_domain_free_irqs_parent(struct irq_domain
*domain
,
1339 unsigned int irq_base
, unsigned int nr_irqs
)
1341 /* irq_domain_free_irqs_recursive() will call parent's free */
1342 if (!irq_domain_is_auto_recursive(domain
) && domain
->parent
)
1343 irq_domain_free_irqs_recursive(domain
->parent
, irq_base
,
1346 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent
);
1349 * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
1351 * @irq_data: outermost irq_data associated with interrupt
1353 * This is the second step to call domain_ops->activate to program interrupt
1354 * controllers, so the interrupt could actually get delivered.
1356 void irq_domain_activate_irq(struct irq_data
*irq_data
)
1358 if (irq_data
&& irq_data
->domain
) {
1359 struct irq_domain
*domain
= irq_data
->domain
;
1361 if (irq_data
->parent_data
)
1362 irq_domain_activate_irq(irq_data
->parent_data
);
1363 if (domain
->ops
->activate
)
1364 domain
->ops
->activate(domain
, irq_data
);
1369 * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
1370 * deactivate interrupt
1371 * @irq_data: outermost irq_data associated with interrupt
1373 * It calls domain_ops->deactivate to program interrupt controllers to disable
1374 * interrupt delivery.
1376 void irq_domain_deactivate_irq(struct irq_data
*irq_data
)
1378 if (irq_data
&& irq_data
->domain
) {
1379 struct irq_domain
*domain
= irq_data
->domain
;
1381 if (domain
->ops
->deactivate
)
1382 domain
->ops
->deactivate(domain
, irq_data
);
1383 if (irq_data
->parent_data
)
1384 irq_domain_deactivate_irq(irq_data
->parent_data
);
1388 static void irq_domain_check_hierarchy(struct irq_domain
*domain
)
1390 /* Hierarchy irq_domains must implement callback alloc() */
1391 if (domain
->ops
->alloc
)
1392 domain
->flags
|= IRQ_DOMAIN_FLAG_HIERARCHY
;
1394 #else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1396 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1397 * @domain: domain to match
1398 * @virq: IRQ number to get irq_data
1400 struct irq_data
*irq_domain_get_irq_data(struct irq_domain
*domain
,
1403 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
1405 return (irq_data
&& irq_data
->domain
== domain
) ? irq_data
: NULL
;
1407 EXPORT_SYMBOL_GPL(irq_domain_get_irq_data
);
1410 * irq_domain_set_info - Set the complete data for a @virq in @domain
1411 * @domain: Interrupt domain to match
1413 * @hwirq: The hardware interrupt number
1414 * @chip: The associated interrupt chip
1415 * @chip_data: The associated interrupt chip data
1416 * @handler: The interrupt flow handler
1417 * @handler_data: The interrupt flow handler data
1418 * @handler_name: The interrupt handler name
1420 void irq_domain_set_info(struct irq_domain
*domain
, unsigned int virq
,
1421 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1422 void *chip_data
, irq_flow_handler_t handler
,
1423 void *handler_data
, const char *handler_name
)
1425 irq_set_chip_and_handler_name(virq
, chip
, handler
, handler_name
);
1426 irq_set_chip_data(virq
, chip_data
);
1427 irq_set_handler_data(virq
, handler_data
);
1430 static void irq_domain_check_hierarchy(struct irq_domain
*domain
)
1433 #endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */