Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 #ifndef _LINUX_IRQ_H
  2 #define _LINUX_IRQ_H
  3 
  4 /*
  5  * Please do not include this file in generic code.  There is currently
  6  * no requirement for any architecture to implement anything held
  7  * within this file.
  8  *
  9  * Thanks. --rmk
 10  */
 11 
 12 #include <linux/smp.h>
 13 
 14 #ifndef CONFIG_S390
 15 
 16 #include <linux/linkage.h>
 17 #include <linux/cache.h>
 18 #include <linux/spinlock.h>
 19 #include <linux/cpumask.h>
 20 #include <linux/irqreturn.h>
 21 #include <linux/errno.h>
 22 #include <linux/wait.h>
 23 
 24 #include <asm/irq.h>
 25 #include <asm/ptrace.h>
 26 #include <asm/irq_regs.h>
 27 #include <asm/timex.h>
 28 
 29 struct irq_desc;
 30 typedef void (*irq_flow_handler_t)(unsigned int irq,
 31                                             struct irq_desc *desc);
 32 
 33 
 34 /*
 35  * IRQ line status.
 36  *
 37  * Bits 0-7 are reserved for the IRQF_* bits in linux/interrupt.h
 38  *
 39  * IRQ types
 40  */
 41 #define IRQ_TYPE_NONE           0x00000000      /* Default, unspecified type */
 42 #define IRQ_TYPE_EDGE_RISING    0x00000001      /* Edge rising type */
 43 #define IRQ_TYPE_EDGE_FALLING   0x00000002      /* Edge falling type */
 44 #define IRQ_TYPE_EDGE_BOTH (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)
 45 #define IRQ_TYPE_LEVEL_HIGH     0x00000004      /* Level high type */
 46 #define IRQ_TYPE_LEVEL_LOW      0x00000008      /* Level low type */
 47 #define IRQ_TYPE_SENSE_MASK     0x0000000f      /* Mask of the above */
 48 #define IRQ_TYPE_PROBE          0x00000010      /* Probing in progress */
 49 
 50 /* Internal flags */
 51 #define IRQ_INPROGRESS          0x00000100      /* IRQ handler active - do not enter! */
 52 #define IRQ_DISABLED            0x00000200      /* IRQ disabled - do not enter! */
 53 #define IRQ_PENDING             0x00000400      /* IRQ pending - replay on enable */
 54 #define IRQ_REPLAY              0x00000800      /* IRQ has been replayed but not acked yet */
 55 #define IRQ_AUTODETECT          0x00001000      /* IRQ is being autodetected */
 56 #define IRQ_WAITING             0x00002000      /* IRQ not yet seen - for autodetection */
 57 #define IRQ_LEVEL               0x00004000      /* IRQ level triggered */
 58 #define IRQ_MASKED              0x00008000      /* IRQ masked - shouldn't be seen again */
 59 #define IRQ_PER_CPU             0x00010000      /* IRQ is per CPU */
 60 #define IRQ_NOPROBE             0x00020000      /* IRQ is not valid for probing */
 61 #define IRQ_NOREQUEST           0x00040000      /* IRQ cannot be requested */
 62 #define IRQ_NOAUTOEN            0x00080000      /* IRQ will not be enabled on request irq */
 63 #define IRQ_WAKEUP              0x00100000      /* IRQ triggers system wakeup */
 64 #define IRQ_MOVE_PENDING        0x00200000      /* need to re-target IRQ destination */
 65 #define IRQ_NO_BALANCING        0x00400000      /* IRQ is excluded from balancing */
 66 #define IRQ_NODELAY             0x40000000      /* IRQ must run immediately */
 67 
 68 #ifdef CONFIG_IRQ_PER_CPU
 69 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
 70 # define IRQ_NO_BALANCING_MASK  (IRQ_PER_CPU | IRQ_NO_BALANCING)
 71 #else
 72 # define CHECK_IRQ_PER_CPU(var) 0
 73 # define IRQ_NO_BALANCING_MASK  IRQ_NO_BALANCING
 74 #endif
 75 
 76 struct proc_dir_entry;
 77 struct msi_desc;
 78 
 79 /**
 80  * struct irq_chip - hardware interrupt chip descriptor
 81  *
 82  * @name:               name for /proc/interrupts
 83  * @startup:            start up the interrupt (defaults to ->enable if NULL)
 84  * @shutdown:           shut down the interrupt (defaults to ->disable if NULL)
 85  * @enable:             enable the interrupt (defaults to chip->unmask if NULL)
 86  * @disable:            disable the interrupt (defaults to chip->mask if NULL)
 87  * @ack:                start of a new interrupt
 88  * @mask:               mask an interrupt source
 89  * @mask_ack:           ack and mask an interrupt source
 90  * @unmask:             unmask an interrupt source
 91  * @eoi:                end of interrupt - chip level
 92  * @end:                end of interrupt - flow level
 93  * @set_affinity:       set the CPU affinity on SMP machines
 94  * @retrigger:          resend an IRQ to the CPU
 95  * @set_type:           set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
 96  * @set_wake:           enable/disable power-management wake-on of an IRQ
 97  *
 98  * @release:            release function solely used by UML
 99  * @typename:           obsoleted by name, kept as migration helper
100  */
101 struct irq_chip {
102         const char      *name;
103         unsigned int    (*startup)(unsigned int irq);
104         void            (*shutdown)(unsigned int irq);
105         void            (*enable)(unsigned int irq);
106         void            (*disable)(unsigned int irq);
107 
108         void            (*ack)(unsigned int irq);
109         void            (*mask)(unsigned int irq);
110         void            (*mask_ack)(unsigned int irq);
111         void            (*unmask)(unsigned int irq);
112         void            (*eoi)(unsigned int irq);
113 
114         void            (*end)(unsigned int irq);
115         void            (*set_affinity)(unsigned int irq, cpumask_t dest);
116         int             (*retrigger)(unsigned int irq);
117         int             (*set_type)(unsigned int irq, unsigned int flow_type);
118         int             (*set_wake)(unsigned int irq, unsigned int on);
119 
120         /* Currently used only by UML, might disappear one day.*/
121 #ifdef CONFIG_IRQ_RELEASE_METHOD
122         void            (*release)(unsigned int irq, void *dev_id);
123 #endif
124         /*
125          * For compatibility, ->typename is copied into ->name.
126          * Will disappear.
127          */
128         const char      *typename;
129 };
130 
131 /**
132  * struct irq_desc - interrupt descriptor
133  *
134  * @handle_irq:         highlevel irq-events handler [if NULL, __do_IRQ()]
135  * @chip:               low level interrupt hardware access
136  * @msi_desc:           MSI descriptor
137  * @handler_data:       per-IRQ data for the irq_chip methods
138  * @chip_data:          platform-specific per-chip private data for the chip
139  *                      methods, to allow shared chip implementations
140  * @action:             the irq action chain
141  * @status:             status information
142  * @depth:              disable-depth, for nested irq_disable() calls
143  * @wake_depth:         enable depth, for multiple set_irq_wake() callers
144  * @irq_count:          stats field to detect stalled irqs
145  * @irqs_unhandled:     stats field for spurious unhandled interrupts
146  * @last_unhandled:     aging timer for unhandled count
147  * @thread:             Thread pointer for threaded preemptible irq handling
148  * @wait_for_handler:   Waitqueue to wait for a running preemptible handler
149  * @lock:               locking for SMP
150  * @affinity:           IRQ affinity on SMP
151  * @cpu:                cpu index useful for balancing
152  * @pending_mask:       pending rebalanced interrupts
153  * @dir:                /proc/irq/ procfs entry
154  * @affinity_entry:     /proc/irq/smp_affinity procfs entry on SMP
155  * @name:               flow handler name for /proc/interrupts output
156  */
157 struct irq_desc {
158         irq_flow_handler_t      handle_irq;
159         struct irq_chip         *chip;
160         struct msi_desc         *msi_desc;
161         void                    *handler_data;
162         void                    *chip_data;
163         struct irqaction        *action;        /* IRQ action list */
164         unsigned int            status;         /* IRQ status */
165 
166         unsigned int            depth;          /* nested irq disables */
167         unsigned int            wake_depth;     /* nested wake enables */
168         unsigned int            irq_count;      /* For detecting broken IRQs */
169         unsigned int            irqs_unhandled;
170         unsigned long           last_unhandled; /* Aging timer for unhandled count */
171         struct task_struct      *thread;
172         wait_queue_head_t       wait_for_handler;
173         cycles_t                timestamp;
174         raw_spinlock_t          lock;
175 #ifdef CONFIG_SMP
176         cpumask_t               affinity;
177         unsigned int            cpu;
178 #endif
179 #if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
180         cpumask_t               pending_mask;
181 #endif
182 #ifdef CONFIG_PROC_FS
183         struct proc_dir_entry   *dir;
184 #endif
185         const char              *name;
186 } ____cacheline_internodealigned_in_smp;
187 
188 extern struct irq_desc irq_desc[NR_IRQS];
189 
190 /*
191  * Migration helpers for obsolete names, they will go away:
192  */
193 #define hw_interrupt_type       irq_chip
194 typedef struct irq_chip         hw_irq_controller;
195 #define no_irq_type             no_irq_chip
196 typedef struct irq_desc         irq_desc_t;
197 
198 /*
199  * Pick up the arch-dependent methods:
200  */
201 #include <asm/hw_irq.h>
202 
203 extern int setup_irq(unsigned int irq, struct irqaction *new);
204 
205 #ifdef CONFIG_GENERIC_HARDIRQS
206 
207 #ifndef handle_dynamic_tick
208 # define handle_dynamic_tick(a)         do { } while (0)
209 #endif
210 
211 #ifdef CONFIG_SMP
212 
213 #if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
214 
215 void set_pending_irq(unsigned int irq, cpumask_t mask);
216 void move_native_irq(int irq);
217 void move_masked_irq(int irq);
218 
219 #else /* CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE */
220 
221 static inline void move_irq(int irq)
222 {
223 }
224 
225 static inline void move_native_irq(int irq)
226 {
227 }
228 
229 static inline void move_masked_irq(int irq)
230 {
231 }
232 
233 static inline void set_pending_irq(unsigned int irq, cpumask_t mask)
234 {
235 }
236 
237 #endif /* CONFIG_GENERIC_PENDING_IRQ */
238 
239 extern int irq_set_affinity(unsigned int irq, cpumask_t cpumask);
240 extern int irq_can_set_affinity(unsigned int irq);
241 
242 #else /* CONFIG_SMP */
243 
244 #define move_native_irq(x)
245 #define move_masked_irq(x)
246 
247 static inline int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
248 {
249         return -EINVAL;
250 }
251 
252 static inline int irq_can_set_affinity(unsigned int irq) { return 0; }
253 
254 #endif /* CONFIG_SMP */
255 
256 #ifdef CONFIG_IRQBALANCE
257 extern void set_balance_irq_affinity(unsigned int irq, cpumask_t mask);
258 #else
259 static inline void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
260 {
261 }
262 #endif
263 
264 #ifdef CONFIG_AUTO_IRQ_AFFINITY
265 extern int select_smp_affinity(unsigned int irq);
266 #else
267 static inline int select_smp_affinity(unsigned int irq)
268 {
269         return 1;
270 }
271 #endif
272 
273 extern int no_irq_affinity;
274 
275 static inline int irq_balancing_disabled(unsigned int irq)
276 {
277         return irq_desc[irq].status & IRQ_NO_BALANCING_MASK;
278 }
279 
280 /* Handle irq action chains: */
281 extern int handle_IRQ_event(unsigned int irq, struct irqaction *action);
282 
283 /*
284  * Built-in IRQ handlers for various IRQ types,
285  * callable via desc->chip->handle_irq()
286  */
287 extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
288 extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
289 extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
290 extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
291 extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
292 extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
293 
294 /*
295  * Monolithic do_IRQ implementation.
296  */
297 #ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
298 extern unsigned int __do_IRQ(unsigned int irq);
299 #endif
300 
301 /*
302  * Architectures call this to let the generic IRQ layer
303  * handle an interrupt. If the descriptor is attached to an
304  * irqchip-style controller then we call the ->handle_irq() handler,
305  * and it calls __do_IRQ() if it's attached to an irqtype-style controller.
306  */
307 static inline void generic_handle_irq(unsigned int irq)
308 {
309         struct irq_desc *desc = irq_desc + irq;
310 
311 #ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
312         desc->handle_irq(irq, desc);
313 #else
314         if (likely(desc->handle_irq))
315                 desc->handle_irq(irq, desc);
316         else
317                 __do_IRQ(irq);
318 #endif
319 }
320 
321 /* Handling of unhandled and spurious interrupts: */
322 extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
323                            int action_ret);
324 
325 /* Resending of interrupts :*/
326 void check_irq_resend(struct irq_desc *desc, unsigned int irq);
327 
328 /* Enable/disable irq debugging output: */
329 extern int noirqdebug_setup(char *str);
330 
331 /* Checks whether the interrupt can be requested by request_irq(): */
332 extern int can_request_irq(unsigned int irq, unsigned long irqflags);
333 
334 /* Dummy irq-chip implementations: */
335 extern struct irq_chip no_irq_chip;
336 extern struct irq_chip dummy_irq_chip;
337 
338 extern void
339 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
340                          irq_flow_handler_t handle);
341 extern void
342 set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
343                               irq_flow_handler_t handle, const char *name);
344 
345 extern void
346 __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
347                   const char *name);
348 
349 /* caller has locked the irq_desc and both params are valid */
350 static inline void __set_irq_handler_unlocked(int irq,
351                                               irq_flow_handler_t handler)
352 {
353         irq_desc[irq].handle_irq = handler;
354 }
355 
356 /*
357  * Set a highlevel flow handler for a given IRQ:
358  */
359 static inline void
360 set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
361 {
362         __set_irq_handler(irq, handle, 0, NULL);
363 }
364 
365 /*
366  * Set a highlevel chained flow handler for a given IRQ.
367  * (a chained handler is automatically enabled and set to
368  *  IRQ_NOREQUEST and IRQ_NOPROBE)
369  */
370 static inline void
371 set_irq_chained_handler(unsigned int irq,
372                         irq_flow_handler_t handle)
373 {
374         __set_irq_handler(irq, handle, 1, NULL);
375 }
376 
377 extern void set_irq_noprobe(unsigned int irq);
378 extern void set_irq_probe(unsigned int irq);
379 
380 /* Handle dynamic irq creation and destruction */
381 extern int create_irq(void);
382 extern void destroy_irq(unsigned int irq);
383 
384 /* Test to see if a driver has successfully requested an irq */
385 static inline int irq_has_action(unsigned int irq)
386 {
387         struct irq_desc *desc = irq_desc + irq;
388         return desc->action != NULL;
389 }
390 
391 /* Dynamic irq helper functions */
392 extern void dynamic_irq_init(unsigned int irq);
393 extern void dynamic_irq_cleanup(unsigned int irq);
394 
395 /* Set/get chip/data for an IRQ: */
396 extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
397 extern int set_irq_data(unsigned int irq, void *data);
398 extern int set_irq_chip_data(unsigned int irq, void *data);
399 extern int set_irq_type(unsigned int irq, unsigned int type);
400 extern int set_irq_msi(unsigned int irq, struct msi_desc *entry);
401 
402 #define get_irq_chip(irq)       (irq_desc[irq].chip)
403 #define get_irq_chip_data(irq)  (irq_desc[irq].chip_data)
404 #define get_irq_data(irq)       (irq_desc[irq].handler_data)
405 #define get_irq_msi(irq)        (irq_desc[irq].msi_desc)
406 
407 /* Early initialization of irqs */
408 extern void early_init_hardirqs(void);
409 
410 #if defined(CONFIG_PREEMPT_HARDIRQS)
411 extern void init_hardirqs(void);
412 #else
413 static inline void init_hardirqs(void) { }
414 #endif
415 
416 #else   /* end GENERIC HARDIRQS */
417 
418 static inline void early_init_hardirqs(void) { }
419 static inline void init_hardirqs(void) { }
420 
421 #endif /* !CONFIG_GENERIC_HARDIRQS */
422 
423 #endif /* !CONFIG_S390 */
424 
425 #endif /* _LINUX_IRQ_H */
426 
  This page was automatically generated by the LXR engine.