1 #ifndef _LINUX_IRQDESC_H 2 #define _LINUX_IRQDESC_H 3 4 /* 5 * Core internal functions to deal with irq descriptors 6 */ 7 8 struct irq_affinity_notify; 9 struct proc_dir_entry; 10 struct module; 11 struct irq_desc; 12 struct irq_domain; 13 struct pt_regs; 14 15 /** 16 * struct irq_desc - interrupt descriptor 17 * @irq_common_data: per irq and chip data passed down to chip functions 18 * @kstat_irqs: irq stats per cpu 19 * @handle_irq: highlevel irq-events handler 20 * @preflow_handler: handler called before the flow handler (currently used by sparc) 21 * @action: the irq action chain 22 * @status: status information 23 * @core_internal_state__do_not_mess_with_it: core internal status information 24 * @depth: disable-depth, for nested irq_disable() calls 25 * @wake_depth: enable depth, for multiple irq_set_irq_wake() callers 26 * @irq_count: stats field to detect stalled irqs 27 * @last_unhandled: aging timer for unhandled count 28 * @irqs_unhandled: stats field for spurious unhandled interrupts 29 * @threads_handled: stats field for deferred spurious detection of threaded handlers 30 * @threads_handled_last: comparator field for deferred spurious detection of theraded handlers 31 * @lock: locking for SMP 32 * @affinity_hint: hint to user space for preferred irq affinity 33 * @affinity_notify: context for notification of affinity changes 34 * @pending_mask: pending rebalanced interrupts 35 * @threads_oneshot: bitfield to handle shared oneshot threads 36 * @threads_active: number of irqaction threads currently running 37 * @wait_for_threads: wait queue for sync_irq to wait for threaded handlers 38 * @nr_actions: number of installed actions on this descriptor 39 * @no_suspend_depth: number of irqactions on a irq descriptor with 40 * IRQF_NO_SUSPEND set 41 * @force_resume_depth: number of irqactions on a irq descriptor with 42 * IRQF_FORCE_RESUME set 43 * @dir: /proc/irq/ procfs entry 44 * @name: flow handler name for /proc/interrupts output 45 */ 46 struct irq_desc { 47 struct irq_common_data irq_common_data; 48 struct irq_data irq_data; 49 unsigned int __percpu *kstat_irqs; 50 irq_flow_handler_t handle_irq; 51 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI 52 irq_preflow_handler_t preflow_handler; 53 #endif 54 struct irqaction *action; /* IRQ action list */ 55 unsigned int status_use_accessors; 56 unsigned int core_internal_state__do_not_mess_with_it; 57 unsigned int depth; /* nested irq disables */ 58 unsigned int wake_depth; /* nested wake enables */ 59 unsigned int irq_count; /* For detecting broken IRQs */ 60 unsigned long last_unhandled; /* Aging timer for unhandled count */ 61 unsigned int irqs_unhandled; 62 atomic_t threads_handled; 63 int threads_handled_last; 64 raw_spinlock_t lock; 65 struct cpumask *percpu_enabled; 66 #ifdef CONFIG_SMP 67 const struct cpumask *affinity_hint; 68 struct irq_affinity_notify *affinity_notify; 69 #ifdef CONFIG_GENERIC_PENDING_IRQ 70 cpumask_var_t pending_mask; 71 #endif 72 #endif 73 unsigned long threads_oneshot; 74 atomic_t threads_active; 75 wait_queue_head_t wait_for_threads; 76 #ifdef CONFIG_PM_SLEEP 77 unsigned int nr_actions; 78 unsigned int no_suspend_depth; 79 unsigned int cond_suspend_depth; 80 unsigned int force_resume_depth; 81 #endif 82 #ifdef CONFIG_PROC_FS 83 struct proc_dir_entry *dir; 84 #endif 85 int parent_irq; 86 struct module *owner; 87 const char *name; 88 } ____cacheline_internodealigned_in_smp; 89 90 #ifdef CONFIG_SPARSE_IRQ 91 extern void irq_lock_sparse(void); 92 extern void irq_unlock_sparse(void); 93 #else 94 static inline void irq_lock_sparse(void) { } 95 static inline void irq_unlock_sparse(void) { } 96 extern struct irq_desc irq_desc[NR_IRQS]; 97 #endif 98 99 static inline struct irq_desc *irq_data_to_desc(struct irq_data *data) 100 { 101 #ifdef CONFIG_IRQ_DOMAIN_HIERARCHY 102 return irq_to_desc(data->irq); 103 #else 104 return container_of(data, struct irq_desc, irq_data); 105 #endif 106 } 107 108 static inline unsigned int irq_desc_get_irq(struct irq_desc *desc) 109 { 110 return desc->irq_data.irq; 111 } 112 113 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc) 114 { 115 return &desc->irq_data; 116 } 117 118 static inline struct irq_chip *irq_desc_get_chip(struct irq_desc *desc) 119 { 120 return desc->irq_data.chip; 121 } 122 123 static inline void *irq_desc_get_chip_data(struct irq_desc *desc) 124 { 125 return desc->irq_data.chip_data; 126 } 127 128 static inline void *irq_desc_get_handler_data(struct irq_desc *desc) 129 { 130 return desc->irq_data.handler_data; 131 } 132 133 static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc) 134 { 135 return desc->irq_data.msi_desc; 136 } 137 138 /* 139 * Architectures call this to let the generic IRQ layer 140 * handle an interrupt. If the descriptor is attached to an 141 * irqchip-style controller then we call the ->handle_irq() handler, 142 * and it calls __do_IRQ() if it's attached to an irqtype-style controller. 143 */ 144 static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc) 145 { 146 desc->handle_irq(irq, desc); 147 } 148 149 int generic_handle_irq(unsigned int irq); 150 151 #ifdef CONFIG_HANDLE_DOMAIN_IRQ 152 /* 153 * Convert a HW interrupt number to a logical one using a IRQ domain, 154 * and handle the result interrupt number. Return -EINVAL if 155 * conversion failed. Providing a NULL domain indicates that the 156 * conversion has already been done. 157 */ 158 int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq, 159 bool lookup, struct pt_regs *regs); 160 161 static inline int handle_domain_irq(struct irq_domain *domain, 162 unsigned int hwirq, struct pt_regs *regs) 163 { 164 return __handle_domain_irq(domain, hwirq, true, regs); 165 } 166 #endif 167 168 /* Test to see if a driver has successfully requested an irq */ 169 static inline int irq_has_action(unsigned int irq) 170 { 171 struct irq_desc *desc = irq_to_desc(irq); 172 return desc->action != NULL; 173 } 174 175 /* caller has locked the irq_desc and both params are valid */ 176 static inline void __irq_set_handler_locked(unsigned int irq, 177 irq_flow_handler_t handler) 178 { 179 struct irq_desc *desc; 180 181 desc = irq_to_desc(irq); 182 desc->handle_irq = handler; 183 } 184 185 /* caller has locked the irq_desc and both params are valid */ 186 static inline void 187 __irq_set_chip_handler_name_locked(unsigned int irq, struct irq_chip *chip, 188 irq_flow_handler_t handler, const char *name) 189 { 190 struct irq_desc *desc; 191 192 desc = irq_to_desc(irq); 193 irq_desc_get_irq_data(desc)->chip = chip; 194 desc->handle_irq = handler; 195 desc->name = name; 196 } 197 198 /** 199 * irq_set_handler_locked - Set irq handler from a locked region 200 * @data: Pointer to the irq_data structure which identifies the irq 201 * @handler: Flow control handler function for this interrupt 202 * 203 * Sets the handler in the irq descriptor associated to @data. 204 * 205 * Must be called with irq_desc locked and valid parameters. Typical 206 * call site is the irq_set_type() callback. 207 */ 208 static inline void irq_set_handler_locked(struct irq_data *data, 209 irq_flow_handler_t handler) 210 { 211 struct irq_desc *desc = irq_data_to_desc(data); 212 213 desc->handle_irq = handler; 214 } 215 216 /** 217 * irq_set_chip_handler_name_locked - Set chip, handler and name from a locked region 218 * @data: Pointer to the irq_data structure for which the chip is set 219 * @chip: Pointer to the new irq chip 220 * @handler: Flow control handler function for this interrupt 221 * @name: Name of the interrupt 222 * 223 * Replace the irq chip at the proper hierarchy level in @data and 224 * sets the handler and name in the associated irq descriptor. 225 * 226 * Must be called with irq_desc locked and valid parameters. 227 */ 228 static inline void 229 irq_set_chip_handler_name_locked(struct irq_data *data, struct irq_chip *chip, 230 irq_flow_handler_t handler, const char *name) 231 { 232 struct irq_desc *desc = irq_data_to_desc(data); 233 234 desc->handle_irq = handler; 235 desc->name = name; 236 data->chip = chip; 237 } 238 239 static inline int irq_balancing_disabled(unsigned int irq) 240 { 241 struct irq_desc *desc; 242 243 desc = irq_to_desc(irq); 244 return desc->status_use_accessors & IRQ_NO_BALANCING_MASK; 245 } 246 247 static inline int irq_is_percpu(unsigned int irq) 248 { 249 struct irq_desc *desc; 250 251 desc = irq_to_desc(irq); 252 return desc->status_use_accessors & IRQ_PER_CPU; 253 } 254 255 static inline void 256 irq_set_lockdep_class(unsigned int irq, struct lock_class_key *class) 257 { 258 struct irq_desc *desc = irq_to_desc(irq); 259 260 if (desc) 261 lockdep_set_class(&desc->lock, class); 262 } 263 264 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI 265 static inline void 266 __irq_set_preflow_handler(unsigned int irq, irq_preflow_handler_t handler) 267 { 268 struct irq_desc *desc; 269 270 desc = irq_to_desc(irq); 271 desc->preflow_handler = handler; 272 } 273 #endif 274 275 #endif 276