irqdomain.h 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. /*
  2. * irq_domain - IRQ translation domains
  3. *
  4. * Translation infrastructure between hw and linux irq numbers. This is
  5. * helpful for interrupt controllers to implement mapping between hardware
  6. * irq numbers and the Linux irq number space.
  7. *
  8. * irq_domains also have a hook for translating device tree interrupt
  9. * representation into a hardware irq number that can be mapped back to a
  10. * Linux irq number without any extra platform support code.
  11. *
  12. * Interrupt controller "domain" data structure. This could be defined as a
  13. * irq domain controller. That is, it handles the mapping between hardware
  14. * and virtual interrupt numbers for a given interrupt domain. The domain
  15. * structure is generally created by the PIC code for a given PIC instance
  16. * (though a domain can cover more than one PIC if they have a flat number
  17. * model). It's the domain callbacks that are responsible for setting the
  18. * irq_chip on a given irq_desc after it's been mapped.
  19. *
  20. * The host code and data structures are agnostic to whether or not
  21. * we use an open firmware device-tree. We do have references to struct
  22. * device_node in two places: in irq_find_host() to find the host matching
  23. * a given interrupt controller node, and of course as an argument to its
  24. * counterpart domain->ops->match() callback. However, those are treated as
  25. * generic pointers by the core and the fact that it's actually a device-node
  26. * pointer is purely a convention between callers and implementation. This
  27. * code could thus be used on other architectures by replacing those two
  28. * by some sort of arch-specific void * "token" used to identify interrupt
  29. * controllers.
  30. */
  31. #ifndef _LINUX_IRQDOMAIN_H
  32. #define _LINUX_IRQDOMAIN_H
  33. #include <linux/types.h>
  34. #include <linux/radix-tree.h>
  35. struct device_node;
  36. struct irq_domain;
  37. struct of_device_id;
  38. /* This type is the placeholder for a hardware interrupt number. It has to
  39. * be big enough to enclose whatever representation is used by a given
  40. * platform.
  41. */
  42. typedef unsigned long irq_hw_number_t;
  43. /**
  44. * struct irq_domain_ops - Methods for irq_domain objects
  45. * @match: Match an interrupt controller device node to a host, returns
  46. * 1 on a match
  47. * @map: Create or update a mapping between a virtual irq number and a hw
  48. * irq number. This is called only once for a given mapping.
  49. * @unmap: Dispose of such a mapping
  50. * @to_irq: (optional) given a local hardware irq number, return the linux
  51. * irq number. If to_irq is not implemented, then the irq_domain
  52. * will use this translation: irq = (domain->irq_base + hwirq)
  53. * @xlate: Given a device tree node and interrupt specifier, decode
  54. * the hardware irq number and linux irq type value.
  55. *
  56. * Functions below are provided by the driver and called whenever a new mapping
  57. * is created or an old mapping is disposed. The driver can then proceed to
  58. * whatever internal data structures management is required. It also needs
  59. * to setup the irq_desc when returning from map().
  60. */
  61. struct irq_domain_ops {
  62. int (*match)(struct irq_domain *d, struct device_node *node);
  63. int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
  64. void (*unmap)(struct irq_domain *d, unsigned int virq);
  65. unsigned int (*to_irq)(struct irq_domain *d, unsigned long hwirq);
  66. int (*xlate)(struct irq_domain *d, struct device_node *node,
  67. const u32 *intspec, unsigned int intsize,
  68. unsigned long *out_hwirq, unsigned int *out_type);
  69. };
  70. /**
  71. * struct irq_domain - Hardware interrupt number translation object
  72. * @link: Element in global irq_domain list.
  73. * @revmap_type: Method used for reverse mapping hwirq numbers to linux irq. This
  74. * will be one of the IRQ_DOMAIN_MAP_* values.
  75. * @revmap_data: Revmap method specific data.
  76. * @ops: pointer to irq_domain methods
  77. * @host_data: private data pointer for use by owner. Not touched by irq_domain
  78. * core code.
  79. * @irq_base: Start of irq_desc range assigned to the irq_domain. The creator
  80. * of the irq_domain is responsible for allocating the array of
  81. * irq_desc structures.
  82. * @nr_irq: Number of irqs managed by the irq domain
  83. * @hwirq_base: Starting number for hwirqs managed by the irq domain
  84. * @of_node: (optional) Pointer to device tree nodes associated with the
  85. * irq_domain. Used when decoding device tree interrupt specifiers.
  86. */
  87. struct irq_domain {
  88. struct list_head link;
  89. /* type of reverse mapping_technique */
  90. unsigned int revmap_type;
  91. union {
  92. struct {
  93. unsigned int size;
  94. unsigned int *revmap;
  95. } linear;
  96. struct radix_tree_root tree;
  97. } revmap_data;
  98. struct irq_domain_ops *ops;
  99. void *host_data;
  100. irq_hw_number_t inval_irq;
  101. unsigned int irq_base;
  102. unsigned int nr_irq;
  103. unsigned int hwirq_base;
  104. /* Optional device node pointer */
  105. struct device_node *of_node;
  106. };
  107. #ifdef CONFIG_IRQ_DOMAIN
  108. #ifdef CONFIG_PPC
  109. struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
  110. struct irq_domain_ops *ops,
  111. void *host_data);
  112. struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
  113. unsigned int size,
  114. struct irq_domain_ops *ops,
  115. void *host_data);
  116. struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
  117. struct irq_domain_ops *ops,
  118. void *host_data);
  119. struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
  120. struct irq_domain_ops *ops,
  121. void *host_data);
  122. extern struct irq_domain *irq_find_host(struct device_node *node);
  123. extern void irq_set_default_host(struct irq_domain *host);
  124. extern void irq_set_virq_count(unsigned int count);
  125. extern unsigned int irq_create_mapping(struct irq_domain *host,
  126. irq_hw_number_t hwirq);
  127. extern void irq_dispose_mapping(unsigned int virq);
  128. extern unsigned int irq_find_mapping(struct irq_domain *host,
  129. irq_hw_number_t hwirq);
  130. extern unsigned int irq_create_direct_mapping(struct irq_domain *host);
  131. extern void irq_radix_revmap_insert(struct irq_domain *host, unsigned int virq,
  132. irq_hw_number_t hwirq);
  133. extern unsigned int irq_radix_revmap_lookup(struct irq_domain *host,
  134. irq_hw_number_t hwirq);
  135. extern unsigned int irq_linear_revmap(struct irq_domain *host,
  136. irq_hw_number_t hwirq);
  137. #else /* CONFIG_PPC */
  138. /**
  139. * irq_domain_to_irq() - Translate from a hardware irq to a linux irq number
  140. *
  141. * Returns the linux irq number associated with a hardware irq. By default,
  142. * the mapping is irq == domain->irq_base + hwirq, but this mapping can
  143. * be overridden if the irq_domain implements a .to_irq() hook.
  144. */
  145. static inline unsigned int irq_domain_to_irq(struct irq_domain *d,
  146. unsigned long hwirq)
  147. {
  148. if (d->ops->to_irq)
  149. return d->ops->to_irq(d, hwirq);
  150. if (WARN_ON(hwirq < d->hwirq_base))
  151. return 0;
  152. return d->irq_base + hwirq - d->hwirq_base;
  153. }
  154. #define irq_domain_for_each_hwirq(d, hw) \
  155. for (hw = d->hwirq_base; hw < d->hwirq_base + d->nr_irq; hw++)
  156. #define irq_domain_for_each_irq(d, hw, irq) \
  157. for (hw = d->hwirq_base, irq = irq_domain_to_irq(d, hw); \
  158. hw < d->hwirq_base + d->nr_irq; \
  159. hw++, irq = irq_domain_to_irq(d, hw))
  160. extern void irq_domain_add(struct irq_domain *domain);
  161. extern void irq_domain_del(struct irq_domain *domain);
  162. extern struct irq_domain_ops irq_domain_simple_ops;
  163. #if defined(CONFIG_OF_IRQ)
  164. extern void irq_domain_add_simple(struct device_node *controller, int irq_base);
  165. extern void irq_domain_generate_simple(const struct of_device_id *match,
  166. u64 phys_base, unsigned int irq_start);
  167. #else /* CONFIG_OF_IRQ */
  168. static inline void irq_domain_generate_simple(const struct of_device_id *match,
  169. u64 phys_base, unsigned int irq_start) { }
  170. #endif /* !CONFIG_OF_IRQ */
  171. #endif /* !CONFIG_PPC */
  172. #endif /* CONFIG_IRQ_DOMAIN */
  173. #endif /* _LINUX_IRQDOMAIN_H */