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 poiner 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
, 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 domain
= kzalloc_node(sizeof(*domain
) + (sizeof(unsigned int) * size
),
150 GFP_KERNEL
, of_node_to_nid(to_of_node(fwnode
)));
154 if (is_fwnode_irqchip(fwnode
)) {
155 fwid
= container_of(fwnode
, struct irqchip_fwid
, fwnode
);
157 switch (fwid
->type
) {
158 case IRQCHIP_FWNODE_NAMED
:
159 case IRQCHIP_FWNODE_NAMED_ID
:
160 domain
->fwnode
= fwnode
;
161 domain
->name
= kstrdup(fwid
->name
, GFP_KERNEL
);
166 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
169 domain
->fwnode
= fwnode
;
170 domain
->name
= fwid
->name
;
173 } else if (is_of_node(fwnode
) || is_acpi_device_node(fwnode
) ||
174 is_software_node(fwnode
)) {
178 * fwnode paths contain '/', which debugfs is legitimately
179 * unhappy about. Replace them with ':', which does
180 * the trick and is not as offensive as '\'...
182 name
= kasprintf(GFP_KERNEL
, "%pfw", fwnode
);
188 strreplace(name
, '/', ':');
191 domain
->fwnode
= fwnode
;
192 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
197 pr_err("Invalid fwnode type for irqdomain\n");
198 domain
->name
= kasprintf(GFP_KERNEL
, "unknown-%d",
199 atomic_inc_return(&unknown_domains
));
204 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
207 fwnode_handle_get(fwnode
);
208 fwnode_dev_initialized(fwnode
, true);
211 INIT_RADIX_TREE(&domain
->revmap_tree
, GFP_KERNEL
);
212 mutex_init(&domain
->revmap_tree_mutex
);
214 domain
->host_data
= host_data
;
215 domain
->hwirq_max
= hwirq_max
;
216 domain
->revmap_size
= size
;
217 domain
->revmap_direct_max_irq
= direct_max
;
218 irq_domain_check_hierarchy(domain
);
220 mutex_lock(&irq_domain_mutex
);
221 debugfs_add_domain_dir(domain
);
222 list_add(&domain
->link
, &irq_domain_list
);
223 mutex_unlock(&irq_domain_mutex
);
225 pr_debug("Added domain %s\n", domain
->name
);
228 EXPORT_SYMBOL_GPL(__irq_domain_add
);
231 * irq_domain_remove() - Remove an irq domain.
232 * @domain: domain to remove
234 * This routine is used to remove an irq domain. The caller must ensure
235 * that all mappings within the domain have been disposed of prior to
236 * use, depending on the revmap type.
238 void irq_domain_remove(struct irq_domain
*domain
)
240 mutex_lock(&irq_domain_mutex
);
241 debugfs_remove_domain_dir(domain
);
243 WARN_ON(!radix_tree_empty(&domain
->revmap_tree
));
245 list_del(&domain
->link
);
248 * If the going away domain is the default one, reset it.
250 if (unlikely(irq_default_domain
== domain
))
251 irq_set_default_host(NULL
);
253 mutex_unlock(&irq_domain_mutex
);
255 pr_debug("Removed domain %s\n", domain
->name
);
257 fwnode_dev_initialized(domain
->fwnode
, false);
258 fwnode_handle_put(domain
->fwnode
);
259 if (domain
->flags
& IRQ_DOMAIN_NAME_ALLOCATED
)
263 EXPORT_SYMBOL_GPL(irq_domain_remove
);
265 void irq_domain_update_bus_token(struct irq_domain
*domain
,
266 enum irq_domain_bus_token bus_token
)
270 if (domain
->bus_token
== bus_token
)
273 mutex_lock(&irq_domain_mutex
);
275 domain
->bus_token
= bus_token
;
277 name
= kasprintf(GFP_KERNEL
, "%s-%d", domain
->name
, bus_token
);
279 mutex_unlock(&irq_domain_mutex
);
283 debugfs_remove_domain_dir(domain
);
285 if (domain
->flags
& IRQ_DOMAIN_NAME_ALLOCATED
)
288 domain
->flags
|= IRQ_DOMAIN_NAME_ALLOCATED
;
291 debugfs_add_domain_dir(domain
);
293 mutex_unlock(&irq_domain_mutex
);
295 EXPORT_SYMBOL_GPL(irq_domain_update_bus_token
);
298 * irq_domain_add_simple() - Register an irq_domain and optionally map a range of irqs
299 * @of_node: pointer to interrupt controller's device tree node.
300 * @size: total number of irqs in mapping
301 * @first_irq: first number of irq block assigned to the domain,
302 * pass zero to assign irqs on-the-fly. If first_irq is non-zero, then
303 * pre-map all of the irqs in the domain to virqs starting at first_irq.
304 * @ops: domain callbacks
305 * @host_data: Controller private data pointer
307 * Allocates an irq_domain, and optionally if first_irq is positive then also
308 * allocate irq_descs and map all of the hwirqs to virqs starting at first_irq.
310 * This is intended to implement the expected behaviour for most
311 * interrupt controllers. If device tree is used, then first_irq will be 0 and
312 * irqs get mapped dynamically on the fly. However, if the controller requires
313 * static virq assignments (non-DT boot) then it will set that up correctly.
315 struct irq_domain
*irq_domain_add_simple(struct device_node
*of_node
,
317 unsigned int first_irq
,
318 const struct irq_domain_ops
*ops
,
321 struct irq_domain
*domain
;
323 domain
= __irq_domain_add(of_node_to_fwnode(of_node
), size
, size
, 0, ops
, host_data
);
328 if (IS_ENABLED(CONFIG_SPARSE_IRQ
)) {
329 /* attempt to allocated irq_descs */
330 int rc
= irq_alloc_descs(first_irq
, first_irq
, size
,
331 of_node_to_nid(of_node
));
333 pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
336 irq_domain_associate_many(domain
, first_irq
, 0, size
);
341 EXPORT_SYMBOL_GPL(irq_domain_add_simple
);
344 * irq_domain_add_legacy() - Allocate and register a legacy revmap irq_domain.
345 * @of_node: pointer to interrupt controller's device tree node.
346 * @size: total number of irqs in legacy mapping
347 * @first_irq: first number of irq block assigned to the domain
348 * @first_hwirq: first hwirq number to use for the translation. Should normally
349 * be '0', but a positive integer can be used if the effective
350 * hwirqs numbering does not begin at zero.
351 * @ops: map/unmap domain callbacks
352 * @host_data: Controller private data pointer
354 * Note: the map() callback will be called before this function returns
355 * for all legacy interrupts except 0 (which is always the invalid irq for
356 * a legacy controller).
358 struct irq_domain
*irq_domain_add_legacy(struct device_node
*of_node
,
360 unsigned int first_irq
,
361 irq_hw_number_t first_hwirq
,
362 const struct irq_domain_ops
*ops
,
365 return irq_domain_create_legacy(of_node_to_fwnode(of_node
), size
,
366 first_irq
, first_hwirq
, ops
, host_data
);
368 EXPORT_SYMBOL_GPL(irq_domain_add_legacy
);
370 struct irq_domain
*irq_domain_create_legacy(struct fwnode_handle
*fwnode
,
372 unsigned int first_irq
,
373 irq_hw_number_t first_hwirq
,
374 const struct irq_domain_ops
*ops
,
377 struct irq_domain
*domain
;
379 domain
= __irq_domain_add(fwnode
, first_hwirq
+ size
, first_hwirq
+ size
, 0, ops
, host_data
);
381 irq_domain_associate_many(domain
, first_irq
, first_hwirq
, size
);
385 EXPORT_SYMBOL_GPL(irq_domain_create_legacy
);
388 * irq_find_matching_fwspec() - Locates a domain for a given fwspec
389 * @fwspec: FW specifier for an interrupt
390 * @bus_token: domain-specific data
392 struct irq_domain
*irq_find_matching_fwspec(struct irq_fwspec
*fwspec
,
393 enum irq_domain_bus_token bus_token
)
395 struct irq_domain
*h
, *found
= NULL
;
396 struct fwnode_handle
*fwnode
= fwspec
->fwnode
;
399 /* We might want to match the legacy controller last since
400 * it might potentially be set to match all interrupts in
401 * the absence of a device node. This isn't a problem so far
404 * bus_token == DOMAIN_BUS_ANY matches any domain, any other
405 * values must generate an exact match for the domain to be
408 mutex_lock(&irq_domain_mutex
);
409 list_for_each_entry(h
, &irq_domain_list
, link
) {
410 if (h
->ops
->select
&& fwspec
->param_count
)
411 rc
= h
->ops
->select(h
, fwspec
, bus_token
);
412 else if (h
->ops
->match
)
413 rc
= h
->ops
->match(h
, to_of_node(fwnode
), bus_token
);
415 rc
= ((fwnode
!= NULL
) && (h
->fwnode
== fwnode
) &&
416 ((bus_token
== DOMAIN_BUS_ANY
) ||
417 (h
->bus_token
== bus_token
)));
424 mutex_unlock(&irq_domain_mutex
);
427 EXPORT_SYMBOL_GPL(irq_find_matching_fwspec
);
430 * irq_domain_check_msi_remap - Check whether all MSI irq domains implement
433 * Return: false if any MSI irq domain does not support IRQ remapping,
434 * true otherwise (including if there is no MSI irq domain)
436 bool irq_domain_check_msi_remap(void)
438 struct irq_domain
*h
;
441 mutex_lock(&irq_domain_mutex
);
442 list_for_each_entry(h
, &irq_domain_list
, link
) {
443 if (irq_domain_is_msi(h
) &&
444 !irq_domain_hierarchical_is_msi_remap(h
)) {
449 mutex_unlock(&irq_domain_mutex
);
452 EXPORT_SYMBOL_GPL(irq_domain_check_msi_remap
);
455 * irq_set_default_host() - Set a "default" irq domain
456 * @domain: default domain pointer
458 * For convenience, it's possible to set a "default" domain that will be used
459 * whenever NULL is passed to irq_create_mapping(). It makes life easier for
460 * platforms that want to manipulate a few hard coded interrupt numbers that
461 * aren't properly represented in the device-tree.
463 void irq_set_default_host(struct irq_domain
*domain
)
465 pr_debug("Default domain set to @0x%p\n", domain
);
467 irq_default_domain
= domain
;
469 EXPORT_SYMBOL_GPL(irq_set_default_host
);
472 * irq_get_default_host() - Retrieve the "default" irq domain
474 * Returns: the default domain, if any.
476 * Modern code should never use this. This should only be used on
477 * systems that cannot implement a firmware->fwnode mapping (which
478 * both DT and ACPI provide).
480 struct irq_domain
*irq_get_default_host(void)
482 return irq_default_domain
;
485 static void irq_domain_clear_mapping(struct irq_domain
*domain
,
486 irq_hw_number_t hwirq
)
488 if (hwirq
< domain
->revmap_size
) {
489 domain
->linear_revmap
[hwirq
] = 0;
491 mutex_lock(&domain
->revmap_tree_mutex
);
492 radix_tree_delete(&domain
->revmap_tree
, hwirq
);
493 mutex_unlock(&domain
->revmap_tree_mutex
);
497 static void irq_domain_set_mapping(struct irq_domain
*domain
,
498 irq_hw_number_t hwirq
,
499 struct irq_data
*irq_data
)
501 if (hwirq
< domain
->revmap_size
) {
502 domain
->linear_revmap
[hwirq
] = irq_data
->irq
;
504 mutex_lock(&domain
->revmap_tree_mutex
);
505 radix_tree_insert(&domain
->revmap_tree
, hwirq
, irq_data
);
506 mutex_unlock(&domain
->revmap_tree_mutex
);
510 static void irq_domain_disassociate(struct irq_domain
*domain
, unsigned int irq
)
512 struct irq_data
*irq_data
= irq_get_irq_data(irq
);
513 irq_hw_number_t hwirq
;
515 if (WARN(!irq_data
|| irq_data
->domain
!= domain
,
516 "virq%i doesn't exist; cannot disassociate\n", irq
))
519 hwirq
= irq_data
->hwirq
;
520 irq_set_status_flags(irq
, IRQ_NOREQUEST
);
522 /* remove chip and handler */
523 irq_set_chip_and_handler(irq
, NULL
, NULL
);
525 /* Make sure it's completed */
526 synchronize_irq(irq
);
528 /* Tell the PIC about it */
529 if (domain
->ops
->unmap
)
530 domain
->ops
->unmap(domain
, irq
);
533 irq_data
->domain
= NULL
;
537 /* Clear reverse map for this hwirq */
538 irq_domain_clear_mapping(domain
, hwirq
);
541 int irq_domain_associate(struct irq_domain
*domain
, unsigned int virq
,
542 irq_hw_number_t hwirq
)
544 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
547 if (WARN(hwirq
>= domain
->hwirq_max
,
548 "error: hwirq 0x%x is too large for %s\n", (int)hwirq
, domain
->name
))
550 if (WARN(!irq_data
, "error: virq%i is not allocated", virq
))
552 if (WARN(irq_data
->domain
, "error: virq%i is already associated", virq
))
555 mutex_lock(&irq_domain_mutex
);
556 irq_data
->hwirq
= hwirq
;
557 irq_data
->domain
= domain
;
558 if (domain
->ops
->map
) {
559 ret
= domain
->ops
->map(domain
, virq
, hwirq
);
562 * If map() returns -EPERM, this interrupt is protected
563 * by the firmware or some other service and shall not
564 * be mapped. Don't bother telling the user about it.
567 pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
568 domain
->name
, hwirq
, virq
, ret
);
570 irq_data
->domain
= NULL
;
572 mutex_unlock(&irq_domain_mutex
);
576 /* If not already assigned, give the domain the chip's name */
577 if (!domain
->name
&& irq_data
->chip
)
578 domain
->name
= irq_data
->chip
->name
;
582 irq_domain_set_mapping(domain
, hwirq
, irq_data
);
583 mutex_unlock(&irq_domain_mutex
);
585 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
589 EXPORT_SYMBOL_GPL(irq_domain_associate
);
591 void irq_domain_associate_many(struct irq_domain
*domain
, unsigned int irq_base
,
592 irq_hw_number_t hwirq_base
, int count
)
594 struct device_node
*of_node
;
597 of_node
= irq_domain_get_of_node(domain
);
598 pr_debug("%s(%s, irqbase=%i, hwbase=%i, count=%i)\n", __func__
,
599 of_node_full_name(of_node
), irq_base
, (int)hwirq_base
, count
);
601 for (i
= 0; i
< count
; i
++) {
602 irq_domain_associate(domain
, irq_base
+ i
, hwirq_base
+ i
);
605 EXPORT_SYMBOL_GPL(irq_domain_associate_many
);
608 * irq_create_direct_mapping() - Allocate an irq for direct mapping
609 * @domain: domain to allocate the irq for or NULL for default domain
611 * This routine is used for irq controllers which can choose the hardware
612 * interrupt numbers they generate. In such a case it's simplest to use
613 * the linux irq as the hardware interrupt number. It still uses the linear
614 * or radix tree to store the mapping, but the irq controller can optimize
615 * the revmap path by using the hwirq directly.
617 unsigned int irq_create_direct_mapping(struct irq_domain
*domain
)
619 struct device_node
*of_node
;
623 domain
= irq_default_domain
;
625 of_node
= irq_domain_get_of_node(domain
);
626 virq
= irq_alloc_desc_from(1, of_node_to_nid(of_node
));
628 pr_debug("create_direct virq allocation failed\n");
631 if (virq
>= domain
->revmap_direct_max_irq
) {
632 pr_err("ERROR: no free irqs available below %i maximum\n",
633 domain
->revmap_direct_max_irq
);
637 pr_debug("create_direct obtained virq %d\n", virq
);
639 if (irq_domain_associate(domain
, virq
, virq
)) {
646 EXPORT_SYMBOL_GPL(irq_create_direct_mapping
);
649 * irq_create_mapping_affinity() - Map a hardware interrupt into linux irq space
650 * @domain: domain owning this hardware interrupt or NULL for default domain
651 * @hwirq: hardware irq number in that domain space
652 * @affinity: irq affinity
654 * Only one mapping per hardware interrupt is permitted. Returns a linux
656 * If the sense/trigger is to be specified, set_irq_type() should be called
657 * on the number returned from that call.
659 unsigned int irq_create_mapping_affinity(struct irq_domain
*domain
,
660 irq_hw_number_t hwirq
,
661 const struct irq_affinity_desc
*affinity
)
663 struct device_node
*of_node
;
666 pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain
, hwirq
);
668 /* Look for default domain if nececssary */
670 domain
= irq_default_domain
;
671 if (domain
== NULL
) {
672 WARN(1, "%s(, %lx) called with NULL domain\n", __func__
, hwirq
);
675 pr_debug("-> using domain @%p\n", domain
);
677 of_node
= irq_domain_get_of_node(domain
);
679 /* Check if mapping already exists */
680 virq
= irq_find_mapping(domain
, hwirq
);
682 pr_debug("-> existing mapping on virq %d\n", virq
);
686 /* Allocate a virtual interrupt number */
687 virq
= irq_domain_alloc_descs(-1, 1, hwirq
, of_node_to_nid(of_node
),
690 pr_debug("-> virq allocation failed\n");
694 if (irq_domain_associate(domain
, virq
, hwirq
)) {
699 pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
700 hwirq
, of_node_full_name(of_node
), virq
);
704 EXPORT_SYMBOL_GPL(irq_create_mapping_affinity
);
707 * irq_create_strict_mappings() - Map a range of hw irqs to fixed linux irqs
708 * @domain: domain owning the interrupt range
709 * @irq_base: beginning of linux IRQ range
710 * @hwirq_base: beginning of hardware IRQ range
711 * @count: Number of interrupts to map
713 * This routine is used for allocating and mapping a range of hardware
714 * irqs to linux irqs where the linux irq numbers are at pre-defined
715 * locations. For use by controllers that already have static mappings
716 * to insert in to the domain.
718 * Non-linear users can use irq_create_identity_mapping() for IRQ-at-a-time
721 * 0 is returned upon success, while any failure to establish a static
722 * mapping is treated as an error.
724 int irq_create_strict_mappings(struct irq_domain
*domain
, unsigned int irq_base
,
725 irq_hw_number_t hwirq_base
, int count
)
727 struct device_node
*of_node
;
730 of_node
= irq_domain_get_of_node(domain
);
731 ret
= irq_alloc_descs(irq_base
, irq_base
, count
,
732 of_node_to_nid(of_node
));
733 if (unlikely(ret
< 0))
736 irq_domain_associate_many(domain
, irq_base
, hwirq_base
, count
);
739 EXPORT_SYMBOL_GPL(irq_create_strict_mappings
);
741 static int irq_domain_translate(struct irq_domain
*d
,
742 struct irq_fwspec
*fwspec
,
743 irq_hw_number_t
*hwirq
, unsigned int *type
)
745 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
746 if (d
->ops
->translate
)
747 return d
->ops
->translate(d
, fwspec
, hwirq
, type
);
750 return d
->ops
->xlate(d
, to_of_node(fwspec
->fwnode
),
751 fwspec
->param
, fwspec
->param_count
,
754 /* If domain has no translation, then we assume interrupt line */
755 *hwirq
= fwspec
->param
[0];
759 static void of_phandle_args_to_fwspec(struct device_node
*np
, const u32
*args
,
761 struct irq_fwspec
*fwspec
)
765 fwspec
->fwnode
= of_node_to_fwnode(np
);
766 fwspec
->param_count
= count
;
768 for (i
= 0; i
< count
; i
++)
769 fwspec
->param
[i
] = args
[i
];
772 unsigned int irq_create_fwspec_mapping(struct irq_fwspec
*fwspec
)
774 struct irq_domain
*domain
;
775 struct irq_data
*irq_data
;
776 irq_hw_number_t hwirq
;
777 unsigned int type
= IRQ_TYPE_NONE
;
780 if (fwspec
->fwnode
) {
781 domain
= irq_find_matching_fwspec(fwspec
, DOMAIN_BUS_WIRED
);
783 domain
= irq_find_matching_fwspec(fwspec
, DOMAIN_BUS_ANY
);
785 domain
= irq_default_domain
;
789 pr_warn("no irq domain found for %s !\n",
790 of_node_full_name(to_of_node(fwspec
->fwnode
)));
794 if (irq_domain_translate(domain
, fwspec
, &hwirq
, &type
))
798 * WARN if the irqchip returns a type with bits
799 * outside the sense mask set and clear these bits.
801 if (WARN_ON(type
& ~IRQ_TYPE_SENSE_MASK
))
802 type
&= IRQ_TYPE_SENSE_MASK
;
805 * If we've already configured this interrupt,
806 * don't do it again, or hell will break loose.
808 virq
= irq_find_mapping(domain
, hwirq
);
811 * If the trigger type is not specified or matches the
812 * current trigger type then we are done so return the
815 if (type
== IRQ_TYPE_NONE
|| type
== irq_get_trigger_type(virq
))
819 * If the trigger type has not been set yet, then set
820 * it now and return the interrupt number.
822 if (irq_get_trigger_type(virq
) == IRQ_TYPE_NONE
) {
823 irq_data
= irq_get_irq_data(virq
);
827 irqd_set_trigger_type(irq_data
, type
);
831 pr_warn("type mismatch, failed to map hwirq-%lu for %s!\n",
832 hwirq
, of_node_full_name(to_of_node(fwspec
->fwnode
)));
836 if (irq_domain_is_hierarchy(domain
)) {
837 virq
= irq_domain_alloc_irqs(domain
, 1, NUMA_NO_NODE
, fwspec
);
842 virq
= irq_create_mapping(domain
, hwirq
);
847 irq_data
= irq_get_irq_data(virq
);
849 if (irq_domain_is_hierarchy(domain
))
850 irq_domain_free_irqs(virq
, 1);
852 irq_dispose_mapping(virq
);
856 /* Store trigger type */
857 irqd_set_trigger_type(irq_data
, type
);
861 EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping
);
863 unsigned int irq_create_of_mapping(struct of_phandle_args
*irq_data
)
865 struct irq_fwspec fwspec
;
867 of_phandle_args_to_fwspec(irq_data
->np
, irq_data
->args
,
868 irq_data
->args_count
, &fwspec
);
870 return irq_create_fwspec_mapping(&fwspec
);
872 EXPORT_SYMBOL_GPL(irq_create_of_mapping
);
875 * irq_dispose_mapping() - Unmap an interrupt
876 * @virq: linux irq number of the interrupt to unmap
878 void irq_dispose_mapping(unsigned int virq
)
880 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
881 struct irq_domain
*domain
;
883 if (!virq
|| !irq_data
)
886 domain
= irq_data
->domain
;
887 if (WARN_ON(domain
== NULL
))
890 if (irq_domain_is_hierarchy(domain
)) {
891 irq_domain_free_irqs(virq
, 1);
893 irq_domain_disassociate(domain
, virq
);
897 EXPORT_SYMBOL_GPL(irq_dispose_mapping
);
900 * irq_find_mapping() - Find a linux irq from a hw irq number.
901 * @domain: domain owning this hardware interrupt
902 * @hwirq: hardware irq number in that domain space
904 unsigned int irq_find_mapping(struct irq_domain
*domain
,
905 irq_hw_number_t hwirq
)
907 struct irq_data
*data
;
909 /* Look for default domain if nececssary */
911 domain
= irq_default_domain
;
915 if (hwirq
< domain
->revmap_direct_max_irq
) {
916 data
= irq_domain_get_irq_data(domain
, hwirq
);
917 if (data
&& data
->hwirq
== hwirq
)
921 /* Check if the hwirq is in the linear revmap. */
922 if (hwirq
< domain
->revmap_size
)
923 return domain
->linear_revmap
[hwirq
];
926 data
= radix_tree_lookup(&domain
->revmap_tree
, hwirq
);
928 return data
? data
->irq
: 0;
930 EXPORT_SYMBOL_GPL(irq_find_mapping
);
933 * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
935 * Device Tree IRQ specifier translation function which works with one cell
936 * bindings where the cell value maps directly to the hwirq number.
938 int irq_domain_xlate_onecell(struct irq_domain
*d
, struct device_node
*ctrlr
,
939 const u32
*intspec
, unsigned int intsize
,
940 unsigned long *out_hwirq
, unsigned int *out_type
)
942 if (WARN_ON(intsize
< 1))
944 *out_hwirq
= intspec
[0];
945 *out_type
= IRQ_TYPE_NONE
;
948 EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell
);
951 * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
953 * Device Tree IRQ specifier translation function which works with two cell
954 * bindings where the cell values map directly to the hwirq number
955 * and linux irq flags.
957 int irq_domain_xlate_twocell(struct irq_domain
*d
, struct device_node
*ctrlr
,
958 const u32
*intspec
, unsigned int intsize
,
959 irq_hw_number_t
*out_hwirq
, unsigned int *out_type
)
961 struct irq_fwspec fwspec
;
963 of_phandle_args_to_fwspec(ctrlr
, intspec
, intsize
, &fwspec
);
964 return irq_domain_translate_twocell(d
, &fwspec
, out_hwirq
, out_type
);
966 EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell
);
969 * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
971 * Device Tree IRQ specifier translation function which works with either one
972 * or two cell bindings where the cell values map directly to the hwirq number
973 * and linux irq flags.
975 * Note: don't use this function unless your interrupt controller explicitly
976 * supports both one and two cell bindings. For the majority of controllers
977 * the _onecell() or _twocell() variants above should be used.
979 int irq_domain_xlate_onetwocell(struct irq_domain
*d
,
980 struct device_node
*ctrlr
,
981 const u32
*intspec
, unsigned int intsize
,
982 unsigned long *out_hwirq
, unsigned int *out_type
)
984 if (WARN_ON(intsize
< 1))
986 *out_hwirq
= intspec
[0];
988 *out_type
= intspec
[1] & IRQ_TYPE_SENSE_MASK
;
990 *out_type
= IRQ_TYPE_NONE
;
993 EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell
);
995 const struct irq_domain_ops irq_domain_simple_ops
= {
996 .xlate
= irq_domain_xlate_onetwocell
,
998 EXPORT_SYMBOL_GPL(irq_domain_simple_ops
);
1001 * irq_domain_translate_onecell() - Generic translate for direct one cell
1004 int irq_domain_translate_onecell(struct irq_domain
*d
,
1005 struct irq_fwspec
*fwspec
,
1006 unsigned long *out_hwirq
,
1007 unsigned int *out_type
)
1009 if (WARN_ON(fwspec
->param_count
< 1))
1011 *out_hwirq
= fwspec
->param
[0];
1012 *out_type
= IRQ_TYPE_NONE
;
1015 EXPORT_SYMBOL_GPL(irq_domain_translate_onecell
);
1018 * irq_domain_translate_twocell() - Generic translate for direct two cell
1021 * Device Tree IRQ specifier translation function which works with two cell
1022 * bindings where the cell values map directly to the hwirq number
1023 * and linux irq flags.
1025 int irq_domain_translate_twocell(struct irq_domain
*d
,
1026 struct irq_fwspec
*fwspec
,
1027 unsigned long *out_hwirq
,
1028 unsigned int *out_type
)
1030 if (WARN_ON(fwspec
->param_count
< 2))
1032 *out_hwirq
= fwspec
->param
[0];
1033 *out_type
= fwspec
->param
[1] & IRQ_TYPE_SENSE_MASK
;
1036 EXPORT_SYMBOL_GPL(irq_domain_translate_twocell
);
1038 int irq_domain_alloc_descs(int virq
, unsigned int cnt
, irq_hw_number_t hwirq
,
1039 int node
, const struct irq_affinity_desc
*affinity
)
1044 virq
= __irq_alloc_descs(virq
, virq
, cnt
, node
, THIS_MODULE
,
1047 hint
= hwirq
% nr_irqs
;
1050 virq
= __irq_alloc_descs(-1, hint
, cnt
, node
, THIS_MODULE
,
1052 if (virq
<= 0 && hint
> 1) {
1053 virq
= __irq_alloc_descs(-1, 1, cnt
, node
, THIS_MODULE
,
1062 * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
1063 * @irq_data: The pointer to irq_data
1065 void irq_domain_reset_irq_data(struct irq_data
*irq_data
)
1067 irq_data
->hwirq
= 0;
1068 irq_data
->chip
= &no_irq_chip
;
1069 irq_data
->chip_data
= NULL
;
1071 EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data
);
1073 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1075 * irq_domain_create_hierarchy - Add a irqdomain into the hierarchy
1076 * @parent: Parent irq domain to associate with the new domain
1077 * @flags: Irq domain flags associated to the domain
1078 * @size: Size of the domain. See below
1079 * @fwnode: Optional fwnode of the interrupt controller
1080 * @ops: Pointer to the interrupt domain callbacks
1081 * @host_data: Controller private data pointer
1083 * If @size is 0 a tree domain is created, otherwise a linear domain.
1085 * If successful the parent is associated to the new domain and the
1086 * domain flags are set.
1087 * Returns pointer to IRQ domain, or NULL on failure.
1089 struct irq_domain
*irq_domain_create_hierarchy(struct irq_domain
*parent
,
1092 struct fwnode_handle
*fwnode
,
1093 const struct irq_domain_ops
*ops
,
1096 struct irq_domain
*domain
;
1099 domain
= irq_domain_create_linear(fwnode
, size
, ops
, host_data
);
1101 domain
= irq_domain_create_tree(fwnode
, ops
, host_data
);
1103 domain
->parent
= parent
;
1104 domain
->flags
|= flags
;
1109 EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy
);
1111 static void irq_domain_insert_irq(int virq
)
1113 struct irq_data
*data
;
1115 for (data
= irq_get_irq_data(virq
); data
; data
= data
->parent_data
) {
1116 struct irq_domain
*domain
= data
->domain
;
1119 irq_domain_set_mapping(domain
, data
->hwirq
, data
);
1121 /* If not already assigned, give the domain the chip's name */
1122 if (!domain
->name
&& data
->chip
)
1123 domain
->name
= data
->chip
->name
;
1126 irq_clear_status_flags(virq
, IRQ_NOREQUEST
);
1129 static void irq_domain_remove_irq(int virq
)
1131 struct irq_data
*data
;
1133 irq_set_status_flags(virq
, IRQ_NOREQUEST
);
1134 irq_set_chip_and_handler(virq
, NULL
, NULL
);
1135 synchronize_irq(virq
);
1138 for (data
= irq_get_irq_data(virq
); data
; data
= data
->parent_data
) {
1139 struct irq_domain
*domain
= data
->domain
;
1140 irq_hw_number_t hwirq
= data
->hwirq
;
1143 irq_domain_clear_mapping(domain
, hwirq
);
1147 static struct irq_data
*irq_domain_insert_irq_data(struct irq_domain
*domain
,
1148 struct irq_data
*child
)
1150 struct irq_data
*irq_data
;
1152 irq_data
= kzalloc_node(sizeof(*irq_data
), GFP_KERNEL
,
1153 irq_data_get_node(child
));
1155 child
->parent_data
= irq_data
;
1156 irq_data
->irq
= child
->irq
;
1157 irq_data
->common
= child
->common
;
1158 irq_data
->domain
= domain
;
1164 static void __irq_domain_free_hierarchy(struct irq_data
*irq_data
)
1166 struct irq_data
*tmp
;
1170 irq_data
= irq_data
->parent_data
;
1175 static void irq_domain_free_irq_data(unsigned int virq
, unsigned int nr_irqs
)
1177 struct irq_data
*irq_data
, *tmp
;
1180 for (i
= 0; i
< nr_irqs
; i
++) {
1181 irq_data
= irq_get_irq_data(virq
+ i
);
1182 tmp
= irq_data
->parent_data
;
1183 irq_data
->parent_data
= NULL
;
1184 irq_data
->domain
= NULL
;
1186 __irq_domain_free_hierarchy(tmp
);
1191 * irq_domain_disconnect_hierarchy - Mark the first unused level of a hierarchy
1192 * @domain: IRQ domain from which the hierarchy is to be disconnected
1193 * @virq: IRQ number where the hierarchy is to be trimmed
1195 * Marks the @virq level belonging to @domain as disconnected.
1196 * Returns -EINVAL if @virq doesn't have a valid irq_data pointing
1199 * Its only use is to be able to trim levels of hierarchy that do not
1200 * have any real meaning for this interrupt, and that the driver marks
1201 * as such from its .alloc() callback.
1203 int irq_domain_disconnect_hierarchy(struct irq_domain
*domain
,
1206 struct irq_data
*irqd
;
1208 irqd
= irq_domain_get_irq_data(domain
, virq
);
1212 irqd
->chip
= ERR_PTR(-ENOTCONN
);
1216 static int irq_domain_trim_hierarchy(unsigned int virq
)
1218 struct irq_data
*tail
, *irqd
, *irq_data
;
1220 irq_data
= irq_get_irq_data(virq
);
1223 /* The first entry must have a valid irqchip */
1224 if (!irq_data
->chip
|| IS_ERR(irq_data
->chip
))
1228 * Validate that the irq_data chain is sane in the presence of
1229 * a hierarchy trimming marker.
1231 for (irqd
= irq_data
->parent_data
; irqd
; irq_data
= irqd
, irqd
= irqd
->parent_data
) {
1232 /* Can't have a valid irqchip after a trim marker */
1233 if (irqd
->chip
&& tail
)
1236 /* Can't have an empty irqchip before a trim marker */
1237 if (!irqd
->chip
&& !tail
)
1240 if (IS_ERR(irqd
->chip
)) {
1241 /* Only -ENOTCONN is a valid trim marker */
1242 if (PTR_ERR(irqd
->chip
) != -ENOTCONN
)
1249 /* No trim marker, nothing to do */
1253 pr_info("IRQ%d: trimming hierarchy from %s\n",
1254 virq
, tail
->parent_data
->domain
->name
);
1256 /* Sever the inner part of the hierarchy... */
1258 tail
= tail
->parent_data
;
1259 irqd
->parent_data
= NULL
;
1260 __irq_domain_free_hierarchy(tail
);
1265 static int irq_domain_alloc_irq_data(struct irq_domain
*domain
,
1266 unsigned int virq
, unsigned int nr_irqs
)
1268 struct irq_data
*irq_data
;
1269 struct irq_domain
*parent
;
1272 /* The outermost irq_data is embedded in struct irq_desc */
1273 for (i
= 0; i
< nr_irqs
; i
++) {
1274 irq_data
= irq_get_irq_data(virq
+ i
);
1275 irq_data
->domain
= domain
;
1277 for (parent
= domain
->parent
; parent
; parent
= parent
->parent
) {
1278 irq_data
= irq_domain_insert_irq_data(parent
, irq_data
);
1280 irq_domain_free_irq_data(virq
, i
+ 1);
1290 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1291 * @domain: domain to match
1292 * @virq: IRQ number to get irq_data
1294 struct irq_data
*irq_domain_get_irq_data(struct irq_domain
*domain
,
1297 struct irq_data
*irq_data
;
1299 for (irq_data
= irq_get_irq_data(virq
); irq_data
;
1300 irq_data
= irq_data
->parent_data
)
1301 if (irq_data
->domain
== domain
)
1306 EXPORT_SYMBOL_GPL(irq_domain_get_irq_data
);
1309 * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
1310 * @domain: Interrupt domain to match
1312 * @hwirq: The hwirq number
1313 * @chip: The associated interrupt chip
1314 * @chip_data: The associated chip data
1316 int irq_domain_set_hwirq_and_chip(struct irq_domain
*domain
, unsigned int virq
,
1317 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1320 struct irq_data
*irq_data
= irq_domain_get_irq_data(domain
, virq
);
1325 irq_data
->hwirq
= hwirq
;
1326 irq_data
->chip
= chip
? chip
: &no_irq_chip
;
1327 irq_data
->chip_data
= chip_data
;
1331 EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip
);
1334 * irq_domain_set_info - Set the complete data for a @virq in @domain
1335 * @domain: Interrupt domain to match
1337 * @hwirq: The hardware interrupt number
1338 * @chip: The associated interrupt chip
1339 * @chip_data: The associated interrupt chip data
1340 * @handler: The interrupt flow handler
1341 * @handler_data: The interrupt flow handler data
1342 * @handler_name: The interrupt handler name
1344 void irq_domain_set_info(struct irq_domain
*domain
, unsigned int virq
,
1345 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1346 void *chip_data
, irq_flow_handler_t handler
,
1347 void *handler_data
, const char *handler_name
)
1349 irq_domain_set_hwirq_and_chip(domain
, virq
, hwirq
, chip
, chip_data
);
1350 __irq_set_handler(virq
, handler
, 0, handler_name
);
1351 irq_set_handler_data(virq
, handler_data
);
1353 EXPORT_SYMBOL(irq_domain_set_info
);
1356 * irq_domain_free_irqs_common - Clear irq_data and free the parent
1357 * @domain: Interrupt domain to match
1358 * @virq: IRQ number to start with
1359 * @nr_irqs: The number of irqs to free
1361 void irq_domain_free_irqs_common(struct irq_domain
*domain
, unsigned int virq
,
1362 unsigned int nr_irqs
)
1364 struct irq_data
*irq_data
;
1367 for (i
= 0; i
< nr_irqs
; i
++) {
1368 irq_data
= irq_domain_get_irq_data(domain
, virq
+ i
);
1370 irq_domain_reset_irq_data(irq_data
);
1372 irq_domain_free_irqs_parent(domain
, virq
, nr_irqs
);
1374 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common
);
1377 * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
1378 * @domain: Interrupt domain to match
1379 * @virq: IRQ number to start with
1380 * @nr_irqs: The number of irqs to free
1382 void irq_domain_free_irqs_top(struct irq_domain
*domain
, unsigned int virq
,
1383 unsigned int nr_irqs
)
1387 for (i
= 0; i
< nr_irqs
; i
++) {
1388 irq_set_handler_data(virq
+ i
, NULL
);
1389 irq_set_handler(virq
+ i
, NULL
);
1391 irq_domain_free_irqs_common(domain
, virq
, nr_irqs
);
1394 static void irq_domain_free_irqs_hierarchy(struct irq_domain
*domain
,
1395 unsigned int irq_base
,
1396 unsigned int nr_irqs
)
1400 if (!domain
->ops
->free
)
1403 for (i
= 0; i
< nr_irqs
; i
++) {
1404 if (irq_domain_get_irq_data(domain
, irq_base
+ i
))
1405 domain
->ops
->free(domain
, irq_base
+ i
, 1);
1409 int irq_domain_alloc_irqs_hierarchy(struct irq_domain
*domain
,
1410 unsigned int irq_base
,
1411 unsigned int nr_irqs
, void *arg
)
1413 if (!domain
->ops
->alloc
) {
1414 pr_debug("domain->ops->alloc() is NULL\n");
1418 return domain
->ops
->alloc(domain
, irq_base
, nr_irqs
, arg
);
1422 * __irq_domain_alloc_irqs - Allocate IRQs from domain
1423 * @domain: domain to allocate from
1424 * @irq_base: allocate specified IRQ number if irq_base >= 0
1425 * @nr_irqs: number of IRQs to allocate
1426 * @node: NUMA node id for memory allocation
1427 * @arg: domain specific argument
1428 * @realloc: IRQ descriptors have already been allocated if true
1429 * @affinity: Optional irq affinity mask for multiqueue devices
1431 * Allocate IRQ numbers and initialized all data structures to support
1432 * hierarchy IRQ domains.
1433 * Parameter @realloc is mainly to support legacy IRQs.
1434 * Returns error code or allocated IRQ number
1436 * The whole process to setup an IRQ has been split into two steps.
1437 * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
1438 * descriptor and required hardware resources. The second step,
1439 * irq_domain_activate_irq(), is to program hardwares with preallocated
1440 * resources. In this way, it's easier to rollback when failing to
1441 * allocate resources.
1443 int __irq_domain_alloc_irqs(struct irq_domain
*domain
, int irq_base
,
1444 unsigned int nr_irqs
, int node
, void *arg
,
1445 bool realloc
, const struct irq_affinity_desc
*affinity
)
1449 if (domain
== NULL
) {
1450 domain
= irq_default_domain
;
1451 if (WARN(!domain
, "domain is NULL; cannot allocate IRQ\n"))
1455 if (realloc
&& irq_base
>= 0) {
1458 virq
= irq_domain_alloc_descs(irq_base
, nr_irqs
, 0, node
,
1461 pr_debug("cannot allocate IRQ(base %d, count %d)\n",
1467 if (irq_domain_alloc_irq_data(domain
, virq
, nr_irqs
)) {
1468 pr_debug("cannot allocate memory for IRQ%d\n", virq
);
1473 mutex_lock(&irq_domain_mutex
);
1474 ret
= irq_domain_alloc_irqs_hierarchy(domain
, virq
, nr_irqs
, arg
);
1476 mutex_unlock(&irq_domain_mutex
);
1477 goto out_free_irq_data
;
1480 for (i
= 0; i
< nr_irqs
; i
++) {
1481 ret
= irq_domain_trim_hierarchy(virq
+ i
);
1483 mutex_unlock(&irq_domain_mutex
);
1484 goto out_free_irq_data
;
1488 for (i
= 0; i
< nr_irqs
; i
++)
1489 irq_domain_insert_irq(virq
+ i
);
1490 mutex_unlock(&irq_domain_mutex
);
1495 irq_domain_free_irq_data(virq
, nr_irqs
);
1497 irq_free_descs(virq
, nr_irqs
);
1501 /* The irq_data was moved, fix the revmap to refer to the new location */
1502 static void irq_domain_fix_revmap(struct irq_data
*d
)
1506 if (d
->hwirq
< d
->domain
->revmap_size
)
1507 return; /* Not using radix tree. */
1509 /* Fix up the revmap. */
1510 mutex_lock(&d
->domain
->revmap_tree_mutex
);
1511 slot
= radix_tree_lookup_slot(&d
->domain
->revmap_tree
, d
->hwirq
);
1513 radix_tree_replace_slot(&d
->domain
->revmap_tree
, slot
, d
);
1514 mutex_unlock(&d
->domain
->revmap_tree_mutex
);
1518 * irq_domain_push_irq() - Push a domain in to the top of a hierarchy.
1519 * @domain: Domain to push.
1520 * @virq: Irq to push the domain in to.
1521 * @arg: Passed to the irq_domain_ops alloc() function.
1523 * For an already existing irqdomain hierarchy, as might be obtained
1524 * via a call to pci_enable_msix(), add an additional domain to the
1525 * head of the processing chain. Must be called before request_irq()
1528 int irq_domain_push_irq(struct irq_domain
*domain
, int virq
, void *arg
)
1530 struct irq_data
*child_irq_data
;
1531 struct irq_data
*root_irq_data
= irq_get_irq_data(virq
);
1532 struct irq_desc
*desc
;
1536 * Check that no action has been set, which indicates the virq
1537 * is in a state where this function doesn't have to deal with
1538 * races between interrupt handling and maintaining the
1539 * hierarchy. This will catch gross misuse. Attempting to
1540 * make the check race free would require holding locks across
1541 * calls to struct irq_domain_ops->alloc(), which could lead
1542 * to deadlock, so we just do a simple check before starting.
1544 desc
= irq_to_desc(virq
);
1547 if (WARN_ON(desc
->action
))
1553 if (WARN_ON(!irq_domain_is_hierarchy(domain
)))
1559 if (domain
->parent
!= root_irq_data
->domain
)
1562 child_irq_data
= kzalloc_node(sizeof(*child_irq_data
), GFP_KERNEL
,
1563 irq_data_get_node(root_irq_data
));
1564 if (!child_irq_data
)
1567 mutex_lock(&irq_domain_mutex
);
1569 /* Copy the original irq_data. */
1570 *child_irq_data
= *root_irq_data
;
1573 * Overwrite the root_irq_data, which is embedded in struct
1574 * irq_desc, with values for this domain.
1576 root_irq_data
->parent_data
= child_irq_data
;
1577 root_irq_data
->domain
= domain
;
1578 root_irq_data
->mask
= 0;
1579 root_irq_data
->hwirq
= 0;
1580 root_irq_data
->chip
= NULL
;
1581 root_irq_data
->chip_data
= NULL
;
1583 /* May (probably does) set hwirq, chip, etc. */
1584 rv
= irq_domain_alloc_irqs_hierarchy(domain
, virq
, 1, arg
);
1586 /* Restore the original irq_data. */
1587 *root_irq_data
= *child_irq_data
;
1588 kfree(child_irq_data
);
1592 irq_domain_fix_revmap(child_irq_data
);
1593 irq_domain_set_mapping(domain
, root_irq_data
->hwirq
, root_irq_data
);
1596 mutex_unlock(&irq_domain_mutex
);
1600 EXPORT_SYMBOL_GPL(irq_domain_push_irq
);
1603 * irq_domain_pop_irq() - Remove a domain from the top of a hierarchy.
1604 * @domain: Domain to remove.
1605 * @virq: Irq to remove the domain from.
1607 * Undo the effects of a call to irq_domain_push_irq(). Must be
1608 * called either before request_irq() or after free_irq().
1610 int irq_domain_pop_irq(struct irq_domain
*domain
, int virq
)
1612 struct irq_data
*root_irq_data
= irq_get_irq_data(virq
);
1613 struct irq_data
*child_irq_data
;
1614 struct irq_data
*tmp_irq_data
;
1615 struct irq_desc
*desc
;
1618 * Check that no action is set, which indicates the virq is in
1619 * a state where this function doesn't have to deal with races
1620 * between interrupt handling and maintaining the hierarchy.
1621 * This will catch gross misuse. Attempting to make the check
1622 * race free would require holding locks across calls to
1623 * struct irq_domain_ops->free(), which could lead to
1624 * deadlock, so we just do a simple check before starting.
1626 desc
= irq_to_desc(virq
);
1629 if (WARN_ON(desc
->action
))
1638 tmp_irq_data
= irq_domain_get_irq_data(domain
, virq
);
1640 /* We can only "pop" if this domain is at the top of the list */
1641 if (WARN_ON(root_irq_data
!= tmp_irq_data
))
1644 if (WARN_ON(root_irq_data
->domain
!= domain
))
1647 child_irq_data
= root_irq_data
->parent_data
;
1648 if (WARN_ON(!child_irq_data
))
1651 mutex_lock(&irq_domain_mutex
);
1653 root_irq_data
->parent_data
= NULL
;
1655 irq_domain_clear_mapping(domain
, root_irq_data
->hwirq
);
1656 irq_domain_free_irqs_hierarchy(domain
, virq
, 1);
1658 /* Restore the original irq_data. */
1659 *root_irq_data
= *child_irq_data
;
1661 irq_domain_fix_revmap(root_irq_data
);
1663 mutex_unlock(&irq_domain_mutex
);
1665 kfree(child_irq_data
);
1669 EXPORT_SYMBOL_GPL(irq_domain_pop_irq
);
1672 * irq_domain_free_irqs - Free IRQ number and associated data structures
1673 * @virq: base IRQ number
1674 * @nr_irqs: number of IRQs to free
1676 void irq_domain_free_irqs(unsigned int virq
, unsigned int nr_irqs
)
1678 struct irq_data
*data
= irq_get_irq_data(virq
);
1681 if (WARN(!data
|| !data
->domain
|| !data
->domain
->ops
->free
,
1682 "NULL pointer, cannot free irq\n"))
1685 mutex_lock(&irq_domain_mutex
);
1686 for (i
= 0; i
< nr_irqs
; i
++)
1687 irq_domain_remove_irq(virq
+ i
);
1688 irq_domain_free_irqs_hierarchy(data
->domain
, virq
, nr_irqs
);
1689 mutex_unlock(&irq_domain_mutex
);
1691 irq_domain_free_irq_data(virq
, nr_irqs
);
1692 irq_free_descs(virq
, nr_irqs
);
1696 * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
1697 * @irq_base: Base IRQ number
1698 * @nr_irqs: Number of IRQs to allocate
1699 * @arg: Allocation data (arch/domain specific)
1701 * Check whether the domain has been setup recursive. If not allocate
1702 * through the parent domain.
1704 int irq_domain_alloc_irqs_parent(struct irq_domain
*domain
,
1705 unsigned int irq_base
, unsigned int nr_irqs
,
1708 if (!domain
->parent
)
1711 return irq_domain_alloc_irqs_hierarchy(domain
->parent
, irq_base
,
1714 EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent
);
1717 * irq_domain_free_irqs_parent - Free interrupts from parent domain
1718 * @irq_base: Base IRQ number
1719 * @nr_irqs: Number of IRQs to free
1721 * Check whether the domain has been setup recursive. If not free
1722 * through the parent domain.
1724 void irq_domain_free_irqs_parent(struct irq_domain
*domain
,
1725 unsigned int irq_base
, unsigned int nr_irqs
)
1727 if (!domain
->parent
)
1730 irq_domain_free_irqs_hierarchy(domain
->parent
, irq_base
, nr_irqs
);
1732 EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent
);
1734 static void __irq_domain_deactivate_irq(struct irq_data
*irq_data
)
1736 if (irq_data
&& irq_data
->domain
) {
1737 struct irq_domain
*domain
= irq_data
->domain
;
1739 if (domain
->ops
->deactivate
)
1740 domain
->ops
->deactivate(domain
, irq_data
);
1741 if (irq_data
->parent_data
)
1742 __irq_domain_deactivate_irq(irq_data
->parent_data
);
1746 static int __irq_domain_activate_irq(struct irq_data
*irqd
, bool reserve
)
1750 if (irqd
&& irqd
->domain
) {
1751 struct irq_domain
*domain
= irqd
->domain
;
1753 if (irqd
->parent_data
)
1754 ret
= __irq_domain_activate_irq(irqd
->parent_data
,
1756 if (!ret
&& domain
->ops
->activate
) {
1757 ret
= domain
->ops
->activate(domain
, irqd
, reserve
);
1758 /* Rollback in case of error */
1759 if (ret
&& irqd
->parent_data
)
1760 __irq_domain_deactivate_irq(irqd
->parent_data
);
1767 * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
1769 * @irq_data: Outermost irq_data associated with interrupt
1770 * @reserve: If set only reserve an interrupt vector instead of assigning one
1772 * This is the second step to call domain_ops->activate to program interrupt
1773 * controllers, so the interrupt could actually get delivered.
1775 int irq_domain_activate_irq(struct irq_data
*irq_data
, bool reserve
)
1779 if (!irqd_is_activated(irq_data
))
1780 ret
= __irq_domain_activate_irq(irq_data
, reserve
);
1782 irqd_set_activated(irq_data
);
1787 * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
1788 * deactivate interrupt
1789 * @irq_data: outermost irq_data associated with interrupt
1791 * It calls domain_ops->deactivate to program interrupt controllers to disable
1792 * interrupt delivery.
1794 void irq_domain_deactivate_irq(struct irq_data
*irq_data
)
1796 if (irqd_is_activated(irq_data
)) {
1797 __irq_domain_deactivate_irq(irq_data
);
1798 irqd_clr_activated(irq_data
);
1802 static void irq_domain_check_hierarchy(struct irq_domain
*domain
)
1804 /* Hierarchy irq_domains must implement callback alloc() */
1805 if (domain
->ops
->alloc
)
1806 domain
->flags
|= IRQ_DOMAIN_FLAG_HIERARCHY
;
1810 * irq_domain_hierarchical_is_msi_remap - Check if the domain or any
1811 * parent has MSI remapping support
1812 * @domain: domain pointer
1814 bool irq_domain_hierarchical_is_msi_remap(struct irq_domain
*domain
)
1816 for (; domain
; domain
= domain
->parent
) {
1817 if (irq_domain_is_msi_remap(domain
))
1822 #else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1824 * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1825 * @domain: domain to match
1826 * @virq: IRQ number to get irq_data
1828 struct irq_data
*irq_domain_get_irq_data(struct irq_domain
*domain
,
1831 struct irq_data
*irq_data
= irq_get_irq_data(virq
);
1833 return (irq_data
&& irq_data
->domain
== domain
) ? irq_data
: NULL
;
1835 EXPORT_SYMBOL_GPL(irq_domain_get_irq_data
);
1838 * irq_domain_set_info - Set the complete data for a @virq in @domain
1839 * @domain: Interrupt domain to match
1841 * @hwirq: The hardware interrupt number
1842 * @chip: The associated interrupt chip
1843 * @chip_data: The associated interrupt chip data
1844 * @handler: The interrupt flow handler
1845 * @handler_data: The interrupt flow handler data
1846 * @handler_name: The interrupt handler name
1848 void irq_domain_set_info(struct irq_domain
*domain
, unsigned int virq
,
1849 irq_hw_number_t hwirq
, struct irq_chip
*chip
,
1850 void *chip_data
, irq_flow_handler_t handler
,
1851 void *handler_data
, const char *handler_name
)
1853 irq_set_chip_and_handler_name(virq
, chip
, handler
, handler_name
);
1854 irq_set_chip_data(virq
, chip_data
);
1855 irq_set_handler_data(virq
, handler_data
);
1858 static void irq_domain_check_hierarchy(struct irq_domain
*domain
)
1861 #endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1863 #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
1864 static struct dentry
*domain_dir
;
1867 irq_domain_debug_show_one(struct seq_file
*m
, struct irq_domain
*d
, int ind
)
1869 seq_printf(m
, "%*sname: %s\n", ind
, "", d
->name
);
1870 seq_printf(m
, "%*ssize: %u\n", ind
+ 1, "",
1871 d
->revmap_size
+ d
->revmap_direct_max_irq
);
1872 seq_printf(m
, "%*smapped: %u\n", ind
+ 1, "", d
->mapcount
);
1873 seq_printf(m
, "%*sflags: 0x%08x\n", ind
+1 , "", d
->flags
);
1874 if (d
->ops
&& d
->ops
->debug_show
)
1875 d
->ops
->debug_show(m
, d
, NULL
, ind
+ 1);
1876 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1879 seq_printf(m
, "%*sparent: %s\n", ind
+ 1, "", d
->parent
->name
);
1880 irq_domain_debug_show_one(m
, d
->parent
, ind
+ 4);
1884 static int irq_domain_debug_show(struct seq_file
*m
, void *p
)
1886 struct irq_domain
*d
= m
->private;
1888 /* Default domain? Might be NULL */
1890 if (!irq_default_domain
)
1892 d
= irq_default_domain
;
1894 irq_domain_debug_show_one(m
, d
, 0);
1897 DEFINE_SHOW_ATTRIBUTE(irq_domain_debug
);
1899 static void debugfs_add_domain_dir(struct irq_domain
*d
)
1901 if (!d
->name
|| !domain_dir
|| d
->debugfs_file
)
1903 d
->debugfs_file
= debugfs_create_file(d
->name
, 0444, domain_dir
, d
,
1904 &irq_domain_debug_fops
);
1907 static void debugfs_remove_domain_dir(struct irq_domain
*d
)
1909 debugfs_remove(d
->debugfs_file
);
1910 d
->debugfs_file
= NULL
;
1913 void __init
irq_domain_debugfs_init(struct dentry
*root
)
1915 struct irq_domain
*d
;
1917 domain_dir
= debugfs_create_dir("domains", root
);
1919 debugfs_create_file("default", 0444, domain_dir
, NULL
,
1920 &irq_domain_debug_fops
);
1921 mutex_lock(&irq_domain_mutex
);
1922 list_for_each_entry(d
, &irq_domain_list
, link
)
1923 debugfs_add_domain_dir(d
);
1924 mutex_unlock(&irq_domain_mutex
);