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