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 return container_of(data->common, struct irq_desc, irq_common_data); 102 } 103 104 static inline unsigned int irq_desc_get_irq(struct irq_desc *desc) 105 { 106 return desc->irq_data.irq; 107 } 108 109 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc) 110 { 111 return &desc->irq_data; 112 } 113 114 static inline struct irq_chip *irq_desc_get_chip(struct irq_desc *desc) 115 { 116 return desc->irq_data.chip; 117 } 118 119 static inline void *irq_desc_get_chip_data(struct irq_desc *desc) 120 { 121 return desc->irq_data.chip_data; 122 } 123 124 static inline void *irq_desc_get_handler_data(struct irq_desc *desc) 125 { 126 return desc->irq_common_data.handler_data; 127 } 128 129 static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc) 130 { 131 return desc->irq_common_data.msi_desc; 132 } 133 134 /* 135 * Architectures call this to let the generic IRQ layer 136 * handle an interrupt. 137 */ 138 static inline void generic_handle_irq_desc(struct irq_desc *desc) 139 { 140 desc->handle_irq(desc); 141 } 142 143 int generic_handle_irq(unsigned int irq); 144 145 #ifdef CONFIG_HANDLE_DOMAIN_IRQ 146 /* 147 * Convert a HW interrupt number to a logical one using a IRQ domain, 148 * and handle the result interrupt number. Return -EINVAL if 149 * conversion failed. Providing a NULL domain indicates that the 150 * conversion has already been done. 151 */ 152 int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq, 153 bool lookup, struct pt_regs *regs); 154 155 static inline int handle_domain_irq(struct irq_domain *domain, 156 unsigned int hwirq, struct pt_regs *regs) 157 { 158 return __handle_domain_irq(domain, hwirq, true, regs); 159 } 160 #endif 161 162 /* Test to see if a driver has successfully requested an irq */ 163 static inline int irq_desc_has_action(struct irq_desc *desc) 164 { 165 return desc->action != NULL; 166 } 167 168 static inline int irq_has_action(unsigned int irq) 169 { 170 return irq_desc_has_action(irq_to_desc(irq)); 171 } 172 173 /** 174 * irq_set_handler_locked - Set irq handler from a locked region 175 * @data: Pointer to the irq_data structure which identifies the irq 176 * @handler: Flow control handler function for this interrupt 177 * 178 * Sets the handler in the irq descriptor associated to @data. 179 * 180 * Must be called with irq_desc locked and valid parameters. Typical 181 * call site is the irq_set_type() callback. 182 */ 183 static inline void irq_set_handler_locked(struct irq_data *data, 184 irq_flow_handler_t handler) 185 { 186 struct irq_desc *desc = irq_data_to_desc(data); 187 188 desc->handle_irq = handler; 189 } 190 191 /** 192 * irq_set_chip_handler_name_locked - Set chip, handler and name from a locked region 193 * @data: Pointer to the irq_data structure for which the chip is set 194 * @chip: Pointer to the new irq chip 195 * @handler: Flow control handler function for this interrupt 196 * @name: Name of the interrupt 197 * 198 * Replace the irq chip at the proper hierarchy level in @data and 199 * sets the handler and name in the associated irq descriptor. 200 * 201 * Must be called with irq_desc locked and valid parameters. 202 */ 203 static inline void 204 irq_set_chip_handler_name_locked(struct irq_data *data, struct irq_chip *chip, 205 irq_flow_handler_t handler, const char *name) 206 { 207 struct irq_desc *desc = irq_data_to_desc(data); 208 209 desc->handle_irq = handler; 210 desc->name = name; 211 data->chip = chip; 212 } 213 214 static inline int irq_balancing_disabled(unsigned int irq) 215 { 216 struct irq_desc *desc; 217 218 desc = irq_to_desc(irq); 219 return desc->status_use_accessors & IRQ_NO_BALANCING_MASK; 220 } 221 222 static inline int irq_is_percpu(unsigned int irq) 223 { 224 struct irq_desc *desc; 225 226 desc = irq_to_desc(irq); 227 return desc->status_use_accessors & IRQ_PER_CPU; 228 } 229 230 static inline void 231 irq_set_lockdep_class(unsigned int irq, struct lock_class_key *class) 232 { 233 struct irq_desc *desc = irq_to_desc(irq); 234 235 if (desc) 236 lockdep_set_class(&desc->lock, class); 237 } 238 239 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI 240 static inline void 241 __irq_set_preflow_handler(unsigned int irq, irq_preflow_handler_t handler) 242 { 243 struct irq_desc *desc; 244 245 desc = irq_to_desc(irq); 246 desc->preflow_handler = handler; 247 } 248 #endif 249 250 #endif 251