~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/include/asm/irq.h

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.2 ] ~ [ linux-4.20.16 ] ~ [ linux-4.19.29 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.106 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.163 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifdef __KERNEL__
  2 #ifndef _ASM_POWERPC_IRQ_H
  3 #define _ASM_POWERPC_IRQ_H
  4 
  5 /*
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License
  8  * as published by the Free Software Foundation; either version
  9  * 2 of the License, or (at your option) any later version.
 10  */
 11 
 12 #include <linux/threads.h>
 13 #include <linux/list.h>
 14 #include <linux/radix-tree.h>
 15 
 16 #include <asm/types.h>
 17 #include <asm/atomic.h>
 18 
 19 
 20 /* Define a way to iterate across irqs. */
 21 #define for_each_irq(i) \
 22         for ((i) = 0; (i) < NR_IRQS; ++(i))
 23 
 24 extern atomic_t ppc_n_lost_interrupts;
 25 
 26 /* This number is used when no interrupt has been assigned */
 27 #define NO_IRQ                  (0)
 28 
 29 /* This is a special irq number to return from get_irq() to tell that
 30  * no interrupt happened _and_ ignore it (don't count it as bad). Some
 31  * platforms like iSeries rely on that.
 32  */
 33 #define NO_IRQ_IGNORE           ((unsigned int)-1)
 34 
 35 /* Total number of virq in the platform */
 36 #define NR_IRQS         CONFIG_NR_IRQS
 37 
 38 /* Number of irqs reserved for the legacy controller */
 39 #define NUM_ISA_INTERRUPTS      16
 40 
 41 /* Same thing, used by the generic IRQ code */
 42 #define NR_IRQS_LEGACY          NUM_ISA_INTERRUPTS
 43 
 44 /* This type is the placeholder for a hardware interrupt number. It has to
 45  * be big enough to enclose whatever representation is used by a given
 46  * platform.
 47  */
 48 typedef unsigned long irq_hw_number_t;
 49 
 50 /* Interrupt controller "host" data structure. This could be defined as a
 51  * irq domain controller. That is, it handles the mapping between hardware
 52  * and virtual interrupt numbers for a given interrupt domain. The host
 53  * structure is generally created by the PIC code for a given PIC instance
 54  * (though a host can cover more than one PIC if they have a flat number
 55  * model). It's the host callbacks that are responsible for setting the
 56  * irq_chip on a given irq_desc after it's been mapped.
 57  *
 58  * The host code and data structures are fairly agnostic to the fact that
 59  * we use an open firmware device-tree. We do have references to struct
 60  * device_node in two places: in irq_find_host() to find the host matching
 61  * a given interrupt controller node, and of course as an argument to its
 62  * counterpart host->ops->match() callback. However, those are treated as
 63  * generic pointers by the core and the fact that it's actually a device-node
 64  * pointer is purely a convention between callers and implementation. This
 65  * code could thus be used on other architectures by replacing those two
 66  * by some sort of arch-specific void * "token" used to identify interrupt
 67  * controllers.
 68  */
 69 struct irq_host;
 70 struct radix_tree_root;
 71 
 72 /* Functions below are provided by the host and called whenever a new mapping
 73  * is created or an old mapping is disposed. The host can then proceed to
 74  * whatever internal data structures management is required. It also needs
 75  * to setup the irq_desc when returning from map().
 76  */
 77 struct irq_host_ops {
 78         /* Match an interrupt controller device node to a host, returns
 79          * 1 on a match
 80          */
 81         int (*match)(struct irq_host *h, struct device_node *node);
 82 
 83         /* Create or update a mapping between a virtual irq number and a hw
 84          * irq number. This is called only once for a given mapping.
 85          */
 86         int (*map)(struct irq_host *h, unsigned int virq, irq_hw_number_t hw);
 87 
 88         /* Dispose of such a mapping */
 89         void (*unmap)(struct irq_host *h, unsigned int virq);
 90 
 91         /* Translate device-tree interrupt specifier from raw format coming
 92          * from the firmware to a irq_hw_number_t (interrupt line number) and
 93          * type (sense) that can be passed to set_irq_type(). In the absence
 94          * of this callback, irq_create_of_mapping() and irq_of_parse_and_map()
 95          * will return the hw number in the first cell and IRQ_TYPE_NONE for
 96          * the type (which amount to keeping whatever default value the
 97          * interrupt controller has for that line)
 98          */
 99         int (*xlate)(struct irq_host *h, struct device_node *ctrler,
100                      const u32 *intspec, unsigned int intsize,
101                      irq_hw_number_t *out_hwirq, unsigned int *out_type);
102 };
103 
104 struct irq_host {
105         struct list_head        link;
106 
107         /* type of reverse mapping technique */
108         unsigned int            revmap_type;
109 #define IRQ_HOST_MAP_LEGACY     0 /* legacy 8259, gets irqs 1..15 */
110 #define IRQ_HOST_MAP_NOMAP      1 /* no fast reverse mapping */
111 #define IRQ_HOST_MAP_LINEAR     2 /* linear map of interrupts */
112 #define IRQ_HOST_MAP_TREE       3 /* radix tree */
113         union {
114                 struct {
115                         unsigned int size;
116                         unsigned int *revmap;
117                 } linear;
118                 struct radix_tree_root tree;
119         } revmap_data;
120         struct irq_host_ops     *ops;
121         void                    *host_data;
122         irq_hw_number_t         inval_irq;
123 
124         /* Optional device node pointer */
125         struct device_node      *of_node;
126 };
127 
128 struct irq_data;
129 extern irq_hw_number_t irqd_to_hwirq(struct irq_data *d);
130 extern irq_hw_number_t virq_to_hw(unsigned int virq);
131 extern bool virq_is_host(unsigned int virq, struct irq_host *host);
132 
133 /**
134  * irq_alloc_host - Allocate a new irq_host data structure
135  * @of_node: optional device-tree node of the interrupt controller
136  * @revmap_type: type of reverse mapping to use
137  * @revmap_arg: for IRQ_HOST_MAP_LINEAR linear only: size of the map
138  * @ops: map/unmap host callbacks
139  * @inval_irq: provide a hw number in that host space that is always invalid
140  *
141  * Allocates and initialize and irq_host structure. Note that in the case of
142  * IRQ_HOST_MAP_LEGACY, the map() callback will be called before this returns
143  * for all legacy interrupts except 0 (which is always the invalid irq for
144  * a legacy controller). For a IRQ_HOST_MAP_LINEAR, the map is allocated by
145  * this call as well. For a IRQ_HOST_MAP_TREE, the radix tree will be allocated
146  * later during boot automatically (the reverse mapping will use the slow path
147  * until that happens).
148  */
149 extern struct irq_host *irq_alloc_host(struct device_node *of_node,
150                                        unsigned int revmap_type,
151                                        unsigned int revmap_arg,
152                                        struct irq_host_ops *ops,
153                                        irq_hw_number_t inval_irq);
154 
155 
156 /**
157  * irq_find_host - Locates a host for a given device node
158  * @node: device-tree node of the interrupt controller
159  */
160 extern struct irq_host *irq_find_host(struct device_node *node);
161 
162 
163 /**
164  * irq_set_default_host - Set a "default" host
165  * @host: default host pointer
166  *
167  * For convenience, it's possible to set a "default" host that will be used
168  * whenever NULL is passed to irq_create_mapping(). It makes life easier for
169  * platforms that want to manipulate a few hard coded interrupt numbers that
170  * aren't properly represented in the device-tree.
171  */
172 extern void irq_set_default_host(struct irq_host *host);
173 
174 
175 /**
176  * irq_set_virq_count - Set the maximum number of virt irqs
177  * @count: number of linux virtual irqs, capped with NR_IRQS
178  *
179  * This is mainly for use by platforms like iSeries who want to program
180  * the virtual irq number in the controller to avoid the reverse mapping
181  */
182 extern void irq_set_virq_count(unsigned int count);
183 
184 
185 /**
186  * irq_create_mapping - Map a hardware interrupt into linux virq space
187  * @host: host owning this hardware interrupt or NULL for default host
188  * @hwirq: hardware irq number in that host space
189  *
190  * Only one mapping per hardware interrupt is permitted. Returns a linux
191  * virq number.
192  * If the sense/trigger is to be specified, set_irq_type() should be called
193  * on the number returned from that call.
194  */
195 extern unsigned int irq_create_mapping(struct irq_host *host,
196                                        irq_hw_number_t hwirq);
197 
198 
199 /**
200  * irq_dispose_mapping - Unmap an interrupt
201  * @virq: linux virq number of the interrupt to unmap
202  */
203 extern void irq_dispose_mapping(unsigned int virq);
204 
205 /**
206  * irq_find_mapping - Find a linux virq from an hw irq number.
207  * @host: host owning this hardware interrupt
208  * @hwirq: hardware irq number in that host space
209  *
210  * This is a slow path, for use by generic code. It's expected that an
211  * irq controller implementation directly calls the appropriate low level
212  * mapping function.
213  */
214 extern unsigned int irq_find_mapping(struct irq_host *host,
215                                      irq_hw_number_t hwirq);
216 
217 /**
218  * irq_create_direct_mapping - Allocate a virq for direct mapping
219  * @host: host to allocate the virq for or NULL for default host
220  *
221  * This routine is used for irq controllers which can choose the hardware
222  * interrupt numbers they generate. In such a case it's simplest to use
223  * the linux virq as the hardware interrupt number.
224  */
225 extern unsigned int irq_create_direct_mapping(struct irq_host *host);
226 
227 /**
228  * irq_radix_revmap_insert - Insert a hw irq to linux virq number mapping.
229  * @host: host owning this hardware interrupt
230  * @virq: linux irq number
231  * @hwirq: hardware irq number in that host space
232  *
233  * This is for use by irq controllers that use a radix tree reverse
234  * mapping for fast lookup.
235  */
236 extern void irq_radix_revmap_insert(struct irq_host *host, unsigned int virq,
237                                     irq_hw_number_t hwirq);
238 
239 /**
240  * irq_radix_revmap_lookup - Find a linux virq from a hw irq number.
241  * @host: host owning this hardware interrupt
242  * @hwirq: hardware irq number in that host space
243  *
244  * This is a fast path, for use by irq controller code that uses radix tree
245  * revmaps
246  */
247 extern unsigned int irq_radix_revmap_lookup(struct irq_host *host,
248                                             irq_hw_number_t hwirq);
249 
250 /**
251  * irq_linear_revmap - Find a linux virq from a hw irq number.
252  * @host: host owning this hardware interrupt
253  * @hwirq: hardware irq number in that host space
254  *
255  * This is a fast path, for use by irq controller code that uses linear
256  * revmaps. It does fallback to the slow path if the revmap doesn't exist
257  * yet and will create the revmap entry with appropriate locking
258  */
259 
260 extern unsigned int irq_linear_revmap(struct irq_host *host,
261                                       irq_hw_number_t hwirq);
262 
263 
264 
265 /**
266  * irq_alloc_virt - Allocate virtual irq numbers
267  * @host: host owning these new virtual irqs
268  * @count: number of consecutive numbers to allocate
269  * @hint: pass a hint number, the allocator will try to use a 1:1 mapping
270  *
271  * This is a low level function that is used internally by irq_create_mapping()
272  * and that can be used by some irq controllers implementations for things
273  * like allocating ranges of numbers for MSIs. The revmaps are left untouched.
274  */
275 extern unsigned int irq_alloc_virt(struct irq_host *host,
276                                    unsigned int count,
277                                    unsigned int hint);
278 
279 /**
280  * irq_free_virt - Free virtual irq numbers
281  * @virq: virtual irq number of the first interrupt to free
282  * @count: number of interrupts to free
283  *
284  * This function is the opposite of irq_alloc_virt. It will not clear reverse
285  * maps, this should be done previously by unmap'ing the interrupt. In fact,
286  * all interrupts covered by the range being freed should have been unmapped
287  * prior to calling this.
288  */
289 extern void irq_free_virt(unsigned int virq, unsigned int count);
290 
291 /**
292  * irq_early_init - Init irq remapping subsystem
293  */
294 extern void irq_early_init(void);
295 
296 static __inline__ int irq_canonicalize(int irq)
297 {
298         return irq;
299 }
300 
301 extern int distribute_irqs;
302 
303 struct irqaction;
304 struct pt_regs;
305 
306 #define __ARCH_HAS_DO_SOFTIRQ
307 
308 #if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
309 /*
310  * Per-cpu stacks for handling critical, debug and machine check
311  * level interrupts.
312  */
313 extern struct thread_info *critirq_ctx[NR_CPUS];
314 extern struct thread_info *dbgirq_ctx[NR_CPUS];
315 extern struct thread_info *mcheckirq_ctx[NR_CPUS];
316 extern void exc_lvl_ctx_init(void);
317 #else
318 #define exc_lvl_ctx_init()
319 #endif
320 
321 /*
322  * Per-cpu stacks for handling hard and soft interrupts.
323  */
324 extern struct thread_info *hardirq_ctx[NR_CPUS];
325 extern struct thread_info *softirq_ctx[NR_CPUS];
326 
327 extern void irq_ctx_init(void);
328 extern void call_do_softirq(struct thread_info *tp);
329 extern int call_handle_irq(int irq, void *p1,
330                            struct thread_info *tp, void *func);
331 extern void do_IRQ(struct pt_regs *regs);
332 
333 #endif /* _ASM_IRQ_H */
334 #endif /* __KERNEL__ */
335 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp