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