1 // SPDX-License-Identifier: GPL-2.0
3 #define pr_fmt(fmt) "irq: " fmt
5 #include <linux/acpi.h>
6 #include <linux/debugfs.h>
7 #include <linux/hardirq.h>
8 #include <linux/interrupt.h>
10 #include <linux/irqdesc.h>
11 #include <linux/irqdomain.h>
12 #include <linux/module.h>
13 #include <linux/mutex.h>
15 #include <linux/of_address.h>
16 #include <linux/of_irq.h>
17 #include <linux/topology.h>
18 #include <linux/seq_file.h>
19 #include <linux/slab.h>
20 #include <linux/smp.h>
23 static LIST_HEAD(irq_domain_list
);
24 static DEFINE_MUTEX(irq_domain_mutex
);
26 static struct irq_domain
*irq_default_domain
;
28 static void irq_domain_check_hierarchy(struct irq_domain
*domain
);
31 struct fwnode_handle fwnode
;
37 #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
38 static void debugfs_add_domain_dir(struct irq_domain
*d
);
39 static void debugfs_remove_domain_dir(struct irq_domain
*d
);
41 static inline void debugfs_add_domain_dir(struct irq_domain
*d
) { }
42 static inline void debugfs_remove_domain_dir(struct irq_domain
*d
) { }
45 static const char *irqchip_fwnode_get_name(const struct fwnode_handle
*fwnode
)
47 struct irqchip_fwid
*fwid
= container_of(fwnode
, struct irqchip_fwid
, fwnode
);
52 const struct fwnode_operations irqchip_fwnode_ops
= {
53 .get_name
= irqchip_fwnode_get_name
,
55 EXPORT_SYMBOL_GPL(irqchip_fwnode_ops
);
58 * __irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for
59 * identifying an irq domain
60 * @type: Type of irqchip_fwnode. See linux/irqdomain.h
61 * @id: Optional user provided id if name != NULL
62 * @name: Optional user provided domain name
63 * @pa: Optional user-provided physical address
65 * Allocate a struct irqchip_fwid, and return a pointer to the embedded
66 * fwnode_handle (or NULL on failure).
68 * Note: The types IRQCHIP_FWNODE_NAMED and IRQCHIP_FWNODE_NAMED_ID are
69 * solely to transport name information to irqdomain creation code. The
70 * node is not stored. For other types the pointer is kept in the irq
73 struct fwnode_handle
*__irq_domain_alloc_fwnode(unsigned int type
, int id
,
77 struct irqchip_fwid
*fwid
;
80 fwid
= kzalloc(sizeof(*fwid
), GFP_KERNEL
);
83 case IRQCHIP_FWNODE_NAMED
:
84 n
= kasprintf(GFP_KERNEL
, "%s", name
);
86 case IRQCHIP_FWNODE_NAMED_ID
:
87 n
= kasprintf(GFP_KERNEL
, "%s-%d", name
, id
);
90 n
= kasprintf(GFP_KERNEL
, "irqchip@%pa", pa
);
103 fwnode_init(&fwid
->fwnode
, &irqchip_fwnode_ops
);
104 return &fwid
->fwnode
;
106 EXPORT_SYMBOL_GPL(__irq_domain_alloc_fwnode
);
109 * irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle
111 * Free a fwnode_handle allocated with irq_domain_alloc_fwnode.
113 void irq_domain_free_fwnode(struct fwnode_handle
*fwnode
)
115 struct irqchip_fwid
*fwid
;
117 if (WARN_ON(!is_fwnode_irqchip(fwnode
)))
120 fwid
= container_of(fwnode
, struct irqchip_fwid
, fwnode
);
124 EXPORT_SYMBOL_GPL(irq_domain_free_fwnode
);
127 * __irq_domain_add() - Allocate a new irq_domain data structure
128 * @fwnode: firmware node for the interrupt controller
129 * @size: Size of linear map; 0 for radix mapping only
130 * @hwirq_max: Maximum number of interrupts supported by controller
131 * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
133 * @ops: domain callbacks
134 * @host_data: Controller private data pointer
136 * Allocates and initializes an irq_domain structure.
137 * Returns pointer to IRQ domain, or NULL on failure.
139 struct irq_domain
*__irq_domain_add(struct fwnode_handle
*fwnode
, unsigned int size
,
140 irq_hw_number_t hwirq_max
, int direct_max
,
141 const struct irq_domain_ops
*ops
,
144 struct irqchip_fwid
*fwid
;
145 struct irq_domain
*domain
;
147 static atomic_t unknown_domains
;
149 if (WARN_ON((size
&& direct_max
) ||
150 (!IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP
) && direct_max
)))
153 domain
= kzalloc_node(struct_size(domain
, revmap
, size
),
154 GFP_KERNEL
, of_node_to_nid(to_of_node(fwnode
)));
158 if (is_fwnode_irqchip(fwnode
)) {
159 fwid
= container_of(fwnode
, struct irqchip_fwid
, fwnode
);
161 switch (fwid
->type
) {
162 case IRQCHIP_FWNODE_NAMED
:
163 case IRQCHIP_FWNODE_NAMED_ID
:
164 domain
->fwnode
= fwnode
;
165 domain
->name
= kstrdup(fwid
->name
, GFP_KERNEL
);
170 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
173 domain
->fwnode
= fwnode
;
174 domain
->name
= fwid
->name
;
177 } else if (is_of_node(fwnode
) || is_acpi_device_node(fwnode
) ||
178 is_software_node(fwnode
)) {
182 * fwnode paths contain '/', which debugfs is legitimately
183 * unhappy about. Replace them with ':', which does
184 * the trick and is not as offensive as '\'...
186 name
= kasprintf(GFP_KERNEL
, "%pfw", fwnode
);
192 strreplace(name
, '/', ':');
195 domain
->fwnode
= fwnode
;
196 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
201 pr_err("Invalid fwnode type for irqdomain\n");
202 domain
->name
= kasprintf(GFP_KERNEL
, "unknown-%d",
203 atomic_inc_return(&unknown_domains
));
208 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
211 fwnode_handle_get(fwnode
);
212 fwnode_dev_initialized(fwnode
, true);
215 INIT_RADIX_TREE(&domain
->revmap_tree
, GFP_KERNEL
);
216 mutex_init(&domain
->revmap_mutex
);
218 domain
->host_data
= host_data
;
219 domain
->hwirq_max
= hwirq_max
;
223 domain
->flags
|= IRQ_DOMAIN_FLAG_NO_MAP
;
226 domain
->revmap_size
= size
;
228 irq_domain_check_hierarchy(domain
);
230 mutex_lock(&irq_domain_mutex
);
231 debugfs_add_domain_dir(domain
);
232 list_add(&domain
->link
, &irq_domain_list
);
233 mutex_unlock(&irq_domain_mutex
);
235 pr_debug("Added domain %s\n", domain
->name
);
238 EXPORT_SYMBOL_GPL(__irq_domain_add
);
241 * irq_domain_remove() - Remove an irq domain.
242 * @domain: domain to remove
244 * This routine is used to remove an irq domain. The caller must ensure
245 * that all mappings within the domain have been disposed of prior to
246 * use, depending on the revmap type.
248 void irq_domain_remove(struct irq_domain
*domain
)
250 mutex_lock(&irq_domain_mutex
);
251 debugfs_remove_domain_dir(domain
);
253 WARN_ON(!radix_tree_empty(&domain
->revmap_tree
));
255 list_del(&domain
->link
);
258 * If the going away domain is the default one, reset it.
260 if (unlikely(irq_default_domain
== domain
))
261 irq_set_default_host(NULL
);
263 mutex_unlock(&irq_domain_mutex
);
265 pr_debug("Removed domain %s\n", domain
->name
);
267 fwnode_dev_initialized(domain
->fwnode
, false);
268 fwnode_handle_put(domain
->fwnode
);
269 if (domain
->flags
& IRQ_DOMAIN_NAME_ALLOCATED
)
273 EXPORT_SYMBOL_GPL(irq_domain_remove
);
275 void irq_domain_update_bus_token(struct irq_domain
*domain
,
276 enum irq_domain_bus_token bus_token
)
280 if (domain
->bus_token
== bus_token
)
283 mutex_lock(&irq_domain_mutex
);
285 domain
->bus_token
= bus_token
;
287 name
= kasprintf(GFP_KERNEL
, "%s-%d", domain
->name
, bus_token
);
289 mutex_unlock(&irq_domain_mutex
);
293 debugfs_remove_domain_dir(domain
);
295 if (domain
->flags
& IRQ_DOMAIN_NAME_ALLOCATED
)
298 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
301 debugfs_add_domain_dir(domain
);
303 mutex_unlock(&irq_domain_mutex
);
305 EXPORT_SYMBOL_GPL(irq_domain_update_bus_token
);
308 * irq_domain_create_simple() - Register an irq_domain and optionally map a range of irqs
309 * @fwnode: firmware node for the interrupt controller
310 * @size: total number of irqs in mapping
311 * @first_irq: first number of irq block assigned to the domain,
312 * pass zero to assign irqs on-the-fly. If first_irq is non-zero, then
313 * pre-map all of the irqs in the domain to virqs starting at first_irq.
314 * @ops: domain callbacks
315 * @host_data: Controller private data pointer
317 * Allocates an irq_domain, and optionally if first_irq is positive then also
318 * allocate irq_descs and map all of the hwirqs to virqs starting at first_irq.
320 * This is intended to implement the expected behaviour for most
321 * interrupt controllers. If device tree is used, then first_irq will be 0 and
322 * irqs get mapped dynamically on the fly. However, if the controller requires
323 * static virq assignments (non-DT boot) then it will set that up correctly.
325 struct irq_domain
*irq_domain_create_simple(struct fwnode_handle
*fwnode
,
327 unsigned int first_irq
,
328 const struct irq_domain_ops
*ops
,
331 struct irq_domain
*domain
;
333 domain
= __irq_domain_add(fwnode
, size
, size
, 0, ops
, host_data
);
338 if (IS_ENABLED(CONFIG_SPARSE_IRQ
)) {
339 /* attempt to allocated irq_descs */
340 int rc
= irq_alloc_descs(first_irq
, first_irq
, size
,
341 of_node_to_nid(to_of_node(fwnode
)));
343 pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
346 irq_domain_associate_many(domain
, first_irq
, 0, size
);
351 EXPORT_SYMBOL_GPL(irq_domain_create_simple
);
354 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
355 * @of_node: pointer to interrupt controller's device tree node.
356 * @size: total number of irqs in legacy mapping
357 * @first_irq: first number of irq block assigned to the domain
358 * @first_hwirq: first hwirq number to use for the translation. Should normally
359 * be '0', but a positive integer can be used if the effective
360 * hwirqs numbering does not begin at zero.
361 * @ops: map/unmap domain callbacks
362 * @host_data: Controller private data pointer
364 * Note: the map() callback will be called before this function returns
365 * for all legacy interrupts except 0 (which is always the invalid irq for
366 * a legacy controller).
368 struct irq_domain
*irq_domain_add_legacy(struct device_node
*of_node
,
370 unsigned int first_irq
,
371 irq_hw_number_t first_hwirq
,
372 const struct irq_domain_ops
*ops
,
375 return irq_domain_create_legacy(of_node_to_fwnode(of_node
), size
,
376 first_irq
, first_hwirq
, ops
, host_data
);
378 EXPORT_SYMBOL_GPL(irq_domain_add_legacy
);
380 struct irq_domain
*irq_domain_create_legacy(struct fwnode_handle
*fwnode
,
382 unsigned int first_irq
,
383 irq_hw_number_t first_hwirq
,
384 const struct irq_domain_ops
*ops
,
387 struct irq_domain
*domain
;
389 domain
= __irq_domain_add(fwnode
, first_hwirq
+ size
, first_hwirq
+ size
, 0, ops
, host_data
);
391 irq_domain_associate_many(domain
, first_irq
, first_hwirq
, size
);
395 EXPORT_SYMBOL_GPL(irq_domain_create_legacy
);
398 * irq_find_matching_fwspec() - Locates a domain for a given fwspec
399 * @fwspec: FW specifier for an interrupt
400 * @bus_token: domain-specific data
402 struct irq_domain
*irq_find_matching_fwspec(struct irq_fwspec
*fwspec
,
403 enum irq_domain_bus_token bus_token
)
405 struct irq_domain
*h
, *found
= NULL
;
406 struct fwnode_handle
*fwnode
= fwspec
->fwnode
;
409 /* We might want to match the legacy controller last since
410 * it might potentially be set to match all interrupts in
411 * the absence of a device node. This isn't a problem so far
414 * bus_token == DOMAIN_BUS_ANY matches any domain, any other
415 * values must generate an exact match for the domain to be
418 mutex_lock(&irq_domain_mutex
);
419 list_for_each_entry(h
, &irq_domain_list
, link
) {
420 if (h
->ops
->select
&& fwspec
->param_count
)
421 rc
= h
->ops
->select(h
, fwspec
, bus_token
);
422 else if (h
->ops
->match
)
423 rc
= h
->ops
->match(h
, to_of_node(fwnode
), bus_token
);
425 rc
= ((fwnode
!= NULL
) && (h
->fwnode
== fwnode
) &&
426 ((bus_token
== DOMAIN_BUS_ANY
) ||
427 (h
->bus_token
== bus_token
)));
434 mutex_unlock(&irq_domain_mutex
);
437 EXPORT_SYMBOL_GPL(irq_find_matching_fwspec
);
440 * irq_domain_check_msi_remap - Check whether all MSI irq domains implement
443 * Return: false if any MSI irq domain does not support IRQ remapping,
444 * true otherwise (including if there is no MSI irq domain)
446 bool irq_domain_check_msi_remap(void)
448 struct irq_domain
*h
;
451 mutex_lock(&irq_domain_mutex
);
452 list_for_each_entry(h
, &irq_domain_list
, link
) {
453 if (irq_domain_is_msi(h
) &&
454 !irq_domain_hierarchical_is_msi_remap(h
)) {
459 mutex_unlock(&irq_domain_mutex
);
462 EXPORT_SYMBOL_GPL(irq_domain_check_msi_remap
);
465 * irq_set_default_host() - Set a "default" irq domain
466 * @domain: default domain pointer
468 * For convenience, it's possible to set a "default" domain that will be used
469 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
470 * platforms that want to manipulate a few hard coded interrupt numbers that
471 * aren't properly represented in the device-tree.
473 void irq_set_default_host(struct irq_domain
*domain
)
475 pr_debug("Default domain set to @0x%p\n", domain
);
477 irq_default_domain
= domain
;
479 EXPORT_SYMBOL_GPL(irq_set_default_host
);
482 * irq_get_default_host() - Retrieve the "default" irq domain
484 * Returns: the default domain, if any.
486 * Modern code should never use this. This should only be used on
487 * systems that cannot implement a firmware->fwnode mapping (which
488 * both DT and ACPI provide).
490 struct irq_domain
*irq_get_default_host(void)
492 return irq_default_domain
;
494 EXPORT_SYMBOL_GPL(irq_get_default_host
);
496 static bool irq_domain_is_nomap(struct irq_domain
*domain
)
498 return IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP
) &&
499 (domain
->flags
& IRQ_DOMAIN_FLAG_NO_MAP
);
502 static void irq_domain_clear_mapping(struct irq_domain
*domain
,
503 irq_hw_number_t hwirq
)
505 if (irq_domain_is_nomap(domain
))
508 mutex_lock(&domain
->revmap_mutex
);
509 if (hwirq
< domain
->revmap_size
)
510 rcu_assign_pointer(domain
->revmap
[hwirq
], NULL
);
512 radix_tree_delete(&domain
->revmap_tree
, hwirq
);
513 mutex_unlock(&domain
->revmap_mutex
);
516 static void irq_domain_set_mapping(struct irq_domain
*domain
,
517 irq_hw_number_t hwirq
,
518 struct irq_data
*irq_data
)
520 if (irq_domain_is_nomap(domain
))
523 mutex_lock(&domain
->revmap_mutex
);
524 if (hwirq
< domain
->revmap_size
)
525 rcu_assign_pointer(domain
->revmap
[hwirq
], irq_data
);
527 radix_tree_insert(&domain
->revmap_tree
, hwirq
, irq_data
);
528 mutex_unlock(&domain
->revmap_mutex
);
531 static void irq_domain_disassociate(struct irq_domain
*domain
, unsigned int irq
)
533 struct irq_data
*irq_data
= irq_get_irq_data(irq
);
534 irq_hw_number_t hwirq
;
536 if (WARN(!irq_data
|| irq_data
->domain
!= domain
,
537 "virq%i doesn't exist; cannot disassociate\n", irq
))
540 hwirq
= irq_data
->hwirq
;
541 irq_set_status_flags(irq
, IRQ_NOREQUEST
);
543 /* remove chip and handler */
544 irq_set_chip_and_handler(irq
, NULL
, NULL
);
546 /* Make sure it's completed */
547 synchronize_irq(irq
);
549 /* Tell the PIC about it */
550 if (domain
->ops
->unmap
)
551 domain
->ops
->unmap(domain
, irq
);
554 irq_data
->domain
= NULL
;
558 /* Clear reverse map for this hwirq */
559 irq_domain_clear_mapping(domain
, hwirq
);
562 int irq_domain_associate(struct irq_domain
*domain
, unsigned int virq
,
563 irq_hw_number_t hwirq
)
565 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
568 if (WARN(hwirq
>= domain
->hwirq_max
,
569 "error: hwirq 0x%x is too large for %s\n", (int)hwirq
, domain
->name
))
571 if (WARN(!irq_data
, "error: virq%i is not allocated", virq
))
573 if (WARN(irq_data
->domain
, "error: virq%i is already associated", virq
))
576 mutex_lock(&irq_domain_mutex
);
577 irq_data
->hwirq
= hwirq
;
578 irq_data
->domain
= domain
;
579 if (domain
->ops
->map
) {
580 ret
= domain
->ops
->map(domain
, virq
, hwirq
);
583 * If map() returns -EPERM, this interrupt is protected
584 * by the firmware or some other service and shall not
585 * be mapped. Don't bother telling the user about it.
588 pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
589 domain
->name
, hwirq
, virq
, ret
);
591 irq_data
->domain
= NULL
;
593 mutex_unlock(&irq_domain_mutex
);
597 /* If not already assigned, give the domain the chip's name */
598 if (!domain
->name
&& irq_data
->chip
)
599 domain
->name
= irq_data
->chip
->name
;
603 irq_domain_set_mapping(domain
, hwirq
, irq_data
);
604 mutex_unlock(&irq_domain_mutex
);
606 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
610 EXPORT_SYMBOL_GPL(irq_domain_associate
);
612 void irq_domain_associate_many(struct irq_domain
*domain
, unsigned int irq_base
,
613 irq_hw_number_t hwirq_base
, int count
)
615 struct device_node
*of_node
;
618 of_node
= irq_domain_get_of_node(domain
);
619 pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__
,
620 of_node_full_name(of_node
), irq_base
, (int)hwirq_base
, count
);
622 for (i
= 0; i
< count
; i
++) {
623 irq_domain_associate(domain
, irq_base
+ i
, hwirq_base
+ i
);
626 EXPORT_SYMBOL_GPL(irq_domain_associate_many
);
628 #ifdef CONFIG_IRQ_DOMAIN_NOMAP
630 * irq_create_direct_mapping() - Allocate an irq for direct mapping
631 * @domain: domain to allocate the irq for or NULL for default domain
633 * This routine is used for irq controllers which can choose the hardware
634 * interrupt numbers they generate. In such a case it's simplest to use
635 * the linux irq as the hardware interrupt number. It still uses the linear
636 * or radix tree to store the mapping, but the irq controller can optimize
637 * the revmap path by using the hwirq directly.
639 unsigned int irq_create_direct_mapping(struct irq_domain
*domain
)
641 struct device_node
*of_node
;
645 domain
= irq_default_domain
;
647 of_node
= irq_domain_get_of_node(domain
);
648 virq
= irq_alloc_desc_from(1, of_node_to_nid(of_node
));
650 pr_debug("create_direct virq allocation failed\n");
653 if (virq
>= domain
->revmap_size
) {
654 pr_err("ERROR: no free irqs available below %i maximum\n",
655 domain
->revmap_size
);
659 pr_debug("create_direct obtained virq %d\n", virq
);
661 if (irq_domain_associate(domain
, virq
, virq
)) {
668 EXPORT_SYMBOL_GPL(irq_create_direct_mapping
);
672 * irq_create_mapping_affinity() - Map a hardware interrupt into linux irq space
673 * @domain: domain owning this hardware interrupt or NULL for default domain
674 * @hwirq: hardware irq number in that domain space
675 * @affinity: irq affinity
677 * Only one mapping per hardware interrupt is permitted. Returns a linux
679 * If the sense/trigger is to be specified, set_irq_type() should be called
680 * on the number returned from that call.
682 unsigned int irq_create_mapping_affinity(struct irq_domain
*domain
,
683 irq_hw_number_t hwirq
,
684 const struct irq_affinity_desc
*affinity
)
686 struct device_node
*of_node
;
689 pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain
, hwirq
);
691 /* Look for default domain if necessary */
693 domain
= irq_default_domain
;
694 if (domain
== NULL
) {
695 WARN(1, "%s(, %lx) called with NULL domain\n", __func__
, hwirq
);
698 pr_debug("-> using domain @%p\n", domain
);
700 of_node
= irq_domain_get_of_node(domain
);
702 /* Check if mapping already exists */
703 virq
= irq_find_mapping(domain
, hwirq
);
705 pr_debug("-> existing mapping on virq %d\n", virq
);
709 /* Allocate a virtual interrupt number */
710 virq
= irq_domain_alloc_descs(-1, 1, hwirq
, of_node_to_nid(of_node
),
713 pr_debug("-> virq allocation failed\n");
717 if (irq_domain_associate(domain
, virq
, hwirq
)) {
722 pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
723 hwirq
, of_node_full_name(of_node
), virq
);
727 EXPORT_SYMBOL_GPL(irq_create_mapping_affinity
);
729 static int irq_domain_translate(struct irq_domain
*d
,
730 struct irq_fwspec
*fwspec
,
731 irq_hw_number_t
*hwirq
, unsigned int *type
)
733 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
734 if (d
->ops
->translate
)
735 return d
->ops
->translate(d
, fwspec
, hwirq
, type
);
738 return d
->ops
->xlate(d
, to_of_node(fwspec
->fwnode
),
739 fwspec
->param
, fwspec
->param_count
,
742 /* If domain has no translation, then we assume interrupt line */
743 *hwirq
= fwspec
->param
[0];
747 static void of_phandle_args_to_fwspec(struct device_node
*np
, const u32
*args
,
749 struct irq_fwspec
*fwspec
)
753 fwspec
->fwnode
= of_node_to_fwnode(np
);
754 fwspec
->param_count
= count
;
756 for (i
= 0; i
< count
; i
++)
757 fwspec
->param
[i
] = args
[i
];
760 unsigned int irq_create_fwspec_mapping(struct irq_fwspec
*fwspec
)
762 struct irq_domain
*domain
;
763 struct irq_data
*irq_data
;
764 irq_hw_number_t hwirq
;
765 unsigned int type
= IRQ_TYPE_NONE
;
768 if (fwspec
->fwnode
) {
769 domain
= irq_find_matching_fwspec(fwspec
, DOMAIN_BUS_WIRED
);
771 domain
= irq_find_matching_fwspec(fwspec
, DOMAIN_BUS_ANY
);
773 domain
= irq_default_domain
;
777 pr_warn("no irq domain found for %s !\n",
778 of_node_full_name(to_of_node(fwspec
->fwnode
)));
782 if (irq_domain_translate(domain
, fwspec
, &hwirq
, &type
))
786 * WARN if the irqchip returns a type with bits
787 * outside the sense mask set and clear these bits.
789 if (WARN_ON(type
& ~IRQ_TYPE_SENSE_MASK
))
790 type
&= IRQ_TYPE_SENSE_MASK
;
793 * If we've already configured this interrupt,
794 * don't do it again, or hell will break loose.
796 virq
= irq_find_mapping(domain
, hwirq
);
799 * If the trigger type is not specified or matches the
800 * current trigger type then we are done so return the
803 if (type
== IRQ_TYPE_NONE
|| type
== irq_get_trigger_type(virq
))
807 * If the trigger type has not been set yet, then set
808 * it now and return the interrupt number.
810 if (irq_get_trigger_type(virq
) == IRQ_TYPE_NONE
) {
811 irq_data
= irq_get_irq_data(virq
);
815 irqd_set_trigger_type(irq_data
, type
);
819 pr_warn("type mismatch, failed to map hwirq-%lu for %s!\n",
820 hwirq
, of_node_full_name(to_of_node(fwspec
->fwnode
)));
824 if (irq_domain_is_hierarchy(domain
)) {
825 virq
= irq_domain_alloc_irqs(domain
, 1, NUMA_NO_NODE
, fwspec
);
830 virq
= irq_create_mapping(domain
, hwirq
);
835 irq_data
= irq_get_irq_data(virq
);
837 if (irq_domain_is_hierarchy(domain
))
838 irq_domain_free_irqs(virq
, 1);
840 irq_dispose_mapping(virq
);
844 /* Store trigger type */
845 irqd_set_trigger_type(irq_data
, type
);
849 EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping
);
851 unsigned int irq_create_of_mapping(struct of_phandle_args
*irq_data
)
853 struct irq_fwspec fwspec
;
855 of_phandle_args_to_fwspec(irq_data
->np
, irq_data
->args
,
856 irq_data
->args_count
, &fwspec
);
858 return irq_create_fwspec_mapping(&fwspec
);
860 EXPORT_SYMBOL_GPL(irq_create_of_mapping
);
863 * irq_dispose_mapping() - Unmap an interrupt
864 * @virq: linux irq number of the interrupt to unmap
866 void irq_dispose_mapping(unsigned int virq
)
868 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
869 struct irq_domain
*domain
;
871 if (!virq
|| !irq_data
)
874 domain
= irq_data
->domain
;
875 if (WARN_ON(domain
== NULL
))
878 if (irq_domain_is_hierarchy(domain
)) {
879 irq_domain_free_irqs(virq
, 1);
881 irq_domain_disassociate(domain
, virq
);
885 EXPORT_SYMBOL_GPL(irq_dispose_mapping
);
888 * __irq_resolve_mapping() - Find a linux irq from a hw irq number.
889 * @domain: domain owning this hardware interrupt
890 * @hwirq: hardware irq number in that domain space
891 * @irq: optional pointer to return the Linux irq if required
893 * Returns the interrupt descriptor.
895 struct irq_desc
*__irq_resolve_mapping(struct irq_domain
*domain
,
896 irq_hw_number_t hwirq
,
899 struct irq_desc
*desc
= NULL
;
900 struct irq_data
*data
;
902 /* Look for default domain if necessary */
904 domain
= irq_default_domain
;
908 if (irq_domain_is_nomap(domain
)) {
909 if (hwirq
< domain
->revmap_size
) {
910 data
= irq_domain_get_irq_data(domain
, hwirq
);
911 if (data
&& data
->hwirq
== hwirq
)
912 desc
= irq_data_to_desc(data
);
919 /* Check if the hwirq is in the linear revmap. */
920 if (hwirq
< domain
->revmap_size
)
921 data
= rcu_dereference(domain
->revmap
[hwirq
]);
923 data
= radix_tree_lookup(&domain
->revmap_tree
, hwirq
);
926 desc
= irq_data_to_desc(data
);
934 EXPORT_SYMBOL_GPL(__irq_resolve_mapping
);
937 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
939 * Device Tree IRQ specifier translation function which works with one cell
940 * bindings where the cell value maps directly to the hwirq number.
942 int irq_domain_xlate_onecell(struct irq_domain
*d
, struct device_node
*ctrlr
,
943 const u32
*intspec
, unsigned int intsize
,
944 unsigned long *out_hwirq
, unsigned int *out_type
)
946 if (WARN_ON(intsize
< 1))
948 *out_hwirq
= intspec
[0];
949 *out_type
= IRQ_TYPE_NONE
;
952 EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell
);
955 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
957 * Device Tree IRQ specifier translation function which works with two cell
958 * bindings where the cell values map directly to the hwirq number
959 * and linux irq flags.
961 int irq_domain_xlate_twocell(struct irq_domain
*d
, struct device_node
*ctrlr
,
962 const u32
*intspec
, unsigned int intsize
,
963 irq_hw_number_t
*out_hwirq
, unsigned int *out_type
)
965 struct irq_fwspec fwspec
;
967 of_phandle_args_to_fwspec(ctrlr
, intspec
, intsize
, &fwspec
);
968 return irq_domain_translate_twocell(d
, &fwspec
, out_hwirq
, out_type
);
970 EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell
);
973 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
975 * Device Tree IRQ specifier translation function which works with either one
976 * or two cell bindings where the cell values map directly to the hwirq number
977 * and linux irq flags.
979 * Note: don't use this function unless your interrupt controller explicitly
980 * supports both one and two cell bindings. For the majority of controllers
981 * the _onecell() or _twocell() variants above should be used.
983 int irq_domain_xlate_onetwocell(struct irq_domain
*d
,
984 struct device_node
*ctrlr
,
985 const u32
*intspec
, unsigned int intsize
,
986 unsigned long *out_hwirq
, unsigned int *out_type
)
988 if (WARN_ON(intsize
< 1))
990 *out_hwirq
= intspec
[0];
992 *out_type
= intspec
[1] & IRQ_TYPE_SENSE_MASK
;
994 *out_type
= IRQ_TYPE_NONE
;
997 EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell
);
999 const struct irq_domain_ops irq_domain_simple_ops
= {
1000 .xlate
= irq_domain_xlate_onetwocell
,
1002 EXPORT_SYMBOL_GPL(irq_domain_simple_ops
);
1005 * irq_domain_translate_onecell() - Generic translate for direct one cell
1008 int irq_domain_translate_onecell(struct irq_domain
*d
,
1009 struct irq_fwspec
*fwspec
,
1010 unsigned long *out_hwirq
,
1011 unsigned int *out_type
)
1013 if (WARN_ON(fwspec
->param_count
< 1))
1015 *out_hwirq
= fwspec
->param
[0];
1016 *out_type
= IRQ_TYPE_NONE
;
1019 EXPORT_SYMBOL_GPL(irq_domain_translate_onecell
);
1022 * irq_domain_translate_twocell() - Generic translate for direct two cell
1025 * Device Tree IRQ specifier translation function which works with two cell
1026 * bindings where the cell values map directly to the hwirq number
1027 * and linux irq flags.
1029 int irq_domain_translate_twocell(struct irq_domain
*d
,
1030 struct irq_fwspec
*fwspec
,
1031 unsigned long *out_hwirq
,
1032 unsigned int *out_type
)
1034 if (WARN_ON(fwspec
->param_count
< 2))
1036 *out_hwirq
= fwspec
->param
[0];
1037 *out_type
= fwspec
->param
[1] & IRQ_TYPE_SENSE_MASK
;
1040 EXPORT_SYMBOL_GPL(irq_domain_translate_twocell
);
1042 int irq_domain_alloc_descs(int virq
, unsigned int cnt
, irq_hw_number_t hwirq
,
1043 int node
, const struct irq_affinity_desc
*affinity
)
1048 virq
= __irq_alloc_descs(virq
, virq
, cnt
, node
, THIS_MODULE
,
1051 hint
= hwirq
% nr_irqs
;
1054 virq
= __irq_alloc_descs(-1, hint
, cnt
, node
, THIS_MODULE
,
1056 if (virq
<= 0 && hint
> 1) {
1057 virq
= __irq_alloc_descs(-1, 1, cnt
, node
, THIS_MODULE
,
1066 * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
1067 * @irq_data: The pointer to irq_data
1069 void irq_domain_reset_irq_data(struct irq_data
*irq_data
)
1071 irq_data
->hwirq
= 0;
1072 irq_data
->chip
= &no_irq_chip
;
1073 irq_data
->chip_data
= NULL
;
1075 EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data
);
1077 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1079 * irq_domain_create_hierarchy - Add a irqdomain into the hierarchy
1080 * @parent: Parent irq domain to associate with the new domain
1081 * @flags: Irq domain flags associated to the domain
1082 * @size: Size of the domain. See below
1083 * @fwnode: Optional fwnode of the interrupt controller
1084 * @ops: Pointer to the interrupt domain callbacks
1085 * @host_data: Controller private data pointer
1087 * If @size is 0 a tree domain is created, otherwise a linear domain.
1089 * If successful the parent is associated to the new domain and the
1090 * domain flags are set.
1091 * Returns pointer to IRQ domain, or NULL on failure.
1093 struct irq_domain
*irq_domain_create_hierarchy(struct irq_domain
*parent
,
1096 struct fwnode_handle
*fwnode
,
1097 const struct irq_domain_ops
*ops
,
1100 struct irq_domain
*domain
;
1103 domain
= irq_domain_create_linear(fwnode
, size
, ops
, host_data
);
1105 domain
= irq_domain_create_tree(fwnode
, ops
, host_data
);
1107 domain
->parent
= parent
;
1108 domain
->flags
|= flags
;
1113 EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy
);
1115 static void irq_domain_insert_irq(int virq
)
1117 struct irq_data
*data
;
1119 for (data
= irq_get_irq_data(virq
); data
; data
= data
->parent_data
) {
1120 struct irq_domain
*domain
= data
->domain
;
1123 irq_domain_set_mapping(domain
, data
->hwirq
, data
);
1125 /* If not already assigned, give the domain the chip's name */
1126 if (!domain
->name
&& data
->chip
)
1127 domain
->name
= data
->chip
->name
;
1130 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
1133 static void irq_domain_remove_irq(int virq
)
1135 struct irq_data
*data
;
1137 irq_set_status_flags(virq
, IRQ_NOREQUEST
);
1138 irq_set_chip_and_handler(virq
, NULL
, NULL
);
1139 synchronize_irq(virq
);
1142 for (data
= irq_get_irq_data(virq
); data
; data
= data
->parent_data
) {
1143 struct irq_domain
*domain
= data
->domain
;
1144 irq_hw_number_t hwirq
= data
->hwirq
;
1147 irq_domain_clear_mapping(domain
, hwirq
);
1151 static struct irq_data
*irq_domain_insert_irq_data(struct irq_domain
*domain
,
1152 struct irq_data
*child
)
1154 struct irq_data
*irq_data
;
1156 irq_data
= kzalloc_node(sizeof(*irq_data
), GFP_KERNEL
,
1157 irq_data_get_node(child
));
1159 child
->parent_data
= irq_data
;
1160 irq_data
->irq
= child
->irq
;
1161 irq_data
->common
= child
->common
;
1162 irq_data
->domain
= domain
;
1168 static void __irq_domain_free_hierarchy(struct irq_data
*irq_data
)
1170 struct irq_data
*tmp
;
1174 irq_data
= irq_data
->parent_data
;
1179 static void irq_domain_free_irq_data(unsigned int virq
, unsigned int nr_irqs
)
1181 struct irq_data
*irq_data
, *tmp
;
1184 for (i
= 0; i
< nr_irqs
; i
++) {
1185 irq_data
= irq_get_irq_data(virq
+ i
);
1186 tmp
= irq_data
->parent_data
;
1187 irq_data
->parent_data
= NULL
;
1188 irq_data
->domain
= NULL
;
1190 __irq_domain_free_hierarchy(tmp
);
1195 * irq_domain_disconnect_hierarchy - Mark the first unused level of a hierarchy
1196 * @domain: IRQ domain from which the hierarchy is to be disconnected
1197 * @virq: IRQ number where the hierarchy is to be trimmed
1199 * Marks the @virq level belonging to @domain as disconnected.
1200 * Returns -EINVAL if @virq doesn't have a valid irq_data pointing
1203 * Its only use is to be able to trim levels of hierarchy that do not
1204 * have any real meaning for this interrupt, and that the driver marks
1205 * as such from its .alloc() callback.
1207 int irq_domain_disconnect_hierarchy(struct irq_domain
*domain
,
1210 struct irq_data
*irqd
;
1212 irqd
= irq_domain_get_irq_data(domain
, virq
);
1216 irqd
->chip
= ERR_PTR(-ENOTCONN
);
1219 EXPORT_SYMBOL_GPL(irq_domain_disconnect_hierarchy
);
1221 static int irq_domain_trim_hierarchy(unsigned int virq
)
1223 struct irq_data
*tail
, *irqd
, *irq_data
;
1225 irq_data
= irq_get_irq_data(virq
);
1228 /* The first entry must have a valid irqchip */
1229 if (!irq_data
->chip
|| IS_ERR(irq_data
->chip
))
1233 * Validate that the irq_data chain is sane in the presence of
1234 * a hierarchy trimming marker.
1236 for (irqd
= irq_data
->parent_data
; irqd
; irq_data
= irqd
, irqd
= irqd
->parent_data
) {
1237 /* Can't have a valid irqchip after a trim marker */
1238 if (irqd
->chip
&& tail
)
1241 /* Can't have an empty irqchip before a trim marker */
1242 if (!irqd
->chip
&& !tail
)
1245 if (IS_ERR(irqd
->chip
)) {
1246 /* Only -ENOTCONN is a valid trim marker */
1247 if (PTR_ERR(irqd
->chip
) != -ENOTCONN
)
1254 /* No trim marker, nothing to do */
1258 pr_info("IRQ%d: trimming hierarchy from %s\n",
1259 virq
, tail
->parent_data
->domain
->name
);
1261 /* Sever the inner part of the hierarchy... */
1263 tail
= tail
->parent_data
;
1264 irqd
->parent_data
= NULL
;
1265 __irq_domain_free_hierarchy(tail
);
1270 static int irq_domain_alloc_irq_data(struct irq_domain
*domain
,
1271 unsigned int virq
, unsigned int nr_irqs
)
1273 struct irq_data
*irq_data
;
1274 struct irq_domain
*parent
;
1277 /* The outermost irq_data is embedded in struct irq_desc */
1278 for (i
= 0; i
< nr_irqs
; i
++) {
1279 irq_data
= irq_get_irq_data(virq
+ i
);
1280 irq_data
->domain
= domain
;
1282 for (parent
= domain
->parent
; parent
; parent
= parent
->parent
) {
1283 irq_data
= irq_domain_insert_irq_data(parent
, irq_data
);
1285 irq_domain_free_irq_data(virq
, i
+ 1);
1295 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1296 * @domain: domain to match
1297 * @virq: IRQ number to get irq_data
1299 struct irq_data
*irq_domain_get_irq_data(struct irq_domain
*domain
,
1302 struct irq_data
*irq_data
;
1304 for (irq_data
= irq_get_irq_data(virq
); irq_data
;
1305 irq_data
= irq_data
->parent_data
)
1306 if (irq_data
->domain
== domain
)
1311 EXPORT_SYMBOL_GPL(irq_domain_get_irq_data
);
1314 * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
1315 * @domain: Interrupt domain to match
1317 * @hwirq: The hwirq number
1318 * @chip: The associated interrupt chip
1319 * @chip_data: The associated chip data
1321 int irq_domain_set_hwirq_and_chip(struct irq_domain
*domain
, unsigned int virq
,
1322 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1325 struct irq_data
*irq_data
= irq_domain_get_irq_data(domain
, virq
);
1330 irq_data
->hwirq
= hwirq
;
1331 irq_data
->chip
= chip
? chip
: &no_irq_chip
;
1332 irq_data
->chip_data
= chip_data
;
1336 EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip
);
1339 * irq_domain_set_info - Set the complete data for a @virq in @domain
1340 * @domain: Interrupt domain to match
1342 * @hwirq: The hardware interrupt number
1343 * @chip: The associated interrupt chip
1344 * @chip_data: The associated interrupt chip data
1345 * @handler: The interrupt flow handler
1346 * @handler_data: The interrupt flow handler data
1347 * @handler_name: The interrupt handler name
1349 void irq_domain_set_info(struct irq_domain
*domain
, unsigned int virq
,
1350 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1351 void *chip_data
, irq_flow_handler_t handler
,
1352 void *handler_data
, const char *handler_name
)
1354 irq_domain_set_hwirq_and_chip(domain
, virq
, hwirq
, chip
, chip_data
);
1355 __irq_set_handler(virq
, handler
, 0, handler_name
);
1356 irq_set_handler_data(virq
, handler_data
);
1358 EXPORT_SYMBOL(irq_domain_set_info
);
1361 * irq_domain_free_irqs_common - Clear irq_data and free the parent
1362 * @domain: Interrupt domain to match
1363 * @virq: IRQ number to start with
1364 * @nr_irqs: The number of irqs to free
1366 void irq_domain_free_irqs_common(struct irq_domain
*domain
, unsigned int virq
,
1367 unsigned int nr_irqs
)
1369 struct irq_data
*irq_data
;
1372 for (i
= 0; i
< nr_irqs
; i
++) {
1373 irq_data
= irq_domain_get_irq_data(domain
, virq
+ i
);
1375 irq_domain_reset_irq_data(irq_data
);
1377 irq_domain_free_irqs_parent(domain
, virq
, nr_irqs
);
1379 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common
);
1382 * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
1383 * @domain: Interrupt domain to match
1384 * @virq: IRQ number to start with
1385 * @nr_irqs: The number of irqs to free
1387 void irq_domain_free_irqs_top(struct irq_domain
*domain
, unsigned int virq
,
1388 unsigned int nr_irqs
)
1392 for (i
= 0; i
< nr_irqs
; i
++) {
1393 irq_set_handler_data(virq
+ i
, NULL
);
1394 irq_set_handler(virq
+ i
, NULL
);
1396 irq_domain_free_irqs_common(domain
, virq
, nr_irqs
);
1399 static void irq_domain_free_irqs_hierarchy(struct irq_domain
*domain
,
1400 unsigned int irq_base
,
1401 unsigned int nr_irqs
)
1405 if (!domain
->ops
->free
)
1408 for (i
= 0; i
< nr_irqs
; i
++) {
1409 if (irq_domain_get_irq_data(domain
, irq_base
+ i
))
1410 domain
->ops
->free(domain
, irq_base
+ i
, 1);
1414 int irq_domain_alloc_irqs_hierarchy(struct irq_domain
*domain
,
1415 unsigned int irq_base
,
1416 unsigned int nr_irqs
, void *arg
)
1418 if (!domain
->ops
->alloc
) {
1419 pr_debug("domain->ops->alloc() is NULL\n");
1423 return domain
->ops
->alloc(domain
, irq_base
, nr_irqs
, arg
);
1427 * __irq_domain_alloc_irqs - Allocate IRQs from domain
1428 * @domain: domain to allocate from
1429 * @irq_base: allocate specified IRQ number if irq_base >= 0
1430 * @nr_irqs: number of IRQs to allocate
1431 * @node: NUMA node id for memory allocation
1432 * @arg: domain specific argument
1433 * @realloc: IRQ descriptors have already been allocated if true
1434 * @affinity: Optional irq affinity mask for multiqueue devices
1436 * Allocate IRQ numbers and initialized all data structures to support
1437 * hierarchy IRQ domains.
1438 * Parameter @realloc is mainly to support legacy IRQs.
1439 * Returns error code or allocated IRQ number
1441 * The whole process to setup an IRQ has been split into two steps.
1442 * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
1443 * descriptor and required hardware resources. The second step,
1444 * irq_domain_activate_irq(), is to program the hardware with preallocated
1445 * resources. In this way, it's easier to rollback when failing to
1446 * allocate resources.
1448 int __irq_domain_alloc_irqs(struct irq_domain
*domain
, int irq_base
,
1449 unsigned int nr_irqs
, int node
, void *arg
,
1450 bool realloc
, const struct irq_affinity_desc
*affinity
)
1454 if (domain
== NULL
) {
1455 domain
= irq_default_domain
;
1456 if (WARN(!domain
, "domain is NULL; cannot allocate IRQ\n"))
1460 if (realloc
&& irq_base
>= 0) {
1463 virq
= irq_domain_alloc_descs(irq_base
, nr_irqs
, 0, node
,
1466 pr_debug("cannot allocate IRQ(base %d, count %d)\n",
1472 if (irq_domain_alloc_irq_data(domain
, virq
, nr_irqs
)) {
1473 pr_debug("cannot allocate memory for IRQ%d\n", virq
);
1478 mutex_lock(&irq_domain_mutex
);
1479 ret
= irq_domain_alloc_irqs_hierarchy(domain
, virq
, nr_irqs
, arg
);
1481 mutex_unlock(&irq_domain_mutex
);
1482 goto out_free_irq_data
;
1485 for (i
= 0; i
< nr_irqs
; i
++) {
1486 ret
= irq_domain_trim_hierarchy(virq
+ i
);
1488 mutex_unlock(&irq_domain_mutex
);
1489 goto out_free_irq_data
;
1493 for (i
= 0; i
< nr_irqs
; i
++)
1494 irq_domain_insert_irq(virq
+ i
);
1495 mutex_unlock(&irq_domain_mutex
);
1500 irq_domain_free_irq_data(virq
, nr_irqs
);
1502 irq_free_descs(virq
, nr_irqs
);
1506 /* The irq_data was moved, fix the revmap to refer to the new location */
1507 static void irq_domain_fix_revmap(struct irq_data
*d
)
1511 if (irq_domain_is_nomap(d
->domain
))
1514 /* Fix up the revmap. */
1515 mutex_lock(&d
->domain
->revmap_mutex
);
1516 if (d
->hwirq
< d
->domain
->revmap_size
) {
1517 /* Not using radix tree */
1518 rcu_assign_pointer(d
->domain
->revmap
[d
->hwirq
], d
);
1520 slot
= radix_tree_lookup_slot(&d
->domain
->revmap_tree
, d
->hwirq
);
1522 radix_tree_replace_slot(&d
->domain
->revmap_tree
, slot
, d
);
1524 mutex_unlock(&d
->domain
->revmap_mutex
);
1528 * irq_domain_push_irq() - Push a domain in to the top of a hierarchy.
1529 * @domain: Domain to push.
1530 * @virq: Irq to push the domain in to.
1531 * @arg: Passed to the irq_domain_ops alloc() function.
1533 * For an already existing irqdomain hierarchy, as might be obtained
1534 * via a call to pci_enable_msix(), add an additional domain to the
1535 * head of the processing chain. Must be called before request_irq()
1538 int irq_domain_push_irq(struct irq_domain
*domain
, int virq
, void *arg
)
1540 struct irq_data
*child_irq_data
;
1541 struct irq_data
*root_irq_data
= irq_get_irq_data(virq
);
1542 struct irq_desc
*desc
;
1546 * Check that no action has been set, which indicates the virq
1547 * is in a state where this function doesn't have to deal with
1548 * races between interrupt handling and maintaining the
1549 * hierarchy. This will catch gross misuse. Attempting to
1550 * make the check race free would require holding locks across
1551 * calls to struct irq_domain_ops->alloc(), which could lead
1552 * to deadlock, so we just do a simple check before starting.
1554 desc
= irq_to_desc(virq
);
1557 if (WARN_ON(desc
->action
))
1563 if (WARN_ON(!irq_domain_is_hierarchy(domain
)))
1569 if (domain
->parent
!= root_irq_data
->domain
)
1572 child_irq_data
= kzalloc_node(sizeof(*child_irq_data
), GFP_KERNEL
,
1573 irq_data_get_node(root_irq_data
));
1574 if (!child_irq_data
)
1577 mutex_lock(&irq_domain_mutex
);
1579 /* Copy the original irq_data. */
1580 *child_irq_data
= *root_irq_data
;
1583 * Overwrite the root_irq_data, which is embedded in struct
1584 * irq_desc, with values for this domain.
1586 root_irq_data
->parent_data
= child_irq_data
;
1587 root_irq_data
->domain
= domain
;
1588 root_irq_data
->mask
= 0;
1589 root_irq_data
->hwirq
= 0;
1590 root_irq_data
->chip
= NULL
;
1591 root_irq_data
->chip_data
= NULL
;
1593 /* May (probably does) set hwirq, chip, etc. */
1594 rv
= irq_domain_alloc_irqs_hierarchy(domain
, virq
, 1, arg
);
1596 /* Restore the original irq_data. */
1597 *root_irq_data
= *child_irq_data
;
1598 kfree(child_irq_data
);
1602 irq_domain_fix_revmap(child_irq_data
);
1603 irq_domain_set_mapping(domain
, root_irq_data
->hwirq
, root_irq_data
);
1606 mutex_unlock(&irq_domain_mutex
);
1610 EXPORT_SYMBOL_GPL(irq_domain_push_irq
);
1613 * irq_domain_pop_irq() - Remove a domain from the top of a hierarchy.
1614 * @domain: Domain to remove.
1615 * @virq: Irq to remove the domain from.
1617 * Undo the effects of a call to irq_domain_push_irq(). Must be
1618 * called either before request_irq() or after free_irq().
1620 int irq_domain_pop_irq(struct irq_domain
*domain
, int virq
)
1622 struct irq_data
*root_irq_data
= irq_get_irq_data(virq
);
1623 struct irq_data
*child_irq_data
;
1624 struct irq_data
*tmp_irq_data
;
1625 struct irq_desc
*desc
;
1628 * Check that no action is set, which indicates the virq is in
1629 * a state where this function doesn't have to deal with races
1630 * between interrupt handling and maintaining the hierarchy.
1631 * This will catch gross misuse. Attempting to make the check
1632 * race free would require holding locks across calls to
1633 * struct irq_domain_ops->free(), which could lead to
1634 * deadlock, so we just do a simple check before starting.
1636 desc
= irq_to_desc(virq
);
1639 if (WARN_ON(desc
->action
))
1648 tmp_irq_data
= irq_domain_get_irq_data(domain
, virq
);
1650 /* We can only "pop" if this domain is at the top of the list */
1651 if (WARN_ON(root_irq_data
!= tmp_irq_data
))
1654 if (WARN_ON(root_irq_data
->domain
!= domain
))
1657 child_irq_data
= root_irq_data
->parent_data
;
1658 if (WARN_ON(!child_irq_data
))
1661 mutex_lock(&irq_domain_mutex
);
1663 root_irq_data
->parent_data
= NULL
;
1665 irq_domain_clear_mapping(domain
, root_irq_data
->hwirq
);
1666 irq_domain_free_irqs_hierarchy(domain
, virq
, 1);
1668 /* Restore the original irq_data. */
1669 *root_irq_data
= *child_irq_data
;
1671 irq_domain_fix_revmap(root_irq_data
);
1673 mutex_unlock(&irq_domain_mutex
);
1675 kfree(child_irq_data
);
1679 EXPORT_SYMBOL_GPL(irq_domain_pop_irq
);
1682 * irq_domain_free_irqs - Free IRQ number and associated data structures
1683 * @virq: base IRQ number
1684 * @nr_irqs: number of IRQs to free
1686 void irq_domain_free_irqs(unsigned int virq
, unsigned int nr_irqs
)
1688 struct irq_data
*data
= irq_get_irq_data(virq
);
1691 if (WARN(!data
|| !data
->domain
|| !data
->domain
->ops
->free
,
1692 "NULL pointer, cannot free irq\n"))
1695 mutex_lock(&irq_domain_mutex
);
1696 for (i
= 0; i
< nr_irqs
; i
++)
1697 irq_domain_remove_irq(virq
+ i
);
1698 irq_domain_free_irqs_hierarchy(data
->domain
, virq
, nr_irqs
);
1699 mutex_unlock(&irq_domain_mutex
);
1701 irq_domain_free_irq_data(virq
, nr_irqs
);
1702 irq_free_descs(virq
, nr_irqs
);
1706 * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
1707 * @domain: Domain below which interrupts must be allocated
1708 * @irq_base: Base IRQ number
1709 * @nr_irqs: Number of IRQs to allocate
1710 * @arg: Allocation data (arch/domain specific)
1712 int irq_domain_alloc_irqs_parent(struct irq_domain
*domain
,
1713 unsigned int irq_base
, unsigned int nr_irqs
,
1716 if (!domain
->parent
)
1719 return irq_domain_alloc_irqs_hierarchy(domain
->parent
, irq_base
,
1722 EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent
);
1725 * irq_domain_free_irqs_parent - Free interrupts from parent domain
1726 * @domain: Domain below which interrupts must be freed
1727 * @irq_base: Base IRQ number
1728 * @nr_irqs: Number of IRQs to free
1730 void irq_domain_free_irqs_parent(struct irq_domain
*domain
,
1731 unsigned int irq_base
, unsigned int nr_irqs
)
1733 if (!domain
->parent
)
1736 irq_domain_free_irqs_hierarchy(domain
->parent
, irq_base
, nr_irqs
);
1738 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent
);
1740 static void __irq_domain_deactivate_irq(struct irq_data
*irq_data
)
1742 if (irq_data
&& irq_data
->domain
) {
1743 struct irq_domain
*domain
= irq_data
->domain
;
1745 if (domain
->ops
->deactivate
)
1746 domain
->ops
->deactivate(domain
, irq_data
);
1747 if (irq_data
->parent_data
)
1748 __irq_domain_deactivate_irq(irq_data
->parent_data
);
1752 static int __irq_domain_activate_irq(struct irq_data
*irqd
, bool reserve
)
1756 if (irqd
&& irqd
->domain
) {
1757 struct irq_domain
*domain
= irqd
->domain
;
1759 if (irqd
->parent_data
)
1760 ret
= __irq_domain_activate_irq(irqd
->parent_data
,
1762 if (!ret
&& domain
->ops
->activate
) {
1763 ret
= domain
->ops
->activate(domain
, irqd
, reserve
);
1764 /* Rollback in case of error */
1765 if (ret
&& irqd
->parent_data
)
1766 __irq_domain_deactivate_irq(irqd
->parent_data
);
1773 * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
1775 * @irq_data: Outermost irq_data associated with interrupt
1776 * @reserve: If set only reserve an interrupt vector instead of assigning one
1778 * This is the second step to call domain_ops->activate to program interrupt
1779 * controllers, so the interrupt could actually get delivered.
1781 int irq_domain_activate_irq(struct irq_data
*irq_data
, bool reserve
)
1785 if (!irqd_is_activated(irq_data
))
1786 ret
= __irq_domain_activate_irq(irq_data
, reserve
);
1788 irqd_set_activated(irq_data
);
1793 * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
1794 * deactivate interrupt
1795 * @irq_data: outermost irq_data associated with interrupt
1797 * It calls domain_ops->deactivate to program interrupt controllers to disable
1798 * interrupt delivery.
1800 void irq_domain_deactivate_irq(struct irq_data
*irq_data
)
1802 if (irqd_is_activated(irq_data
)) {
1803 __irq_domain_deactivate_irq(irq_data
);
1804 irqd_clr_activated(irq_data
);
1808 static void irq_domain_check_hierarchy(struct irq_domain
*domain
)
1810 /* Hierarchy irq_domains must implement callback alloc() */
1811 if (domain
->ops
->alloc
)
1812 domain
->flags
|= IRQ_DOMAIN_FLAG_HIERARCHY
;
1816 * irq_domain_hierarchical_is_msi_remap - Check if the domain or any
1817 * parent has MSI remapping support
1818 * @domain: domain pointer
1820 bool irq_domain_hierarchical_is_msi_remap(struct irq_domain
*domain
)
1822 for (; domain
; domain
= domain
->parent
) {
1823 if (irq_domain_is_msi_remap(domain
))
1828 #else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1830 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1831 * @domain: domain to match
1832 * @virq: IRQ number to get irq_data
1834 struct irq_data
*irq_domain_get_irq_data(struct irq_domain
*domain
,
1837 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
1839 return (irq_data
&& irq_data
->domain
== domain
) ? irq_data
: NULL
;
1841 EXPORT_SYMBOL_GPL(irq_domain_get_irq_data
);
1844 * irq_domain_set_info - Set the complete data for a @virq in @domain
1845 * @domain: Interrupt domain to match
1847 * @hwirq: The hardware interrupt number
1848 * @chip: The associated interrupt chip
1849 * @chip_data: The associated interrupt chip data
1850 * @handler: The interrupt flow handler
1851 * @handler_data: The interrupt flow handler data
1852 * @handler_name: The interrupt handler name
1854 void irq_domain_set_info(struct irq_domain
*domain
, unsigned int virq
,
1855 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1856 void *chip_data
, irq_flow_handler_t handler
,
1857 void *handler_data
, const char *handler_name
)
1859 irq_set_chip_and_handler_name(virq
, chip
, handler
, handler_name
);
1860 irq_set_chip_data(virq
, chip_data
);
1861 irq_set_handler_data(virq
, handler_data
);
1864 static void irq_domain_check_hierarchy(struct irq_domain
*domain
)
1867 #endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1869 #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
1870 static struct dentry
*domain_dir
;
1873 irq_domain_debug_show_one(struct seq_file
*m
, struct irq_domain
*d
, int ind
)
1875 seq_printf(m
, "%*sname: %s\n", ind
, "", d
->name
);
1876 seq_printf(m
, "%*ssize: %u\n", ind
+ 1, "", d
->revmap_size
);
1877 seq_printf(m
, "%*smapped: %u\n", ind
+ 1, "", d
->mapcount
);
1878 seq_printf(m
, "%*sflags: 0x%08x\n", ind
+1 , "", d
->flags
);
1879 if (d
->ops
&& d
->ops
->debug_show
)
1880 d
->ops
->debug_show(m
, d
, NULL
, ind
+ 1);
1881 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1884 seq_printf(m
, "%*sparent: %s\n", ind
+ 1, "", d
->parent
->name
);
1885 irq_domain_debug_show_one(m
, d
->parent
, ind
+ 4);
1889 static int irq_domain_debug_show(struct seq_file
*m
, void *p
)
1891 struct irq_domain
*d
= m
->private;
1893 /* Default domain? Might be NULL */
1895 if (!irq_default_domain
)
1897 d
= irq_default_domain
;
1899 irq_domain_debug_show_one(m
, d
, 0);
1902 DEFINE_SHOW_ATTRIBUTE(irq_domain_debug
);
1904 static void debugfs_add_domain_dir(struct irq_domain
*d
)
1906 if (!d
->name
|| !domain_dir
)
1908 debugfs_create_file(d
->name
, 0444, domain_dir
, d
,
1909 &irq_domain_debug_fops
);
1912 static void debugfs_remove_domain_dir(struct irq_domain
*d
)
1914 debugfs_remove(debugfs_lookup(d
->name
, domain_dir
));
1917 void __init
irq_domain_debugfs_init(struct dentry
*root
)
1919 struct irq_domain
*d
;
1921 domain_dir
= debugfs_create_dir("domains", root
);
1923 debugfs_create_file("default", 0444, domain_dir
, NULL
,
1924 &irq_domain_debug_fops
);
1925 mutex_lock(&irq_domain_mutex
);
1926 list_for_each_entry(d
, &irq_domain_list
, link
)
1927 debugfs_add_domain_dir(d
);
1928 mutex_unlock(&irq_domain_mutex
);