1 #ifndef _LINUX_IRQDESC_H 2 #define _LINUX_IRQDESC_H 3 4 /* 5 * Core internal functions to deal with irq descriptors 6 * 7 * This include will move to kernel/irq once we cleaned up the tree. 8 * For now it's included from <linux/irq.h> 9 */ 10 11 struct irq_affinity_notify; 12 struct proc_dir_entry; 13 struct timer_rand_state; 14 /** 15 * struct irq_desc - interrupt descriptor 16 * @irq_data: per irq and chip data passed down to chip functions 17 * @timer_rand_state: pointer to timer rand state struct 18 * @kstat_irqs: irq stats per cpu 19 * @handle_irq: highlevel irq-events handler [if NULL, __do_IRQ()] 20 * @action: the irq action chain 21 * @status: status information 22 * @core_internal_state__do_not_mess_with_it: core internal status information 23 * @depth: disable-depth, for nested irq_disable() calls 24 * @wake_depth: enable depth, for multiple set_irq_wake() callers 25 * @irq_count: stats field to detect stalled irqs 26 * @last_unhandled: aging timer for unhandled count 27 * @irqs_unhandled: stats field for spurious unhandled interrupts 28 * @lock: locking for SMP 29 * @affinity_notify: context for notification of affinity changes 30 * @pending_mask: pending rebalanced interrupts 31 * @threads_oneshot: bitfield to handle shared oneshot threads 32 * @threads_active: number of irqaction threads currently running 33 * @wait_for_threads: wait queue for sync_irq to wait for threaded handlers 34 * @dir: /proc/irq/ procfs entry 35 * @name: flow handler name for /proc/interrupts output 36 */ 37 struct irq_desc { 38 39 #ifdef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED 40 struct irq_data irq_data; 41 #else 42 /* 43 * This union will go away, once we fixed the direct access to 44 * irq_desc all over the place. The direct fields are a 1:1 45 * overlay of irq_data. 46 */ 47 union { 48 struct irq_data irq_data; 49 struct { 50 unsigned int irq; 51 unsigned int node; 52 unsigned int pad_do_not_even_think_about_it; 53 struct irq_chip *chip; 54 void *handler_data; 55 void *chip_data; 56 struct msi_desc *msi_desc; 57 #ifdef CONFIG_SMP 58 cpumask_var_t affinity; 59 #endif 60 }; 61 }; 62 #endif 63 64 struct timer_rand_state *timer_rand_state; 65 unsigned int __percpu *kstat_irqs; 66 irq_flow_handler_t handle_irq; 67 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI 68 irq_preflow_handler_t preflow_handler; 69 #endif 70 struct irqaction *action; /* IRQ action list */ 71 #ifdef CONFIG_GENERIC_HARDIRQS_NO_COMPAT 72 unsigned int status_use_accessors; 73 #else 74 unsigned int status; /* IRQ status */ 75 #endif 76 unsigned int core_internal_state__do_not_mess_with_it; 77 unsigned int depth; /* nested irq disables */ 78 unsigned int wake_depth; /* nested wake enables */ 79 unsigned int irq_count; /* For detecting broken IRQs */ 80 unsigned long last_unhandled; /* Aging timer for unhandled count */ 81 unsigned int irqs_unhandled; 82 raw_spinlock_t lock; 83 #ifdef CONFIG_SMP 84 const struct cpumask *affinity_hint; 85 struct irq_affinity_notify *affinity_notify; 86 #ifdef CONFIG_GENERIC_PENDING_IRQ 87 cpumask_var_t pending_mask; 88 #endif 89 #endif 90 unsigned long threads_oneshot; 91 atomic_t threads_active; 92 wait_queue_head_t wait_for_threads; 93 #ifdef CONFIG_PROC_FS 94 struct proc_dir_entry *dir; 95 #endif 96 const char *name; 97 } ____cacheline_internodealigned_in_smp; 98 99 #ifndef CONFIG_SPARSE_IRQ 100 extern struct irq_desc irq_desc[NR_IRQS]; 101 #endif 102 103 /* Will be removed once the last users in power and sh are gone */ 104 extern struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node); 105 static inline struct irq_desc *move_irq_desc(struct irq_desc *desc, int node) 106 { 107 return desc; 108 } 109 110 #ifdef CONFIG_GENERIC_HARDIRQS 111 112 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc) 113 { 114 return &desc->irq_data; 115 } 116 117 static inline struct irq_chip *irq_desc_get_chip(struct irq_desc *desc) 118 { 119 return desc->irq_data.chip; 120 } 121 122 static inline void *irq_desc_get_chip_data(struct irq_desc *desc) 123 { 124 return desc->irq_data.chip_data; 125 } 126 127 static inline void *irq_desc_get_handler_data(struct irq_desc *desc) 128 { 129 return desc->irq_data.handler_data; 130 } 131 132 static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc) 133 { 134 return desc->irq_data.msi_desc; 135 } 136 137 #ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT 138 static inline struct irq_chip *get_irq_desc_chip(struct irq_desc *desc) 139 { 140 return irq_desc_get_chip(desc); 141 } 142 static inline void *get_irq_desc_data(struct irq_desc *desc) 143 { 144 return irq_desc_get_handler_data(desc); 145 } 146 147 static inline void *get_irq_desc_chip_data(struct irq_desc *desc) 148 { 149 return irq_desc_get_chip_data(desc); 150 } 151 152 static inline struct msi_desc *get_irq_desc_msi(struct irq_desc *desc) 153 { 154 return irq_desc_get_msi_desc(desc); 155 } 156 #endif 157 158 /* 159 * Architectures call this to let the generic IRQ layer 160 * handle an interrupt. If the descriptor is attached to an 161 * irqchip-style controller then we call the ->handle_irq() handler, 162 * and it calls __do_IRQ() if it's attached to an irqtype-style controller. 163 */ 164 static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc) 165 { 166 desc->handle_irq(irq, desc); 167 } 168 169 static inline void generic_handle_irq(unsigned int irq) 170 { 171 generic_handle_irq_desc(irq, irq_to_desc(irq)); 172 } 173 174 /* Test to see if a driver has successfully requested an irq */ 175 static inline int irq_has_action(unsigned int irq) 176 { 177 struct irq_desc *desc = irq_to_desc(irq); 178 return desc->action != NULL; 179 } 180 181 #ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT 182 static inline int irq_balancing_disabled(unsigned int irq) 183 { 184 struct irq_desc *desc; 185 186 desc = irq_to_desc(irq); 187 return desc->status & IRQ_NO_BALANCING_MASK; 188 } 189 #endif 190 191 /* caller has locked the irq_desc and both params are valid */ 192 static inline void __set_irq_handler_unlocked(int irq, 193 irq_flow_handler_t handler) 194 { 195 struct irq_desc *desc; 196 197 desc = irq_to_desc(irq); 198 desc->handle_irq = handler; 199 } 200 201 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI 202 static inline void 203 __irq_set_preflow_handler(unsigned int irq, irq_preflow_handler_t handler) 204 { 205 struct irq_desc *desc; 206 207 desc = irq_to_desc(irq); 208 desc->preflow_handler = handler; 209 } 210 #endif 211 #endif 212 213 #endif 214