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