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