irqdomain.h 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  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. /* Number of irqs reserved for a legacy isa controller */
  39. #define NUM_ISA_INTERRUPTS 16
  40. /**
  41. * struct irq_domain_ops - Methods for irq_domain objects
  42. * @match: Match an interrupt controller device node to a host, returns
  43. * 1 on a match
  44. * @map: Create or update a mapping between a virtual irq number and a hw
  45. * irq number. This is called only once for a given mapping.
  46. * @unmap: Dispose of such a mapping
  47. * @xlate: Given a device tree node and interrupt specifier, decode
  48. * the hardware irq number and linux irq type value.
  49. *
  50. * Functions below are provided by the driver and called whenever a new mapping
  51. * is created or an old mapping is disposed. The driver can then proceed to
  52. * whatever internal data structures management is required. It also needs
  53. * to setup the irq_desc when returning from map().
  54. */
  55. struct irq_domain_ops {
  56. int (*match)(struct irq_domain *d, struct device_node *node);
  57. int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
  58. void (*unmap)(struct irq_domain *d, unsigned int virq);
  59. int (*xlate)(struct irq_domain *d, struct device_node *node,
  60. const u32 *intspec, unsigned int intsize,
  61. unsigned long *out_hwirq, unsigned int *out_type);
  62. };
  63. extern struct irq_domain_ops irq_generic_chip_ops;
  64. struct irq_domain_chip_generic;
  65. /**
  66. * struct irq_domain - Hardware interrupt number translation object
  67. * @link: Element in global irq_domain list.
  68. * @revmap_type: Method used for reverse mapping hwirq numbers to linux irq. This
  69. * will be one of the IRQ_DOMAIN_MAP_* values.
  70. * @revmap_data: Revmap method specific data.
  71. * @ops: pointer to irq_domain methods
  72. * @host_data: private data pointer for use by owner. Not touched by irq_domain
  73. * core code.
  74. * @irq_base: Start of irq_desc range assigned to the irq_domain. The creator
  75. * of the irq_domain is responsible for allocating the array of
  76. * irq_desc structures.
  77. * @nr_irq: Number of irqs managed by the irq domain
  78. * @hwirq_base: Starting number for hwirqs managed by the irq domain
  79. * @of_node: (optional) Pointer to device tree nodes associated with the
  80. * irq_domain. Used when decoding device tree interrupt specifiers.
  81. */
  82. struct irq_domain {
  83. struct list_head link;
  84. const char *name;
  85. /* type of reverse mapping_technique */
  86. unsigned int revmap_type;
  87. union {
  88. struct {
  89. unsigned int size;
  90. unsigned int *revmap;
  91. } linear;
  92. struct {
  93. unsigned int max_irq;
  94. } nomap;
  95. struct radix_tree_root tree;
  96. } revmap_data;
  97. const struct irq_domain_ops *ops;
  98. void *host_data;
  99. irq_hw_number_t inval_irq;
  100. /* Optional device node pointer */
  101. struct device_node *of_node;
  102. /* Optional pointer to generic interrupt chips */
  103. struct irq_domain_chip_generic *gc;
  104. };
  105. #define IRQ_DOMAIN_MAP_NOMAP 1 /* no fast reverse mapping */
  106. #define IRQ_DOMAIN_MAP_LINEAR 2 /* linear map of interrupts */
  107. #define IRQ_DOMAIN_MAP_TREE 3 /* radix tree */
  108. #ifdef CONFIG_IRQ_DOMAIN
  109. struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
  110. unsigned int size,
  111. unsigned int first_irq,
  112. const struct irq_domain_ops *ops,
  113. void *host_data);
  114. struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
  115. unsigned int size,
  116. unsigned int first_irq,
  117. irq_hw_number_t first_hwirq,
  118. const struct irq_domain_ops *ops,
  119. void *host_data);
  120. struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
  121. unsigned int size,
  122. const struct irq_domain_ops *ops,
  123. void *host_data);
  124. struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
  125. unsigned int max_irq,
  126. const struct irq_domain_ops *ops,
  127. void *host_data);
  128. struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
  129. const struct irq_domain_ops *ops,
  130. void *host_data);
  131. extern struct irq_domain *irq_find_host(struct device_node *node);
  132. extern void irq_set_default_host(struct irq_domain *host);
  133. static inline struct irq_domain *irq_domain_add_legacy_isa(
  134. struct device_node *of_node,
  135. const struct irq_domain_ops *ops,
  136. void *host_data)
  137. {
  138. return irq_domain_add_legacy(of_node, NUM_ISA_INTERRUPTS, 0, 0, ops,
  139. host_data);
  140. }
  141. extern void irq_domain_remove(struct irq_domain *host);
  142. extern int irq_domain_associate_many(struct irq_domain *domain,
  143. unsigned int irq_base,
  144. irq_hw_number_t hwirq_base, int count);
  145. static inline int irq_domain_associate(struct irq_domain *domain, unsigned int irq,
  146. irq_hw_number_t hwirq)
  147. {
  148. return irq_domain_associate_many(domain, irq, hwirq, 1);
  149. }
  150. extern unsigned int irq_create_mapping(struct irq_domain *host,
  151. irq_hw_number_t hwirq);
  152. extern void irq_dispose_mapping(unsigned int virq);
  153. extern unsigned int irq_find_mapping(struct irq_domain *host,
  154. irq_hw_number_t hwirq);
  155. extern unsigned int irq_create_direct_mapping(struct irq_domain *host);
  156. extern int irq_create_strict_mappings(struct irq_domain *domain,
  157. unsigned int irq_base,
  158. irq_hw_number_t hwirq_base, int count);
  159. static inline int irq_create_identity_mapping(struct irq_domain *host,
  160. irq_hw_number_t hwirq)
  161. {
  162. return irq_create_strict_mappings(host, hwirq, hwirq, 1);
  163. }
  164. extern unsigned int irq_linear_revmap(struct irq_domain *host,
  165. irq_hw_number_t hwirq);
  166. extern const struct irq_domain_ops irq_domain_simple_ops;
  167. /* stock xlate functions */
  168. int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
  169. const u32 *intspec, unsigned int intsize,
  170. irq_hw_number_t *out_hwirq, unsigned int *out_type);
  171. int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
  172. const u32 *intspec, unsigned int intsize,
  173. irq_hw_number_t *out_hwirq, unsigned int *out_type);
  174. int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
  175. const u32 *intspec, unsigned int intsize,
  176. irq_hw_number_t *out_hwirq, unsigned int *out_type);
  177. #if defined(CONFIG_OF_IRQ)
  178. extern void irq_domain_generate_simple(const struct of_device_id *match,
  179. u64 phys_base, unsigned int irq_start);
  180. #else /* CONFIG_OF_IRQ */
  181. static inline void irq_domain_generate_simple(const struct of_device_id *match,
  182. u64 phys_base, unsigned int irq_start) { }
  183. #endif /* !CONFIG_OF_IRQ */
  184. #else /* CONFIG_IRQ_DOMAIN */
  185. static inline void irq_dispose_mapping(unsigned int virq) { }
  186. #endif /* !CONFIG_IRQ_DOMAIN */
  187. #endif /* _LINUX_IRQDOMAIN_H */