arch/powerpc/include/asm/irq.h

   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         /* Update of such a mapping  */
  92         void (*remap)(struct irq_host *h, unsigned int virq, irq_hw_number_t hw);
  93
  94         /* Translate device-tree interrupt specifier from raw format coming
  95          * from the firmware to a irq_hw_number_t (interrupt line number) and
  96          * type (sense) that can be passed to set_irq_type(). In the absence
  97          * of this callback, irq_create_of_mapping() and irq_of_parse_and_map()
  98          * will return the hw number in the first cell and IRQ_TYPE_NONE for
  99          * the type (which amount to keeping whatever default value the
 100          * interrupt controller has for that line)
 101          */
 102         int (*xlate)(struct irq_host *h, struct device_node *ctrler,
 103                      const u32 *intspec, unsigned int intsize,
 104                      irq_hw_number_t *out_hwirq, unsigned int *out_type);
 105 };
 106
 107 struct irq_host {
 108         struct list_head        link;
 109
 110         /* type of reverse mapping technique */
 111         unsigned int            revmap_type;
 112 #define IRQ_HOST_MAP_LEGACY     0 /* legacy 8259, gets irqs 1..15 */
 113 #define IRQ_HOST_MAP_NOMAP      1 /* no fast reverse mapping */
 114 #define IRQ_HOST_MAP_LINEAR     2 /* linear map of interrupts */
 115 #define IRQ_HOST_MAP_TREE       3 /* radix tree */
 116         union {
 117                 struct {
 118                         unsigned int size;
 119                         unsigned int *revmap;
 120                 } linear;
 121                 struct radix_tree_root tree;
 122         } revmap_data;
 123         struct irq_host_ops     *ops;
 124         void                    *host_data;
 125         irq_hw_number_t         inval_irq;
 126
 127         /* Optional device node pointer */
 128         struct device_node      *of_node;
 129 };
 130
 131 /* The main irq map itself is an array of NR_IRQ entries containing the
 132  * associate host and irq number. An entry with a host of NULL is free.
 133  * An entry can be allocated if it's free, the allocator always then sets
 134  * hwirq first to the host's invalid irq number and then fills ops.
 135  */
 136 struct irq_map_entry {
 137         irq_hw_number_t hwirq;
 138         struct irq_host *host;
 139 };
 140
 141 extern struct irq_map_entry irq_map[NR_IRQS];
 142
 143 extern irq_hw_number_t virq_to_hw(unsigned int virq);
 144
 145 /**
 146  * irq_alloc_host - Allocate a new irq_host data structure
 147  * @of_node: optional device-tree node of the interrupt controller
 148  * @revmap_type: type of reverse mapping to use
 149  * @revmap_arg: for IRQ_HOST_MAP_LINEAR linear only: size of the map
 150  * @ops: map/unmap host callbacks
 151  * @inval_irq: provide a hw number in that host space that is always invalid
 152  *
 153  * Allocates and initialize and irq_host structure. Note that in the case of
 154  * IRQ_HOST_MAP_LEGACY, the map() callback will be called before this returns
 155  * for all legacy interrupts except 0 (which is always the invalid irq for
 156  * a legacy controller). For a IRQ_HOST_MAP_LINEAR, the map is allocated by
 157  * this call as well. For a IRQ_HOST_MAP_TREE, the radix tree will be allocated
 158  * later during boot automatically (the reverse mapping will use the slow path
 159  * until that happens).
 160  */
 161 extern struct irq_host *irq_alloc_host(struct device_node *of_node,
 162                                        unsigned int revmap_type,
 163                                        unsigned int revmap_arg,
 164                                        struct irq_host_ops *ops,
 165                                        irq_hw_number_t inval_irq);
 166
 167
 168 /**
 169  * irq_find_host - Locates a host for a given device node
 170  * @node: device-tree node of the interrupt controller
 171  */
 172 extern struct irq_host *irq_find_host(struct device_node *node);
 173
 174
 175 /**
 176  * irq_set_default_host - Set a "default" host
 177  * @host: default host pointer
 178  *
 179  * For convenience, it's possible to set a "default" host that will be used
 180  * whenever NULL is passed to irq_create_mapping(). It makes life easier for
 181  * platforms that want to manipulate a few hard coded interrupt numbers that
 182  * aren't properly represented in the device-tree.
 183  */
 184 extern void irq_set_default_host(struct irq_host *host);
 185
 186
 187 /**
 188  * irq_set_virq_count - Set the maximum number of virt irqs
 189  * @count: number of linux virtual irqs, capped with NR_IRQS
 190  *
 191  * This is mainly for use by platforms like iSeries who want to program
 192  * the virtual irq number in the controller to avoid the reverse mapping
 193  */
 194 extern void irq_set_virq_count(unsigned int count);
 195
 196
 197 /**
 198  * irq_create_mapping - Map a hardware interrupt into linux virq space
 199  * @host: host owning this hardware interrupt or NULL for default host
 200  * @hwirq: hardware irq number in that host space
 201  *
 202  * Only one mapping per hardware interrupt is permitted. Returns a linux
 203  * virq number.
 204  * If the sense/trigger is to be specified, set_irq_type() should be called
 205  * on the number returned from that call.
 206  */
 207 extern unsigned int irq_create_mapping(struct irq_host *host,
 208                                        irq_hw_number_t hwirq);
 209
 210
 211 /**
 212  * irq_dispose_mapping - Unmap an interrupt
 213  * @virq: linux virq number of the interrupt to unmap
 214  */
 215 extern void irq_dispose_mapping(unsigned int virq);
 216
 217 /**
 218  * irq_find_mapping - Find a linux virq from an hw irq number.
 219  * @host: host owning this hardware interrupt
 220  * @hwirq: hardware irq number in that host space
 221  *
 222  * This is a slow path, for use by generic code. It's expected that an
 223  * irq controller implementation directly calls the appropriate low level
 224  * mapping function.
 225  */
 226 extern unsigned int irq_find_mapping(struct irq_host *host,
 227                                      irq_hw_number_t hwirq);
 228
 229 /**
 230  * irq_create_direct_mapping - Allocate a virq for direct mapping
 231  * @host: host to allocate the virq for or NULL for default host
 232  *
 233  * This routine is used for irq controllers which can choose the hardware
 234  * interrupt numbers they generate. In such a case it's simplest to use
 235  * the linux virq as the hardware interrupt number.
 236  */
 237 extern unsigned int irq_create_direct_mapping(struct irq_host *host);
 238
 239 /**
 240  * irq_radix_revmap_insert - Insert a hw irq to linux virq number mapping.
 241  * @host: host owning this hardware interrupt
 242  * @virq: linux irq number
 243  * @hwirq: hardware irq number in that host space
 244  *
 245  * This is for use by irq controllers that use a radix tree reverse
 246  * mapping for fast lookup.
 247  */
 248 extern void irq_radix_revmap_insert(struct irq_host *host, unsigned int virq,
 249                                     irq_hw_number_t hwirq);
 250
 251 /**
 252  * irq_radix_revmap_lookup - Find a linux virq from a hw irq number.
 253  * @host: host owning this hardware interrupt
 254  * @hwirq: hardware irq number in that host space
 255  *
 256  * This is a fast path, for use by irq controller code that uses radix tree
 257  * revmaps
 258  */
 259 extern unsigned int irq_radix_revmap_lookup(struct irq_host *host,
 260                                             irq_hw_number_t hwirq);
 261
 262 /**
 263  * irq_linear_revmap - Find a linux virq from a hw irq number.
 264  * @host: host owning this hardware interrupt
 265  * @hwirq: hardware irq number in that host space
 266  *
 267  * This is a fast path, for use by irq controller code that uses linear
 268  * revmaps. It does fallback to the slow path if the revmap doesn't exist
 269  * yet and will create the revmap entry with appropriate locking
 270  */
 271
 272 extern unsigned int irq_linear_revmap(struct irq_host *host,
 273                                       irq_hw_number_t hwirq);
 274
 275
 276
 277 /**
 278  * irq_alloc_virt - Allocate virtual irq numbers
 279  * @host: host owning these new virtual irqs
 280  * @count: number of consecutive numbers to allocate
 281  * @hint: pass a hint number, the allocator will try to use a 1:1 mapping
 282  *
 283  * This is a low level function that is used internally by irq_create_mapping()
 284  * and that can be used by some irq controllers implementations for things
 285  * like allocating ranges of numbers for MSIs. The revmaps are left untouched.
 286  */
 287 extern unsigned int irq_alloc_virt(struct irq_host *host,
 288                                    unsigned int count,
 289                                    unsigned int hint);
 290
 291 /**
 292  * irq_free_virt - Free virtual irq numbers
 293  * @virq: virtual irq number of the first interrupt to free
 294  * @count: number of interrupts to free
 295  *
 296  * This function is the opposite of irq_alloc_virt. It will not clear reverse
 297  * maps, this should be done previously by unmap'ing the interrupt. In fact,
 298  * all interrupts covered by the range being freed should have been unmapped
 299  * prior to calling this.
 300  */
 301 extern void irq_free_virt(unsigned int virq, unsigned int count);
 302
 303
 304 /* -- OF helpers -- */
 305
 306 /**
 307  * irq_create_of_mapping - Map a hardware interrupt into linux virq space
 308  * @controller: Device node of the interrupt controller
 309  * @inspec: Interrupt specifier from the device-tree
 310  * @intsize: Size of the interrupt specifier from the device-tree
 311  *
 312  * This function is identical to irq_create_mapping except that it takes
 313  * as input informations straight from the device-tree (typically the results
 314  * of the of_irq_map_*() functions.
 315  */
 316 extern unsigned int irq_create_of_mapping(struct device_node *controller,
 317                                           const u32 *intspec, unsigned int intsize);
 318
 319 /**
 320  * irq_of_parse_and_map - Parse and Map an interrupt into linux virq space
 321  * @device: Device node of the device whose interrupt is to be mapped
 322  * @index: Index of the interrupt to map
 323  *
 324  * This function is a wrapper that chains of_irq_map_one() and
 325  * irq_create_of_mapping() to make things easier to callers
 326  */
 327 extern unsigned int irq_of_parse_and_map(struct device_node *dev, int index);
 328
 329 /* -- End OF helpers -- */
 330
 331 /**
 332  * irq_early_init - Init irq remapping subsystem
 333  */
 334 extern void irq_early_init(void);
 335
 336 static __inline__ int irq_canonicalize(int irq)
 337 {
 338         return irq;
 339 }
 340
 341 extern int distribute_irqs;
 342
 343 struct irqaction;
 344 struct pt_regs;
 345
 346 #define __ARCH_HAS_DO_SOFTIRQ
 347
 348 #if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
 349 /*
 350  * Per-cpu stacks for handling critical, debug and machine check
 351  * level interrupts.
 352  */
 353 extern struct thread_info *critirq_ctx[NR_CPUS];
 354 extern struct thread_info *dbgirq_ctx[NR_CPUS];
 355 extern struct thread_info *mcheckirq_ctx[NR_CPUS];
 356 extern void exc_lvl_ctx_init(void);
 357 #else
 358 #define exc_lvl_ctx_init()
 359 #endif
 360
 361 #ifdef CONFIG_IRQSTACKS
 362 /*
 363  * Per-cpu stacks for handling hard and soft interrupts.
 364  */
 365 extern struct thread_info *hardirq_ctx[NR_CPUS];
 366 extern struct thread_info *softirq_ctx[NR_CPUS];
 367
 368 extern void irq_ctx_init(void);
 369 extern void call_do_softirq(struct thread_info *tp);
 370 extern int call_handle_irq(int irq, void *p1,
 371                            struct thread_info *tp, void *func);
 372 #else
 373 #define irq_ctx_init()
 374
 375 #endif /* CONFIG_IRQSTACKS */
 376
 377 extern void do_IRQ(struct pt_regs *regs);
 378
 379 #endif /* _ASM_IRQ_H */
 380 #endif /* __KERNEL__ */