~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/irq/irqdomain.c

Version: ~ [ linux-5.2-rc5 ] ~ [ linux-5.1.12 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.53 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.128 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.182 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.182 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp