Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 :
3 : #define pr_fmt(fmt) "irq: " fmt
4 :
5 : #include <linux/acpi.h>
6 : #include <linux/debugfs.h>
7 : #include <linux/hardirq.h>
8 : #include <linux/interrupt.h>
9 : #include <linux/irq.h>
10 : #include <linux/irqdesc.h>
11 : #include <linux/irqdomain.h>
12 : #include <linux/module.h>
13 : #include <linux/mutex.h>
14 : #include <linux/of.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>
21 : #include <linux/fs.h>
22 :
23 : static LIST_HEAD(irq_domain_list);
24 : static DEFINE_MUTEX(irq_domain_mutex);
25 :
26 : static struct irq_domain *irq_default_domain;
27 :
28 : static void irq_domain_check_hierarchy(struct irq_domain *domain);
29 :
30 : struct irqchip_fwid {
31 : struct fwnode_handle fwnode;
32 : unsigned int type;
33 : char *name;
34 : phys_addr_t *pa;
35 : };
36 :
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);
40 : #else
41 : static inline void debugfs_add_domain_dir(struct irq_domain *d) { }
42 : static inline void debugfs_remove_domain_dir(struct irq_domain *d) { }
43 : #endif
44 :
45 0 : static const char *irqchip_fwnode_get_name(const struct fwnode_handle *fwnode)
46 : {
47 0 : struct irqchip_fwid *fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
48 :
49 0 : return fwid->name;
50 : }
51 :
52 : const struct fwnode_operations irqchip_fwnode_ops = {
53 : .get_name = irqchip_fwnode_get_name,
54 : };
55 : EXPORT_SYMBOL_GPL(irqchip_fwnode_ops);
56 :
57 : /**
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
64 : *
65 : * Allocate a struct irqchip_fwid, and return a pointer to the embedded
66 : * fwnode_handle (or NULL on failure).
67 : *
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
71 : * domain struct.
72 : */
73 0 : struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id,
74 : const char *name,
75 : phys_addr_t *pa)
76 : {
77 : struct irqchip_fwid *fwid;
78 : char *n;
79 :
80 0 : fwid = kzalloc(sizeof(*fwid), GFP_KERNEL);
81 :
82 0 : switch (type) {
83 : case IRQCHIP_FWNODE_NAMED:
84 0 : n = kasprintf(GFP_KERNEL, "%s", name);
85 0 : break;
86 : case IRQCHIP_FWNODE_NAMED_ID:
87 0 : n = kasprintf(GFP_KERNEL, "%s-%d", name, id);
88 0 : break;
89 : default:
90 0 : n = kasprintf(GFP_KERNEL, "irqchip@%pa", pa);
91 0 : break;
92 : }
93 :
94 0 : if (!fwid || !n) {
95 0 : kfree(fwid);
96 0 : kfree(n);
97 0 : return NULL;
98 : }
99 :
100 0 : fwid->type = type;
101 0 : fwid->name = n;
102 0 : fwid->pa = pa;
103 0 : fwnode_init(&fwid->fwnode, &irqchip_fwnode_ops);
104 0 : return &fwid->fwnode;
105 : }
106 : EXPORT_SYMBOL_GPL(__irq_domain_alloc_fwnode);
107 :
108 : /**
109 : * irq_domain_free_fwnode - Free a non-OF-backed fwnode_handle
110 : *
111 : * Free a fwnode_handle allocated with irq_domain_alloc_fwnode.
112 : */
113 0 : void irq_domain_free_fwnode(struct fwnode_handle *fwnode)
114 : {
115 : struct irqchip_fwid *fwid;
116 :
117 0 : if (WARN_ON(!is_fwnode_irqchip(fwnode)))
118 : return;
119 :
120 0 : fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
121 0 : kfree(fwid->name);
122 0 : kfree(fwid);
123 : }
124 : EXPORT_SYMBOL_GPL(irq_domain_free_fwnode);
125 :
126 : /**
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
132 : * direct mapping
133 : * @ops: domain callbacks
134 : * @host_data: Controller private data pointer
135 : *
136 : * Allocates and initializes an irq_domain structure.
137 : * Returns pointer to IRQ domain, or NULL on failure.
138 : */
139 0 : 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,
142 : void *host_data)
143 : {
144 : struct irqchip_fwid *fwid;
145 : struct irq_domain *domain;
146 :
147 : static atomic_t unknown_domains;
148 :
149 0 : if (WARN_ON((size && direct_max) ||
150 : (!IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP) && direct_max)))
151 : return NULL;
152 :
153 0 : domain = kzalloc_node(struct_size(domain, revmap, size),
154 : GFP_KERNEL, of_node_to_nid(to_of_node(fwnode)));
155 0 : if (!domain)
156 : return NULL;
157 :
158 0 : if (is_fwnode_irqchip(fwnode)) {
159 0 : fwid = container_of(fwnode, struct irqchip_fwid, fwnode);
160 :
161 0 : switch (fwid->type) {
162 : case IRQCHIP_FWNODE_NAMED:
163 : case IRQCHIP_FWNODE_NAMED_ID:
164 0 : domain->fwnode = fwnode;
165 0 : domain->name = kstrdup(fwid->name, GFP_KERNEL);
166 0 : if (!domain->name) {
167 0 : kfree(domain);
168 0 : return NULL;
169 : }
170 0 : domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
171 0 : break;
172 : default:
173 0 : domain->fwnode = fwnode;
174 0 : domain->name = fwid->name;
175 0 : break;
176 : }
177 0 : } else if (is_of_node(fwnode) || is_acpi_device_node(fwnode) ||
178 0 : is_software_node(fwnode)) {
179 : char *name;
180 :
181 : /*
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 '\'...
185 : */
186 0 : name = kasprintf(GFP_KERNEL, "%pfw", fwnode);
187 0 : if (!name) {
188 0 : kfree(domain);
189 0 : return NULL;
190 : }
191 :
192 0 : strreplace(name, '/', ':');
193 :
194 0 : domain->name = name;
195 0 : domain->fwnode = fwnode;
196 0 : domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
197 : }
198 :
199 0 : if (!domain->name) {
200 0 : if (fwnode)
201 0 : pr_err("Invalid fwnode type for irqdomain\n");
202 0 : domain->name = kasprintf(GFP_KERNEL, "unknown-%d",
203 : atomic_inc_return(&unknown_domains));
204 0 : if (!domain->name) {
205 0 : kfree(domain);
206 0 : return NULL;
207 : }
208 0 : domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
209 : }
210 :
211 0 : fwnode_handle_get(fwnode);
212 0 : fwnode_dev_initialized(fwnode, true);
213 :
214 : /* Fill structure */
215 0 : INIT_RADIX_TREE(&domain->revmap_tree, GFP_KERNEL);
216 0 : mutex_init(&domain->revmap_mutex);
217 0 : domain->ops = ops;
218 0 : domain->host_data = host_data;
219 0 : domain->hwirq_max = hwirq_max;
220 :
221 0 : if (direct_max) {
222 0 : size = direct_max;
223 0 : domain->flags |= IRQ_DOMAIN_FLAG_NO_MAP;
224 : }
225 :
226 0 : domain->revmap_size = size;
227 :
228 0 : irq_domain_check_hierarchy(domain);
229 :
230 0 : mutex_lock(&irq_domain_mutex);
231 0 : debugfs_add_domain_dir(domain);
232 0 : list_add(&domain->link, &irq_domain_list);
233 0 : mutex_unlock(&irq_domain_mutex);
234 :
235 : pr_debug("Added domain %s\n", domain->name);
236 0 : return domain;
237 : }
238 : EXPORT_SYMBOL_GPL(__irq_domain_add);
239 :
240 : /**
241 : * irq_domain_remove() - Remove an irq domain.
242 : * @domain: domain to remove
243 : *
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.
247 : */
248 0 : void irq_domain_remove(struct irq_domain *domain)
249 : {
250 0 : mutex_lock(&irq_domain_mutex);
251 0 : debugfs_remove_domain_dir(domain);
252 :
253 0 : WARN_ON(!radix_tree_empty(&domain->revmap_tree));
254 :
255 0 : list_del(&domain->link);
256 :
257 : /*
258 : * If the going away domain is the default one, reset it.
259 : */
260 0 : if (unlikely(irq_default_domain == domain))
261 : irq_set_default_host(NULL);
262 :
263 0 : mutex_unlock(&irq_domain_mutex);
264 :
265 : pr_debug("Removed domain %s\n", domain->name);
266 :
267 0 : fwnode_dev_initialized(domain->fwnode, false);
268 0 : fwnode_handle_put(domain->fwnode);
269 0 : if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED)
270 0 : kfree(domain->name);
271 0 : kfree(domain);
272 0 : }
273 : EXPORT_SYMBOL_GPL(irq_domain_remove);
274 :
275 0 : void irq_domain_update_bus_token(struct irq_domain *domain,
276 : enum irq_domain_bus_token bus_token)
277 : {
278 : char *name;
279 :
280 0 : if (domain->bus_token == bus_token)
281 : return;
282 :
283 0 : mutex_lock(&irq_domain_mutex);
284 :
285 0 : domain->bus_token = bus_token;
286 :
287 0 : name = kasprintf(GFP_KERNEL, "%s-%d", domain->name, bus_token);
288 0 : if (!name) {
289 0 : mutex_unlock(&irq_domain_mutex);
290 0 : return;
291 : }
292 :
293 0 : debugfs_remove_domain_dir(domain);
294 :
295 0 : if (domain->flags & IRQ_DOMAIN_NAME_ALLOCATED)
296 0 : kfree(domain->name);
297 : else
298 0 : domain->flags |= IRQ_DOMAIN_NAME_ALLOCATED;
299 :
300 0 : domain->name = name;
301 0 : debugfs_add_domain_dir(domain);
302 :
303 0 : mutex_unlock(&irq_domain_mutex);
304 : }
305 : EXPORT_SYMBOL_GPL(irq_domain_update_bus_token);
306 :
307 : /**
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
316 : *
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.
319 : *
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.
324 : */
325 0 : struct irq_domain *irq_domain_create_simple(struct fwnode_handle *fwnode,
326 : unsigned int size,
327 : unsigned int first_irq,
328 : const struct irq_domain_ops *ops,
329 : void *host_data)
330 : {
331 : struct irq_domain *domain;
332 :
333 0 : domain = __irq_domain_add(fwnode, size, size, 0, ops, host_data);
334 0 : if (!domain)
335 : return NULL;
336 :
337 0 : if (first_irq > 0) {
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)));
342 : if (rc < 0)
343 : pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
344 : first_irq);
345 : }
346 0 : irq_domain_associate_many(domain, first_irq, 0, size);
347 : }
348 :
349 : return domain;
350 : }
351 : EXPORT_SYMBOL_GPL(irq_domain_create_simple);
352 :
353 : /**
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
363 : *
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).
367 : */
368 0 : struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
369 : unsigned int size,
370 : unsigned int first_irq,
371 : irq_hw_number_t first_hwirq,
372 : const struct irq_domain_ops *ops,
373 : void *host_data)
374 : {
375 0 : return irq_domain_create_legacy(of_node_to_fwnode(of_node), size,
376 : first_irq, first_hwirq, ops, host_data);
377 : }
378 : EXPORT_SYMBOL_GPL(irq_domain_add_legacy);
379 :
380 0 : struct irq_domain *irq_domain_create_legacy(struct fwnode_handle *fwnode,
381 : unsigned int size,
382 : unsigned int first_irq,
383 : irq_hw_number_t first_hwirq,
384 : const struct irq_domain_ops *ops,
385 : void *host_data)
386 : {
387 : struct irq_domain *domain;
388 :
389 0 : domain = __irq_domain_add(fwnode, first_hwirq + size, first_hwirq + size, 0, ops, host_data);
390 0 : if (domain)
391 0 : irq_domain_associate_many(domain, first_irq, first_hwirq, size);
392 :
393 0 : return domain;
394 : }
395 : EXPORT_SYMBOL_GPL(irq_domain_create_legacy);
396 :
397 : /**
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
401 : */
402 0 : struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
403 : enum irq_domain_bus_token bus_token)
404 : {
405 0 : struct irq_domain *h, *found = NULL;
406 0 : struct fwnode_handle *fwnode = fwspec->fwnode;
407 : int rc;
408 :
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
412 : * yet though...
413 : *
414 : * bus_token == DOMAIN_BUS_ANY matches any domain, any other
415 : * values must generate an exact match for the domain to be
416 : * selected.
417 : */
418 0 : mutex_lock(&irq_domain_mutex);
419 0 : list_for_each_entry(h, &irq_domain_list, link) {
420 0 : if (h->ops->select && fwspec->param_count)
421 0 : rc = h->ops->select(h, fwspec, bus_token);
422 0 : else if (h->ops->match)
423 0 : rc = h->ops->match(h, to_of_node(fwnode), bus_token);
424 : else
425 0 : rc = ((fwnode != NULL) && (h->fwnode == fwnode) &&
426 0 : ((bus_token == DOMAIN_BUS_ANY) ||
427 0 : (h->bus_token == bus_token)));
428 :
429 0 : if (rc) {
430 : found = h;
431 : break;
432 : }
433 : }
434 0 : mutex_unlock(&irq_domain_mutex);
435 0 : return found;
436 : }
437 : EXPORT_SYMBOL_GPL(irq_find_matching_fwspec);
438 :
439 : /**
440 : * irq_domain_check_msi_remap - Check whether all MSI irq domains implement
441 : * IRQ remapping
442 : *
443 : * Return: false if any MSI irq domain does not support IRQ remapping,
444 : * true otherwise (including if there is no MSI irq domain)
445 : */
446 0 : bool irq_domain_check_msi_remap(void)
447 : {
448 : struct irq_domain *h;
449 0 : bool ret = true;
450 :
451 0 : mutex_lock(&irq_domain_mutex);
452 0 : list_for_each_entry(h, &irq_domain_list, link) {
453 0 : if (irq_domain_is_msi(h) &&
454 0 : !irq_domain_hierarchical_is_msi_remap(h)) {
455 : ret = false;
456 : break;
457 : }
458 : }
459 0 : mutex_unlock(&irq_domain_mutex);
460 0 : return ret;
461 : }
462 : EXPORT_SYMBOL_GPL(irq_domain_check_msi_remap);
463 :
464 : /**
465 : * irq_set_default_host() - Set a "default" irq domain
466 : * @domain: default domain pointer
467 : *
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.
472 : */
473 0 : void irq_set_default_host(struct irq_domain *domain)
474 : {
475 : pr_debug("Default domain set to @0x%p\n", domain);
476 :
477 0 : irq_default_domain = domain;
478 0 : }
479 : EXPORT_SYMBOL_GPL(irq_set_default_host);
480 :
481 : /**
482 : * irq_get_default_host() - Retrieve the "default" irq domain
483 : *
484 : * Returns: the default domain, if any.
485 : *
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).
489 : */
490 0 : struct irq_domain *irq_get_default_host(void)
491 : {
492 0 : return irq_default_domain;
493 : }
494 : EXPORT_SYMBOL_GPL(irq_get_default_host);
495 :
496 : static bool irq_domain_is_nomap(struct irq_domain *domain)
497 : {
498 : return IS_ENABLED(CONFIG_IRQ_DOMAIN_NOMAP) &&
499 : (domain->flags & IRQ_DOMAIN_FLAG_NO_MAP);
500 : }
501 :
502 0 : static void irq_domain_clear_mapping(struct irq_domain *domain,
503 : irq_hw_number_t hwirq)
504 : {
505 0 : if (irq_domain_is_nomap(domain))
506 : return;
507 :
508 0 : mutex_lock(&domain->revmap_mutex);
509 0 : if (hwirq < domain->revmap_size)
510 0 : rcu_assign_pointer(domain->revmap[hwirq], NULL);
511 : else
512 0 : radix_tree_delete(&domain->revmap_tree, hwirq);
513 0 : mutex_unlock(&domain->revmap_mutex);
514 : }
515 :
516 0 : static void irq_domain_set_mapping(struct irq_domain *domain,
517 : irq_hw_number_t hwirq,
518 : struct irq_data *irq_data)
519 : {
520 0 : if (irq_domain_is_nomap(domain))
521 : return;
522 :
523 0 : mutex_lock(&domain->revmap_mutex);
524 0 : if (hwirq < domain->revmap_size)
525 0 : rcu_assign_pointer(domain->revmap[hwirq], irq_data);
526 : else
527 0 : radix_tree_insert(&domain->revmap_tree, hwirq, irq_data);
528 0 : mutex_unlock(&domain->revmap_mutex);
529 : }
530 :
531 0 : static void irq_domain_disassociate(struct irq_domain *domain, unsigned int irq)
532 : {
533 0 : struct irq_data *irq_data = irq_get_irq_data(irq);
534 : irq_hw_number_t hwirq;
535 :
536 0 : if (WARN(!irq_data || irq_data->domain != domain,
537 : "virq%i doesn't exist; cannot disassociate\n", irq))
538 : return;
539 :
540 0 : hwirq = irq_data->hwirq;
541 0 : irq_set_status_flags(irq, IRQ_NOREQUEST);
542 :
543 : /* remove chip and handler */
544 0 : irq_set_chip_and_handler(irq, NULL, NULL);
545 :
546 : /* Make sure it's completed */
547 0 : synchronize_irq(irq);
548 :
549 : /* Tell the PIC about it */
550 0 : if (domain->ops->unmap)
551 0 : domain->ops->unmap(domain, irq);
552 0 : smp_mb();
553 :
554 0 : irq_data->domain = NULL;
555 0 : irq_data->hwirq = 0;
556 0 : domain->mapcount--;
557 :
558 : /* Clear reverse map for this hwirq */
559 0 : irq_domain_clear_mapping(domain, hwirq);
560 : }
561 :
562 0 : int irq_domain_associate(struct irq_domain *domain, unsigned int virq,
563 : irq_hw_number_t hwirq)
564 : {
565 0 : struct irq_data *irq_data = irq_get_irq_data(virq);
566 : int ret;
567 :
568 0 : if (WARN(hwirq >= domain->hwirq_max,
569 : "error: hwirq 0x%x is too large for %s\n", (int)hwirq, domain->name))
570 : return -EINVAL;
571 0 : if (WARN(!irq_data, "error: virq%i is not allocated", virq))
572 : return -EINVAL;
573 0 : if (WARN(irq_data->domain, "error: virq%i is already associated", virq))
574 : return -EINVAL;
575 :
576 0 : mutex_lock(&irq_domain_mutex);
577 0 : irq_data->hwirq = hwirq;
578 0 : irq_data->domain = domain;
579 0 : if (domain->ops->map) {
580 0 : ret = domain->ops->map(domain, virq, hwirq);
581 0 : if (ret != 0) {
582 : /*
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.
586 : */
587 0 : if (ret != -EPERM) {
588 0 : pr_info("%s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d)\n",
589 : domain->name, hwirq, virq, ret);
590 : }
591 0 : irq_data->domain = NULL;
592 0 : irq_data->hwirq = 0;
593 0 : mutex_unlock(&irq_domain_mutex);
594 0 : return ret;
595 : }
596 :
597 : /* If not already assigned, give the domain the chip's name */
598 0 : if (!domain->name && irq_data->chip)
599 0 : domain->name = irq_data->chip->name;
600 : }
601 :
602 0 : domain->mapcount++;
603 0 : irq_domain_set_mapping(domain, hwirq, irq_data);
604 0 : mutex_unlock(&irq_domain_mutex);
605 :
606 0 : irq_clear_status_flags(virq, IRQ_NOREQUEST);
607 :
608 0 : return 0;
609 : }
610 : EXPORT_SYMBOL_GPL(irq_domain_associate);
611 :
612 0 : void irq_domain_associate_many(struct irq_domain *domain, unsigned int irq_base,
613 : irq_hw_number_t hwirq_base, int count)
614 : {
615 : struct device_node *of_node;
616 : int i;
617 :
618 0 : 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);
621 :
622 0 : for (i = 0; i < count; i++) {
623 0 : irq_domain_associate(domain, irq_base + i, hwirq_base + i);
624 : }
625 0 : }
626 : EXPORT_SYMBOL_GPL(irq_domain_associate_many);
627 :
628 : #ifdef CONFIG_IRQ_DOMAIN_NOMAP
629 : /**
630 : * irq_create_direct_mapping() - Allocate an irq for direct mapping
631 : * @domain: domain to allocate the irq for or NULL for default domain
632 : *
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.
638 : */
639 : unsigned int irq_create_direct_mapping(struct irq_domain *domain)
640 : {
641 : struct device_node *of_node;
642 : unsigned int virq;
643 :
644 : if (domain == NULL)
645 : domain = irq_default_domain;
646 :
647 : of_node = irq_domain_get_of_node(domain);
648 : virq = irq_alloc_desc_from(1, of_node_to_nid(of_node));
649 : if (!virq) {
650 : pr_debug("create_direct virq allocation failed\n");
651 : return 0;
652 : }
653 : if (virq >= domain->revmap_size) {
654 : pr_err("ERROR: no free irqs available below %i maximum\n",
655 : domain->revmap_size);
656 : irq_free_desc(virq);
657 : return 0;
658 : }
659 : pr_debug("create_direct obtained virq %d\n", virq);
660 :
661 : if (irq_domain_associate(domain, virq, virq)) {
662 : irq_free_desc(virq);
663 : return 0;
664 : }
665 :
666 : return virq;
667 : }
668 : EXPORT_SYMBOL_GPL(irq_create_direct_mapping);
669 : #endif
670 :
671 : /**
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
676 : *
677 : * Only one mapping per hardware interrupt is permitted. Returns a linux
678 : * irq number.
679 : * If the sense/trigger is to be specified, set_irq_type() should be called
680 : * on the number returned from that call.
681 : */
682 0 : unsigned int irq_create_mapping_affinity(struct irq_domain *domain,
683 : irq_hw_number_t hwirq,
684 : const struct irq_affinity_desc *affinity)
685 : {
686 : struct device_node *of_node;
687 : int virq;
688 :
689 : pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
690 :
691 : /* Look for default domain if necessary */
692 0 : if (domain == NULL)
693 0 : domain = irq_default_domain;
694 0 : if (domain == NULL) {
695 0 : WARN(1, "%s(, %lx) called with NULL domain\n", __func__, hwirq);
696 0 : return 0;
697 : }
698 : pr_debug("-> using domain @%p\n", domain);
699 :
700 0 : of_node = irq_domain_get_of_node(domain);
701 :
702 : /* Check if mapping already exists */
703 0 : virq = irq_find_mapping(domain, hwirq);
704 0 : if (virq) {
705 : pr_debug("-> existing mapping on virq %d\n", virq);
706 : return virq;
707 : }
708 :
709 : /* Allocate a virtual interrupt number */
710 0 : virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node),
711 : affinity);
712 0 : if (virq <= 0) {
713 : pr_debug("-> virq allocation failed\n");
714 : return 0;
715 : }
716 :
717 0 : if (irq_domain_associate(domain, virq, hwirq)) {
718 0 : irq_free_desc(virq);
719 0 : return 0;
720 : }
721 :
722 : pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
723 : hwirq, of_node_full_name(of_node), virq);
724 :
725 : return virq;
726 : }
727 : EXPORT_SYMBOL_GPL(irq_create_mapping_affinity);
728 :
729 0 : static int irq_domain_translate(struct irq_domain *d,
730 : struct irq_fwspec *fwspec,
731 : irq_hw_number_t *hwirq, unsigned int *type)
732 : {
733 : #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
734 0 : if (d->ops->translate)
735 0 : return d->ops->translate(d, fwspec, hwirq, type);
736 : #endif
737 0 : if (d->ops->xlate)
738 0 : return d->ops->xlate(d, to_of_node(fwspec->fwnode),
739 0 : fwspec->param, fwspec->param_count,
740 : hwirq, type);
741 :
742 : /* If domain has no translation, then we assume interrupt line */
743 0 : *hwirq = fwspec->param[0];
744 0 : return 0;
745 : }
746 :
747 0 : void of_phandle_args_to_fwspec(struct device_node *np, const u32 *args,
748 : unsigned int count, struct irq_fwspec *fwspec)
749 : {
750 : int i;
751 :
752 0 : fwspec->fwnode = of_node_to_fwnode(np);
753 0 : fwspec->param_count = count;
754 :
755 0 : for (i = 0; i < count; i++)
756 0 : fwspec->param[i] = args[i];
757 0 : }
758 : EXPORT_SYMBOL_GPL(of_phandle_args_to_fwspec);
759 :
760 0 : unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec)
761 : {
762 : struct irq_domain *domain;
763 : struct irq_data *irq_data;
764 : irq_hw_number_t hwirq;
765 0 : unsigned int type = IRQ_TYPE_NONE;
766 : int virq;
767 :
768 0 : if (fwspec->fwnode) {
769 0 : domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_WIRED);
770 0 : if (!domain)
771 0 : domain = irq_find_matching_fwspec(fwspec, DOMAIN_BUS_ANY);
772 : } else {
773 0 : domain = irq_default_domain;
774 : }
775 :
776 0 : if (!domain) {
777 0 : pr_warn("no irq domain found for %s !\n",
778 : of_node_full_name(to_of_node(fwspec->fwnode)));
779 0 : return 0;
780 : }
781 :
782 0 : if (irq_domain_translate(domain, fwspec, &hwirq, &type))
783 : return 0;
784 :
785 : /*
786 : * WARN if the irqchip returns a type with bits
787 : * outside the sense mask set and clear these bits.
788 : */
789 0 : if (WARN_ON(type & ~IRQ_TYPE_SENSE_MASK))
790 0 : type &= IRQ_TYPE_SENSE_MASK;
791 :
792 : /*
793 : * If we've already configured this interrupt,
794 : * don't do it again, or hell will break loose.
795 : */
796 0 : virq = irq_find_mapping(domain, hwirq);
797 0 : if (virq) {
798 : /*
799 : * If the trigger type is not specified or matches the
800 : * current trigger type then we are done so return the
801 : * interrupt number.
802 : */
803 0 : if (type == IRQ_TYPE_NONE || type == irq_get_trigger_type(virq))
804 : return virq;
805 :
806 : /*
807 : * If the trigger type has not been set yet, then set
808 : * it now and return the interrupt number.
809 : */
810 0 : if (irq_get_trigger_type(virq) == IRQ_TYPE_NONE) {
811 0 : irq_data = irq_get_irq_data(virq);
812 0 : if (!irq_data)
813 : return 0;
814 :
815 0 : irqd_set_trigger_type(irq_data, type);
816 0 : return virq;
817 : }
818 :
819 0 : pr_warn("type mismatch, failed to map hwirq-%lu for %s!\n",
820 : hwirq, of_node_full_name(to_of_node(fwspec->fwnode)));
821 0 : return 0;
822 : }
823 :
824 0 : if (irq_domain_is_hierarchy(domain)) {
825 0 : virq = irq_domain_alloc_irqs(domain, 1, NUMA_NO_NODE, fwspec);
826 0 : if (virq <= 0)
827 : return 0;
828 : } else {
829 : /* Create mapping */
830 0 : virq = irq_create_mapping(domain, hwirq);
831 0 : if (!virq)
832 : return virq;
833 : }
834 :
835 0 : irq_data = irq_get_irq_data(virq);
836 0 : if (!irq_data) {
837 0 : if (irq_domain_is_hierarchy(domain))
838 0 : irq_domain_free_irqs(virq, 1);
839 : else
840 0 : irq_dispose_mapping(virq);
841 : return 0;
842 : }
843 :
844 : /* Store trigger type */
845 0 : irqd_set_trigger_type(irq_data, type);
846 :
847 0 : return virq;
848 : }
849 : EXPORT_SYMBOL_GPL(irq_create_fwspec_mapping);
850 :
851 0 : unsigned int irq_create_of_mapping(struct of_phandle_args *irq_data)
852 : {
853 : struct irq_fwspec fwspec;
854 :
855 0 : of_phandle_args_to_fwspec(irq_data->np, irq_data->args,
856 0 : irq_data->args_count, &fwspec);
857 :
858 0 : return irq_create_fwspec_mapping(&fwspec);
859 : }
860 : EXPORT_SYMBOL_GPL(irq_create_of_mapping);
861 :
862 : /**
863 : * irq_dispose_mapping() - Unmap an interrupt
864 : * @virq: linux irq number of the interrupt to unmap
865 : */
866 0 : void irq_dispose_mapping(unsigned int virq)
867 : {
868 0 : struct irq_data *irq_data = irq_get_irq_data(virq);
869 : struct irq_domain *domain;
870 :
871 0 : if (!virq || !irq_data)
872 : return;
873 :
874 0 : domain = irq_data->domain;
875 0 : if (WARN_ON(domain == NULL))
876 : return;
877 :
878 0 : if (irq_domain_is_hierarchy(domain)) {
879 0 : irq_domain_free_irqs(virq, 1);
880 : } else {
881 0 : irq_domain_disassociate(domain, virq);
882 : irq_free_desc(virq);
883 : }
884 : }
885 : EXPORT_SYMBOL_GPL(irq_dispose_mapping);
886 :
887 : /**
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
892 : *
893 : * Returns the interrupt descriptor.
894 : */
895 0 : struct irq_desc *__irq_resolve_mapping(struct irq_domain *domain,
896 : irq_hw_number_t hwirq,
897 : unsigned int *irq)
898 : {
899 0 : struct irq_desc *desc = NULL;
900 : struct irq_data *data;
901 :
902 : /* Look for default domain if necessary */
903 0 : if (domain == NULL)
904 0 : domain = irq_default_domain;
905 0 : if (domain == NULL)
906 : return desc;
907 :
908 0 : 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);
913 : }
914 :
915 : return desc;
916 : }
917 :
918 : rcu_read_lock();
919 : /* Check if the hwirq is in the linear revmap. */
920 0 : if (hwirq < domain->revmap_size)
921 0 : data = rcu_dereference(domain->revmap[hwirq]);
922 : else
923 0 : data = radix_tree_lookup(&domain->revmap_tree, hwirq);
924 :
925 0 : if (likely(data)) {
926 0 : desc = irq_data_to_desc(data);
927 0 : if (irq)
928 0 : *irq = data->irq;
929 : }
930 :
931 : rcu_read_unlock();
932 0 : return desc;
933 : }
934 : EXPORT_SYMBOL_GPL(__irq_resolve_mapping);
935 :
936 : /**
937 : * irq_domain_xlate_onecell() - Generic xlate for direct one cell bindings
938 : *
939 : * Device Tree IRQ specifier translation function which works with one cell
940 : * bindings where the cell value maps directly to the hwirq number.
941 : */
942 0 : 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)
945 : {
946 0 : if (WARN_ON(intsize < 1))
947 : return -EINVAL;
948 0 : *out_hwirq = intspec[0];
949 0 : *out_type = IRQ_TYPE_NONE;
950 0 : return 0;
951 : }
952 : EXPORT_SYMBOL_GPL(irq_domain_xlate_onecell);
953 :
954 : /**
955 : * irq_domain_xlate_twocell() - Generic xlate for direct two cell bindings
956 : *
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.
960 : */
961 0 : 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)
964 : {
965 : struct irq_fwspec fwspec;
966 :
967 0 : of_phandle_args_to_fwspec(ctrlr, intspec, intsize, &fwspec);
968 0 : return irq_domain_translate_twocell(d, &fwspec, out_hwirq, out_type);
969 : }
970 : EXPORT_SYMBOL_GPL(irq_domain_xlate_twocell);
971 :
972 : /**
973 : * irq_domain_xlate_onetwocell() - Generic xlate for one or two cell bindings
974 : *
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.
978 : *
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.
982 : */
983 0 : 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)
987 : {
988 0 : if (WARN_ON(intsize < 1))
989 : return -EINVAL;
990 0 : *out_hwirq = intspec[0];
991 0 : if (intsize > 1)
992 0 : *out_type = intspec[1] & IRQ_TYPE_SENSE_MASK;
993 : else
994 0 : *out_type = IRQ_TYPE_NONE;
995 : return 0;
996 : }
997 : EXPORT_SYMBOL_GPL(irq_domain_xlate_onetwocell);
998 :
999 : const struct irq_domain_ops irq_domain_simple_ops = {
1000 : .xlate = irq_domain_xlate_onetwocell,
1001 : };
1002 : EXPORT_SYMBOL_GPL(irq_domain_simple_ops);
1003 :
1004 : /**
1005 : * irq_domain_translate_onecell() - Generic translate for direct one cell
1006 : * bindings
1007 : */
1008 0 : int irq_domain_translate_onecell(struct irq_domain *d,
1009 : struct irq_fwspec *fwspec,
1010 : unsigned long *out_hwirq,
1011 : unsigned int *out_type)
1012 : {
1013 0 : if (WARN_ON(fwspec->param_count < 1))
1014 : return -EINVAL;
1015 0 : *out_hwirq = fwspec->param[0];
1016 0 : *out_type = IRQ_TYPE_NONE;
1017 0 : return 0;
1018 : }
1019 : EXPORT_SYMBOL_GPL(irq_domain_translate_onecell);
1020 :
1021 : /**
1022 : * irq_domain_translate_twocell() - Generic translate for direct two cell
1023 : * bindings
1024 : *
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.
1028 : */
1029 0 : int irq_domain_translate_twocell(struct irq_domain *d,
1030 : struct irq_fwspec *fwspec,
1031 : unsigned long *out_hwirq,
1032 : unsigned int *out_type)
1033 : {
1034 0 : if (WARN_ON(fwspec->param_count < 2))
1035 : return -EINVAL;
1036 0 : *out_hwirq = fwspec->param[0];
1037 0 : *out_type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK;
1038 0 : return 0;
1039 : }
1040 : EXPORT_SYMBOL_GPL(irq_domain_translate_twocell);
1041 :
1042 0 : int irq_domain_alloc_descs(int virq, unsigned int cnt, irq_hw_number_t hwirq,
1043 : int node, const struct irq_affinity_desc *affinity)
1044 : {
1045 : unsigned int hint;
1046 :
1047 0 : if (virq >= 0) {
1048 0 : virq = __irq_alloc_descs(virq, virq, cnt, node, THIS_MODULE,
1049 : affinity);
1050 : } else {
1051 0 : hint = hwirq % nr_irqs;
1052 0 : if (hint == 0)
1053 0 : hint++;
1054 0 : virq = __irq_alloc_descs(-1, hint, cnt, node, THIS_MODULE,
1055 : affinity);
1056 0 : if (virq <= 0 && hint > 1) {
1057 0 : virq = __irq_alloc_descs(-1, 1, cnt, node, THIS_MODULE,
1058 : affinity);
1059 : }
1060 : }
1061 :
1062 0 : return virq;
1063 : }
1064 :
1065 : /**
1066 : * irq_domain_reset_irq_data - Clear hwirq, chip and chip_data in @irq_data
1067 : * @irq_data: The pointer to irq_data
1068 : */
1069 0 : void irq_domain_reset_irq_data(struct irq_data *irq_data)
1070 : {
1071 0 : irq_data->hwirq = 0;
1072 0 : irq_data->chip = &no_irq_chip;
1073 0 : irq_data->chip_data = NULL;
1074 0 : }
1075 : EXPORT_SYMBOL_GPL(irq_domain_reset_irq_data);
1076 :
1077 : #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1078 : /**
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
1086 : *
1087 : * If @size is 0 a tree domain is created, otherwise a linear domain.
1088 : *
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.
1092 : */
1093 0 : struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
1094 : unsigned int flags,
1095 : unsigned int size,
1096 : struct fwnode_handle *fwnode,
1097 : const struct irq_domain_ops *ops,
1098 : void *host_data)
1099 : {
1100 : struct irq_domain *domain;
1101 :
1102 0 : if (size)
1103 0 : domain = irq_domain_create_linear(fwnode, size, ops, host_data);
1104 : else
1105 0 : domain = irq_domain_create_tree(fwnode, ops, host_data);
1106 0 : if (domain) {
1107 0 : domain->parent = parent;
1108 0 : domain->flags |= flags;
1109 : }
1110 :
1111 0 : return domain;
1112 : }
1113 : EXPORT_SYMBOL_GPL(irq_domain_create_hierarchy);
1114 :
1115 0 : static void irq_domain_insert_irq(int virq)
1116 : {
1117 : struct irq_data *data;
1118 :
1119 0 : for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
1120 0 : struct irq_domain *domain = data->domain;
1121 :
1122 0 : domain->mapcount++;
1123 0 : irq_domain_set_mapping(domain, data->hwirq, data);
1124 :
1125 : /* If not already assigned, give the domain the chip's name */
1126 0 : if (!domain->name && data->chip)
1127 0 : domain->name = data->chip->name;
1128 : }
1129 :
1130 0 : irq_clear_status_flags(virq, IRQ_NOREQUEST);
1131 0 : }
1132 :
1133 0 : static void irq_domain_remove_irq(int virq)
1134 : {
1135 : struct irq_data *data;
1136 :
1137 0 : irq_set_status_flags(virq, IRQ_NOREQUEST);
1138 0 : irq_set_chip_and_handler(virq, NULL, NULL);
1139 0 : synchronize_irq(virq);
1140 0 : smp_mb();
1141 :
1142 0 : for (data = irq_get_irq_data(virq); data; data = data->parent_data) {
1143 0 : struct irq_domain *domain = data->domain;
1144 0 : irq_hw_number_t hwirq = data->hwirq;
1145 :
1146 0 : domain->mapcount--;
1147 0 : irq_domain_clear_mapping(domain, hwirq);
1148 : }
1149 0 : }
1150 :
1151 0 : static struct irq_data *irq_domain_insert_irq_data(struct irq_domain *domain,
1152 : struct irq_data *child)
1153 : {
1154 : struct irq_data *irq_data;
1155 :
1156 0 : irq_data = kzalloc_node(sizeof(*irq_data), GFP_KERNEL,
1157 : irq_data_get_node(child));
1158 0 : if (irq_data) {
1159 0 : child->parent_data = irq_data;
1160 0 : irq_data->irq = child->irq;
1161 0 : irq_data->common = child->common;
1162 0 : irq_data->domain = domain;
1163 : }
1164 :
1165 0 : return irq_data;
1166 : }
1167 :
1168 : static void __irq_domain_free_hierarchy(struct irq_data *irq_data)
1169 : {
1170 : struct irq_data *tmp;
1171 :
1172 0 : while (irq_data) {
1173 0 : tmp = irq_data;
1174 0 : irq_data = irq_data->parent_data;
1175 0 : kfree(tmp);
1176 : }
1177 : }
1178 :
1179 0 : static void irq_domain_free_irq_data(unsigned int virq, unsigned int nr_irqs)
1180 : {
1181 : struct irq_data *irq_data, *tmp;
1182 : int i;
1183 :
1184 0 : for (i = 0; i < nr_irqs; i++) {
1185 0 : irq_data = irq_get_irq_data(virq + i);
1186 0 : tmp = irq_data->parent_data;
1187 0 : irq_data->parent_data = NULL;
1188 0 : irq_data->domain = NULL;
1189 :
1190 0 : __irq_domain_free_hierarchy(tmp);
1191 : }
1192 0 : }
1193 :
1194 : /**
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
1198 : *
1199 : * Marks the @virq level belonging to @domain as disconnected.
1200 : * Returns -EINVAL if @virq doesn't have a valid irq_data pointing
1201 : * to @domain.
1202 : *
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.
1206 : */
1207 0 : int irq_domain_disconnect_hierarchy(struct irq_domain *domain,
1208 : unsigned int virq)
1209 : {
1210 : struct irq_data *irqd;
1211 :
1212 0 : irqd = irq_domain_get_irq_data(domain, virq);
1213 0 : if (!irqd)
1214 : return -EINVAL;
1215 :
1216 0 : irqd->chip = ERR_PTR(-ENOTCONN);
1217 0 : return 0;
1218 : }
1219 : EXPORT_SYMBOL_GPL(irq_domain_disconnect_hierarchy);
1220 :
1221 0 : static int irq_domain_trim_hierarchy(unsigned int virq)
1222 : {
1223 : struct irq_data *tail, *irqd, *irq_data;
1224 :
1225 0 : irq_data = irq_get_irq_data(virq);
1226 0 : tail = NULL;
1227 :
1228 : /* The first entry must have a valid irqchip */
1229 0 : if (!irq_data->chip || IS_ERR(irq_data->chip))
1230 : return -EINVAL;
1231 :
1232 : /*
1233 : * Validate that the irq_data chain is sane in the presence of
1234 : * a hierarchy trimming marker.
1235 : */
1236 0 : 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 0 : if (irqd->chip && tail)
1239 : return -EINVAL;
1240 :
1241 : /* Can't have an empty irqchip before a trim marker */
1242 0 : if (!irqd->chip && !tail)
1243 : return -EINVAL;
1244 :
1245 0 : if (IS_ERR(irqd->chip)) {
1246 : /* Only -ENOTCONN is a valid trim marker */
1247 0 : if (PTR_ERR(irqd->chip) != -ENOTCONN)
1248 : return -EINVAL;
1249 :
1250 : tail = irq_data;
1251 : }
1252 : }
1253 :
1254 : /* No trim marker, nothing to do */
1255 0 : if (!tail)
1256 : return 0;
1257 :
1258 0 : pr_info("IRQ%d: trimming hierarchy from %s\n",
1259 : virq, tail->parent_data->domain->name);
1260 :
1261 : /* Sever the inner part of the hierarchy... */
1262 0 : irqd = tail;
1263 0 : tail = tail->parent_data;
1264 0 : irqd->parent_data = NULL;
1265 : __irq_domain_free_hierarchy(tail);
1266 :
1267 : return 0;
1268 : }
1269 :
1270 0 : static int irq_domain_alloc_irq_data(struct irq_domain *domain,
1271 : unsigned int virq, unsigned int nr_irqs)
1272 : {
1273 : struct irq_data *irq_data;
1274 : struct irq_domain *parent;
1275 : int i;
1276 :
1277 : /* The outermost irq_data is embedded in struct irq_desc */
1278 0 : for (i = 0; i < nr_irqs; i++) {
1279 0 : irq_data = irq_get_irq_data(virq + i);
1280 0 : irq_data->domain = domain;
1281 :
1282 0 : for (parent = domain->parent; parent; parent = parent->parent) {
1283 0 : irq_data = irq_domain_insert_irq_data(parent, irq_data);
1284 0 : if (!irq_data) {
1285 0 : irq_domain_free_irq_data(virq, i + 1);
1286 0 : return -ENOMEM;
1287 : }
1288 : }
1289 : }
1290 :
1291 : return 0;
1292 : }
1293 :
1294 : /**
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
1298 : */
1299 0 : struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
1300 : unsigned int virq)
1301 : {
1302 : struct irq_data *irq_data;
1303 :
1304 0 : for (irq_data = irq_get_irq_data(virq); irq_data;
1305 0 : irq_data = irq_data->parent_data)
1306 0 : if (irq_data->domain == domain)
1307 : return irq_data;
1308 :
1309 : return NULL;
1310 : }
1311 : EXPORT_SYMBOL_GPL(irq_domain_get_irq_data);
1312 :
1313 : /**
1314 : * irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @virq at @domain
1315 : * @domain: Interrupt domain to match
1316 : * @virq: IRQ number
1317 : * @hwirq: The hwirq number
1318 : * @chip: The associated interrupt chip
1319 : * @chip_data: The associated chip data
1320 : */
1321 0 : int irq_domain_set_hwirq_and_chip(struct irq_domain *domain, unsigned int virq,
1322 : irq_hw_number_t hwirq,
1323 : const struct irq_chip *chip,
1324 : void *chip_data)
1325 : {
1326 0 : struct irq_data *irq_data = irq_domain_get_irq_data(domain, virq);
1327 :
1328 0 : if (!irq_data)
1329 : return -ENOENT;
1330 :
1331 0 : irq_data->hwirq = hwirq;
1332 0 : irq_data->chip = (struct irq_chip *)(chip ? chip : &no_irq_chip);
1333 0 : irq_data->chip_data = chip_data;
1334 :
1335 0 : return 0;
1336 : }
1337 : EXPORT_SYMBOL_GPL(irq_domain_set_hwirq_and_chip);
1338 :
1339 : /**
1340 : * irq_domain_set_info - Set the complete data for a @virq in @domain
1341 : * @domain: Interrupt domain to match
1342 : * @virq: IRQ number
1343 : * @hwirq: The hardware interrupt number
1344 : * @chip: The associated interrupt chip
1345 : * @chip_data: The associated interrupt chip data
1346 : * @handler: The interrupt flow handler
1347 : * @handler_data: The interrupt flow handler data
1348 : * @handler_name: The interrupt handler name
1349 : */
1350 0 : void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
1351 : irq_hw_number_t hwirq, const struct irq_chip *chip,
1352 : void *chip_data, irq_flow_handler_t handler,
1353 : void *handler_data, const char *handler_name)
1354 : {
1355 0 : irq_domain_set_hwirq_and_chip(domain, virq, hwirq, chip, chip_data);
1356 0 : __irq_set_handler(virq, handler, 0, handler_name);
1357 0 : irq_set_handler_data(virq, handler_data);
1358 0 : }
1359 : EXPORT_SYMBOL(irq_domain_set_info);
1360 :
1361 : /**
1362 : * irq_domain_free_irqs_common - Clear irq_data and free the parent
1363 : * @domain: Interrupt domain to match
1364 : * @virq: IRQ number to start with
1365 : * @nr_irqs: The number of irqs to free
1366 : */
1367 0 : void irq_domain_free_irqs_common(struct irq_domain *domain, unsigned int virq,
1368 : unsigned int nr_irqs)
1369 : {
1370 : struct irq_data *irq_data;
1371 : int i;
1372 :
1373 0 : for (i = 0; i < nr_irqs; i++) {
1374 0 : irq_data = irq_domain_get_irq_data(domain, virq + i);
1375 0 : if (irq_data)
1376 : irq_domain_reset_irq_data(irq_data);
1377 : }
1378 0 : irq_domain_free_irqs_parent(domain, virq, nr_irqs);
1379 0 : }
1380 : EXPORT_SYMBOL_GPL(irq_domain_free_irqs_common);
1381 :
1382 : /**
1383 : * irq_domain_free_irqs_top - Clear handler and handler data, clear irqdata and free parent
1384 : * @domain: Interrupt domain to match
1385 : * @virq: IRQ number to start with
1386 : * @nr_irqs: The number of irqs to free
1387 : */
1388 0 : void irq_domain_free_irqs_top(struct irq_domain *domain, unsigned int virq,
1389 : unsigned int nr_irqs)
1390 : {
1391 : int i;
1392 :
1393 0 : for (i = 0; i < nr_irqs; i++) {
1394 0 : irq_set_handler_data(virq + i, NULL);
1395 0 : irq_set_handler(virq + i, NULL);
1396 : }
1397 0 : irq_domain_free_irqs_common(domain, virq, nr_irqs);
1398 0 : }
1399 :
1400 0 : static void irq_domain_free_irqs_hierarchy(struct irq_domain *domain,
1401 : unsigned int irq_base,
1402 : unsigned int nr_irqs)
1403 : {
1404 : unsigned int i;
1405 :
1406 0 : if (!domain->ops->free)
1407 : return;
1408 :
1409 0 : for (i = 0; i < nr_irqs; i++) {
1410 0 : if (irq_domain_get_irq_data(domain, irq_base + i))
1411 0 : domain->ops->free(domain, irq_base + i, 1);
1412 : }
1413 : }
1414 :
1415 0 : int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain,
1416 : unsigned int irq_base,
1417 : unsigned int nr_irqs, void *arg)
1418 : {
1419 0 : if (!domain->ops->alloc) {
1420 : pr_debug("domain->ops->alloc() is NULL\n");
1421 : return -ENOSYS;
1422 : }
1423 :
1424 0 : return domain->ops->alloc(domain, irq_base, nr_irqs, arg);
1425 : }
1426 :
1427 : /**
1428 : * __irq_domain_alloc_irqs - Allocate IRQs from domain
1429 : * @domain: domain to allocate from
1430 : * @irq_base: allocate specified IRQ number if irq_base >= 0
1431 : * @nr_irqs: number of IRQs to allocate
1432 : * @node: NUMA node id for memory allocation
1433 : * @arg: domain specific argument
1434 : * @realloc: IRQ descriptors have already been allocated if true
1435 : * @affinity: Optional irq affinity mask for multiqueue devices
1436 : *
1437 : * Allocate IRQ numbers and initialized all data structures to support
1438 : * hierarchy IRQ domains.
1439 : * Parameter @realloc is mainly to support legacy IRQs.
1440 : * Returns error code or allocated IRQ number
1441 : *
1442 : * The whole process to setup an IRQ has been split into two steps.
1443 : * The first step, __irq_domain_alloc_irqs(), is to allocate IRQ
1444 : * descriptor and required hardware resources. The second step,
1445 : * irq_domain_activate_irq(), is to program the hardware with preallocated
1446 : * resources. In this way, it's easier to rollback when failing to
1447 : * allocate resources.
1448 : */
1449 0 : int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
1450 : unsigned int nr_irqs, int node, void *arg,
1451 : bool realloc, const struct irq_affinity_desc *affinity)
1452 : {
1453 : int i, ret, virq;
1454 :
1455 0 : if (domain == NULL) {
1456 0 : domain = irq_default_domain;
1457 0 : if (WARN(!domain, "domain is NULL; cannot allocate IRQ\n"))
1458 : return -EINVAL;
1459 : }
1460 :
1461 0 : if (realloc && irq_base >= 0) {
1462 : virq = irq_base;
1463 : } else {
1464 0 : virq = irq_domain_alloc_descs(irq_base, nr_irqs, 0, node,
1465 : affinity);
1466 0 : if (virq < 0) {
1467 : pr_debug("cannot allocate IRQ(base %d, count %d)\n",
1468 : irq_base, nr_irqs);
1469 : return virq;
1470 : }
1471 : }
1472 :
1473 0 : if (irq_domain_alloc_irq_data(domain, virq, nr_irqs)) {
1474 : pr_debug("cannot allocate memory for IRQ%d\n", virq);
1475 : ret = -ENOMEM;
1476 : goto out_free_desc;
1477 : }
1478 :
1479 0 : mutex_lock(&irq_domain_mutex);
1480 0 : ret = irq_domain_alloc_irqs_hierarchy(domain, virq, nr_irqs, arg);
1481 0 : if (ret < 0) {
1482 0 : mutex_unlock(&irq_domain_mutex);
1483 0 : goto out_free_irq_data;
1484 : }
1485 :
1486 0 : for (i = 0; i < nr_irqs; i++) {
1487 0 : ret = irq_domain_trim_hierarchy(virq + i);
1488 0 : if (ret) {
1489 0 : mutex_unlock(&irq_domain_mutex);
1490 0 : goto out_free_irq_data;
1491 : }
1492 : }
1493 :
1494 0 : for (i = 0; i < nr_irqs; i++)
1495 0 : irq_domain_insert_irq(virq + i);
1496 0 : mutex_unlock(&irq_domain_mutex);
1497 :
1498 0 : return virq;
1499 :
1500 : out_free_irq_data:
1501 0 : irq_domain_free_irq_data(virq, nr_irqs);
1502 : out_free_desc:
1503 0 : irq_free_descs(virq, nr_irqs);
1504 0 : return ret;
1505 : }
1506 : EXPORT_SYMBOL_GPL(__irq_domain_alloc_irqs);
1507 :
1508 : /* The irq_data was moved, fix the revmap to refer to the new location */
1509 0 : static void irq_domain_fix_revmap(struct irq_data *d)
1510 : {
1511 : void __rcu **slot;
1512 :
1513 0 : if (irq_domain_is_nomap(d->domain))
1514 : return;
1515 :
1516 : /* Fix up the revmap. */
1517 0 : mutex_lock(&d->domain->revmap_mutex);
1518 0 : if (d->hwirq < d->domain->revmap_size) {
1519 : /* Not using radix tree */
1520 0 : rcu_assign_pointer(d->domain->revmap[d->hwirq], d);
1521 : } else {
1522 0 : slot = radix_tree_lookup_slot(&d->domain->revmap_tree, d->hwirq);
1523 0 : if (slot)
1524 0 : radix_tree_replace_slot(&d->domain->revmap_tree, slot, d);
1525 : }
1526 0 : mutex_unlock(&d->domain->revmap_mutex);
1527 : }
1528 :
1529 : /**
1530 : * irq_domain_push_irq() - Push a domain in to the top of a hierarchy.
1531 : * @domain: Domain to push.
1532 : * @virq: Irq to push the domain in to.
1533 : * @arg: Passed to the irq_domain_ops alloc() function.
1534 : *
1535 : * For an already existing irqdomain hierarchy, as might be obtained
1536 : * via a call to pci_enable_msix(), add an additional domain to the
1537 : * head of the processing chain. Must be called before request_irq()
1538 : * has been called.
1539 : */
1540 0 : int irq_domain_push_irq(struct irq_domain *domain, int virq, void *arg)
1541 : {
1542 : struct irq_data *child_irq_data;
1543 0 : struct irq_data *root_irq_data = irq_get_irq_data(virq);
1544 : struct irq_desc *desc;
1545 0 : int rv = 0;
1546 :
1547 : /*
1548 : * Check that no action has been set, which indicates the virq
1549 : * is in a state where this function doesn't have to deal with
1550 : * races between interrupt handling and maintaining the
1551 : * hierarchy. This will catch gross misuse. Attempting to
1552 : * make the check race free would require holding locks across
1553 : * calls to struct irq_domain_ops->alloc(), which could lead
1554 : * to deadlock, so we just do a simple check before starting.
1555 : */
1556 0 : desc = irq_to_desc(virq);
1557 0 : if (!desc)
1558 : return -EINVAL;
1559 0 : if (WARN_ON(desc->action))
1560 : return -EBUSY;
1561 :
1562 0 : if (domain == NULL)
1563 : return -EINVAL;
1564 :
1565 0 : if (WARN_ON(!irq_domain_is_hierarchy(domain)))
1566 : return -EINVAL;
1567 :
1568 0 : if (!root_irq_data)
1569 : return -EINVAL;
1570 :
1571 0 : if (domain->parent != root_irq_data->domain)
1572 : return -EINVAL;
1573 :
1574 0 : child_irq_data = kzalloc_node(sizeof(*child_irq_data), GFP_KERNEL,
1575 : irq_data_get_node(root_irq_data));
1576 0 : if (!child_irq_data)
1577 : return -ENOMEM;
1578 :
1579 0 : mutex_lock(&irq_domain_mutex);
1580 :
1581 : /* Copy the original irq_data. */
1582 0 : *child_irq_data = *root_irq_data;
1583 :
1584 : /*
1585 : * Overwrite the root_irq_data, which is embedded in struct
1586 : * irq_desc, with values for this domain.
1587 : */
1588 0 : root_irq_data->parent_data = child_irq_data;
1589 0 : root_irq_data->domain = domain;
1590 0 : root_irq_data->mask = 0;
1591 0 : root_irq_data->hwirq = 0;
1592 0 : root_irq_data->chip = NULL;
1593 0 : root_irq_data->chip_data = NULL;
1594 :
1595 : /* May (probably does) set hwirq, chip, etc. */
1596 0 : rv = irq_domain_alloc_irqs_hierarchy(domain, virq, 1, arg);
1597 0 : if (rv) {
1598 : /* Restore the original irq_data. */
1599 0 : *root_irq_data = *child_irq_data;
1600 0 : kfree(child_irq_data);
1601 0 : goto error;
1602 : }
1603 :
1604 0 : irq_domain_fix_revmap(child_irq_data);
1605 0 : irq_domain_set_mapping(domain, root_irq_data->hwirq, root_irq_data);
1606 :
1607 : error:
1608 0 : mutex_unlock(&irq_domain_mutex);
1609 :
1610 0 : return rv;
1611 : }
1612 : EXPORT_SYMBOL_GPL(irq_domain_push_irq);
1613 :
1614 : /**
1615 : * irq_domain_pop_irq() - Remove a domain from the top of a hierarchy.
1616 : * @domain: Domain to remove.
1617 : * @virq: Irq to remove the domain from.
1618 : *
1619 : * Undo the effects of a call to irq_domain_push_irq(). Must be
1620 : * called either before request_irq() or after free_irq().
1621 : */
1622 0 : int irq_domain_pop_irq(struct irq_domain *domain, int virq)
1623 : {
1624 0 : struct irq_data *root_irq_data = irq_get_irq_data(virq);
1625 : struct irq_data *child_irq_data;
1626 : struct irq_data *tmp_irq_data;
1627 : struct irq_desc *desc;
1628 :
1629 : /*
1630 : * Check that no action is set, which indicates the virq is in
1631 : * a state where this function doesn't have to deal with races
1632 : * between interrupt handling and maintaining the hierarchy.
1633 : * This will catch gross misuse. Attempting to make the check
1634 : * race free would require holding locks across calls to
1635 : * struct irq_domain_ops->free(), which could lead to
1636 : * deadlock, so we just do a simple check before starting.
1637 : */
1638 0 : desc = irq_to_desc(virq);
1639 0 : if (!desc)
1640 : return -EINVAL;
1641 0 : if (WARN_ON(desc->action))
1642 : return -EBUSY;
1643 :
1644 0 : if (domain == NULL)
1645 : return -EINVAL;
1646 :
1647 0 : if (!root_irq_data)
1648 : return -EINVAL;
1649 :
1650 0 : tmp_irq_data = irq_domain_get_irq_data(domain, virq);
1651 :
1652 : /* We can only "pop" if this domain is at the top of the list */
1653 0 : if (WARN_ON(root_irq_data != tmp_irq_data))
1654 : return -EINVAL;
1655 :
1656 0 : if (WARN_ON(root_irq_data->domain != domain))
1657 : return -EINVAL;
1658 :
1659 0 : child_irq_data = root_irq_data->parent_data;
1660 0 : if (WARN_ON(!child_irq_data))
1661 : return -EINVAL;
1662 :
1663 0 : mutex_lock(&irq_domain_mutex);
1664 :
1665 0 : root_irq_data->parent_data = NULL;
1666 :
1667 0 : irq_domain_clear_mapping(domain, root_irq_data->hwirq);
1668 0 : irq_domain_free_irqs_hierarchy(domain, virq, 1);
1669 :
1670 : /* Restore the original irq_data. */
1671 0 : *root_irq_data = *child_irq_data;
1672 :
1673 0 : irq_domain_fix_revmap(root_irq_data);
1674 :
1675 0 : mutex_unlock(&irq_domain_mutex);
1676 :
1677 0 : kfree(child_irq_data);
1678 :
1679 0 : return 0;
1680 : }
1681 : EXPORT_SYMBOL_GPL(irq_domain_pop_irq);
1682 :
1683 : /**
1684 : * irq_domain_free_irqs - Free IRQ number and associated data structures
1685 : * @virq: base IRQ number
1686 : * @nr_irqs: number of IRQs to free
1687 : */
1688 0 : void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs)
1689 : {
1690 0 : struct irq_data *data = irq_get_irq_data(virq);
1691 : int i;
1692 :
1693 0 : if (WARN(!data || !data->domain || !data->domain->ops->free,
1694 : "NULL pointer, cannot free irq\n"))
1695 : return;
1696 :
1697 0 : mutex_lock(&irq_domain_mutex);
1698 0 : for (i = 0; i < nr_irqs; i++)
1699 0 : irq_domain_remove_irq(virq + i);
1700 0 : irq_domain_free_irqs_hierarchy(data->domain, virq, nr_irqs);
1701 0 : mutex_unlock(&irq_domain_mutex);
1702 :
1703 0 : irq_domain_free_irq_data(virq, nr_irqs);
1704 0 : irq_free_descs(virq, nr_irqs);
1705 : }
1706 :
1707 : /**
1708 : * irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
1709 : * @domain: Domain below which interrupts must be allocated
1710 : * @irq_base: Base IRQ number
1711 : * @nr_irqs: Number of IRQs to allocate
1712 : * @arg: Allocation data (arch/domain specific)
1713 : */
1714 0 : int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
1715 : unsigned int irq_base, unsigned int nr_irqs,
1716 : void *arg)
1717 : {
1718 0 : if (!domain->parent)
1719 : return -ENOSYS;
1720 :
1721 0 : return irq_domain_alloc_irqs_hierarchy(domain->parent, irq_base,
1722 : nr_irqs, arg);
1723 : }
1724 : EXPORT_SYMBOL_GPL(irq_domain_alloc_irqs_parent);
1725 :
1726 : /**
1727 : * irq_domain_free_irqs_parent - Free interrupts from parent domain
1728 : * @domain: Domain below which interrupts must be freed
1729 : * @irq_base: Base IRQ number
1730 : * @nr_irqs: Number of IRQs to free
1731 : */
1732 0 : void irq_domain_free_irqs_parent(struct irq_domain *domain,
1733 : unsigned int irq_base, unsigned int nr_irqs)
1734 : {
1735 0 : if (!domain->parent)
1736 : return;
1737 :
1738 0 : irq_domain_free_irqs_hierarchy(domain->parent, irq_base, nr_irqs);
1739 : }
1740 : EXPORT_SYMBOL_GPL(irq_domain_free_irqs_parent);
1741 :
1742 0 : static void __irq_domain_deactivate_irq(struct irq_data *irq_data)
1743 : {
1744 0 : if (irq_data && irq_data->domain) {
1745 0 : struct irq_domain *domain = irq_data->domain;
1746 :
1747 0 : if (domain->ops->deactivate)
1748 0 : domain->ops->deactivate(domain, irq_data);
1749 0 : if (irq_data->parent_data)
1750 0 : __irq_domain_deactivate_irq(irq_data->parent_data);
1751 : }
1752 0 : }
1753 :
1754 2 : static int __irq_domain_activate_irq(struct irq_data *irqd, bool reserve)
1755 : {
1756 2 : int ret = 0;
1757 :
1758 2 : if (irqd && irqd->domain) {
1759 0 : struct irq_domain *domain = irqd->domain;
1760 :
1761 0 : if (irqd->parent_data)
1762 0 : ret = __irq_domain_activate_irq(irqd->parent_data,
1763 : reserve);
1764 0 : if (!ret && domain->ops->activate) {
1765 0 : ret = domain->ops->activate(domain, irqd, reserve);
1766 : /* Rollback in case of error */
1767 0 : if (ret && irqd->parent_data)
1768 0 : __irq_domain_deactivate_irq(irqd->parent_data);
1769 : }
1770 : }
1771 2 : return ret;
1772 : }
1773 :
1774 : /**
1775 : * irq_domain_activate_irq - Call domain_ops->activate recursively to activate
1776 : * interrupt
1777 : * @irq_data: Outermost irq_data associated with interrupt
1778 : * @reserve: If set only reserve an interrupt vector instead of assigning one
1779 : *
1780 : * This is the second step to call domain_ops->activate to program interrupt
1781 : * controllers, so the interrupt could actually get delivered.
1782 : */
1783 2 : int irq_domain_activate_irq(struct irq_data *irq_data, bool reserve)
1784 : {
1785 2 : int ret = 0;
1786 :
1787 4 : if (!irqd_is_activated(irq_data))
1788 2 : ret = __irq_domain_activate_irq(irq_data, reserve);
1789 2 : if (!ret)
1790 2 : irqd_set_activated(irq_data);
1791 2 : return ret;
1792 : }
1793 :
1794 : /**
1795 : * irq_domain_deactivate_irq - Call domain_ops->deactivate recursively to
1796 : * deactivate interrupt
1797 : * @irq_data: outermost irq_data associated with interrupt
1798 : *
1799 : * It calls domain_ops->deactivate to program interrupt controllers to disable
1800 : * interrupt delivery.
1801 : */
1802 0 : void irq_domain_deactivate_irq(struct irq_data *irq_data)
1803 : {
1804 0 : if (irqd_is_activated(irq_data)) {
1805 0 : __irq_domain_deactivate_irq(irq_data);
1806 0 : irqd_clr_activated(irq_data);
1807 : }
1808 0 : }
1809 :
1810 : static void irq_domain_check_hierarchy(struct irq_domain *domain)
1811 : {
1812 : /* Hierarchy irq_domains must implement callback alloc() */
1813 0 : if (domain->ops->alloc)
1814 0 : domain->flags |= IRQ_DOMAIN_FLAG_HIERARCHY;
1815 : }
1816 :
1817 : /**
1818 : * irq_domain_hierarchical_is_msi_remap - Check if the domain or any
1819 : * parent has MSI remapping support
1820 : * @domain: domain pointer
1821 : */
1822 0 : bool irq_domain_hierarchical_is_msi_remap(struct irq_domain *domain)
1823 : {
1824 0 : for (; domain; domain = domain->parent) {
1825 0 : if (irq_domain_is_msi_remap(domain))
1826 : return true;
1827 : }
1828 : return false;
1829 : }
1830 : #else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1831 : /**
1832 : * irq_domain_get_irq_data - Get irq_data associated with @virq and @domain
1833 : * @domain: domain to match
1834 : * @virq: IRQ number to get irq_data
1835 : */
1836 : struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
1837 : unsigned int virq)
1838 : {
1839 : struct irq_data *irq_data = irq_get_irq_data(virq);
1840 :
1841 : return (irq_data && irq_data->domain == domain) ? irq_data : NULL;
1842 : }
1843 : EXPORT_SYMBOL_GPL(irq_domain_get_irq_data);
1844 :
1845 : /**
1846 : * irq_domain_set_info - Set the complete data for a @virq in @domain
1847 : * @domain: Interrupt domain to match
1848 : * @virq: IRQ number
1849 : * @hwirq: The hardware interrupt number
1850 : * @chip: The associated interrupt chip
1851 : * @chip_data: The associated interrupt chip data
1852 : * @handler: The interrupt flow handler
1853 : * @handler_data: The interrupt flow handler data
1854 : * @handler_name: The interrupt handler name
1855 : */
1856 : void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
1857 : irq_hw_number_t hwirq, const struct irq_chip *chip,
1858 : void *chip_data, irq_flow_handler_t handler,
1859 : void *handler_data, const char *handler_name)
1860 : {
1861 : irq_set_chip_and_handler_name(virq, chip, handler, handler_name);
1862 : irq_set_chip_data(virq, chip_data);
1863 : irq_set_handler_data(virq, handler_data);
1864 : }
1865 :
1866 : static void irq_domain_check_hierarchy(struct irq_domain *domain)
1867 : {
1868 : }
1869 : #endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
1870 :
1871 : #ifdef CONFIG_GENERIC_IRQ_DEBUGFS
1872 : static struct dentry *domain_dir;
1873 :
1874 : static void
1875 : irq_domain_debug_show_one(struct seq_file *m, struct irq_domain *d, int ind)
1876 : {
1877 : seq_printf(m, "%*sname: %s\n", ind, "", d->name);
1878 : seq_printf(m, "%*ssize: %u\n", ind + 1, "", d->revmap_size);
1879 : seq_printf(m, "%*smapped: %u\n", ind + 1, "", d->mapcount);
1880 : seq_printf(m, "%*sflags: 0x%08x\n", ind +1 , "", d->flags);
1881 : if (d->ops && d->ops->debug_show)
1882 : d->ops->debug_show(m, d, NULL, ind + 1);
1883 : #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1884 : if (!d->parent)
1885 : return;
1886 : seq_printf(m, "%*sparent: %s\n", ind + 1, "", d->parent->name);
1887 : irq_domain_debug_show_one(m, d->parent, ind + 4);
1888 : #endif
1889 : }
1890 :
1891 : static int irq_domain_debug_show(struct seq_file *m, void *p)
1892 : {
1893 : struct irq_domain *d = m->private;
1894 :
1895 : /* Default domain? Might be NULL */
1896 : if (!d) {
1897 : if (!irq_default_domain)
1898 : return 0;
1899 : d = irq_default_domain;
1900 : }
1901 : irq_domain_debug_show_one(m, d, 0);
1902 : return 0;
1903 : }
1904 : DEFINE_SHOW_ATTRIBUTE(irq_domain_debug);
1905 :
1906 : static void debugfs_add_domain_dir(struct irq_domain *d)
1907 : {
1908 : if (!d->name || !domain_dir)
1909 : return;
1910 : debugfs_create_file(d->name, 0444, domain_dir, d,
1911 : &irq_domain_debug_fops);
1912 : }
1913 :
1914 : static void debugfs_remove_domain_dir(struct irq_domain *d)
1915 : {
1916 : debugfs_remove(debugfs_lookup(d->name, domain_dir));
1917 : }
1918 :
1919 : void __init irq_domain_debugfs_init(struct dentry *root)
1920 : {
1921 : struct irq_domain *d;
1922 :
1923 : domain_dir = debugfs_create_dir("domains", root);
1924 :
1925 : debugfs_create_file("default", 0444, domain_dir, NULL,
1926 : &irq_domain_debug_fops);
1927 : mutex_lock(&irq_domain_mutex);
1928 : list_for_each_entry(d, &irq_domain_list, link)
1929 : debugfs_add_domain_dir(d);
1930 : mutex_unlock(&irq_domain_mutex);
1931 : }
1932 : #endif
|
