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