linux/kernel/irq/chip.c
<<
>>
Prefs
   1/*
   2 * linux/kernel/irq/chip.c
   3 *
   4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
   5 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
   6 *
   7 * This file contains the core interrupt handling code, for irq-chip
   8 * based architectures.
   9 *
  10 * Detailed information is available in Documentation/DocBook/genericirq
  11 */
  12
  13#include <linux/irq.h>
  14#include <linux/msi.h>
  15#include <linux/module.h>
  16#include <linux/interrupt.h>
  17#include <linux/kernel_stat.h>
  18
  19#include <trace/events/irq.h>
  20
  21#include "internals.h"
  22
  23/**
  24 *      irq_set_chip - set the irq chip for an irq
  25 *      @irq:   irq number
  26 *      @chip:  pointer to irq chip description structure
  27 */
  28int irq_set_chip(unsigned int irq, struct irq_chip *chip)
  29{
  30        unsigned long flags;
  31        struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
  32
  33        if (!desc)
  34                return -EINVAL;
  35
  36        if (!chip)
  37                chip = &no_irq_chip;
  38
  39        desc->irq_data.chip = chip;
  40        irq_put_desc_unlock(desc, flags);
  41        /*
  42         * For !CONFIG_SPARSE_IRQ make the irq show up in
  43         * allocated_irqs. For the CONFIG_SPARSE_IRQ case, it is
  44         * already marked, and this call is harmless.
  45         */
  46        irq_reserve_irq(irq);
  47        return 0;
  48}
  49EXPORT_SYMBOL(irq_set_chip);
  50
  51/**
  52 *      irq_set_type - set the irq trigger type for an irq
  53 *      @irq:   irq number
  54 *      @type:  IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
  55 */
  56int irq_set_irq_type(unsigned int irq, unsigned int type)
  57{
  58        unsigned long flags;
  59        struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
  60        int ret = 0;
  61
  62        if (!desc)
  63                return -EINVAL;
  64
  65        type &= IRQ_TYPE_SENSE_MASK;
  66        ret = __irq_set_trigger(desc, irq, type);
  67        irq_put_desc_busunlock(desc, flags);
  68        return ret;
  69}
  70EXPORT_SYMBOL(irq_set_irq_type);
  71
  72/**
  73 *      irq_set_handler_data - set irq handler data for an irq
  74 *      @irq:   Interrupt number
  75 *      @data:  Pointer to interrupt specific data
  76 *
  77 *      Set the hardware irq controller data for an irq
  78 */
  79int irq_set_handler_data(unsigned int irq, void *data)
  80{
  81        unsigned long flags;
  82        struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
  83
  84        if (!desc)
  85                return -EINVAL;
  86        desc->irq_data.handler_data = data;
  87        irq_put_desc_unlock(desc, flags);
  88        return 0;
  89}
  90EXPORT_SYMBOL(irq_set_handler_data);
  91
  92/**
  93 *      irq_set_msi_desc_off - set MSI descriptor data for an irq at offset
  94 *      @irq_base:      Interrupt number base
  95 *      @irq_offset:    Interrupt number offset
  96 *      @entry:         Pointer to MSI descriptor data
  97 *
  98 *      Set the MSI descriptor entry for an irq at offset
  99 */
 100int irq_set_msi_desc_off(unsigned int irq_base, unsigned int irq_offset,
 101                         struct msi_desc *entry)
 102{
 103        unsigned long flags;
 104        struct irq_desc *desc = irq_get_desc_lock(irq_base + irq_offset, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
 105
 106        if (!desc)
 107                return -EINVAL;
 108        desc->irq_data.msi_desc = entry;
 109        if (entry && !irq_offset)
 110                entry->irq = irq_base;
 111        irq_put_desc_unlock(desc, flags);
 112        return 0;
 113}
 114
 115/**
 116 *      irq_set_msi_desc - set MSI descriptor data for an irq
 117 *      @irq:   Interrupt number
 118 *      @entry: Pointer to MSI descriptor data
 119 *
 120 *      Set the MSI descriptor entry for an irq
 121 */
 122int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
 123{
 124        return irq_set_msi_desc_off(irq, 0, entry);
 125}
 126
 127/**
 128 *      irq_set_chip_data - set irq chip data for an irq
 129 *      @irq:   Interrupt number
 130 *      @data:  Pointer to chip specific data
 131 *
 132 *      Set the hardware irq chip data for an irq
 133 */
 134int irq_set_chip_data(unsigned int irq, void *data)
 135{
 136        unsigned long flags;
 137        struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
 138
 139        if (!desc)
 140                return -EINVAL;
 141        desc->irq_data.chip_data = data;
 142        irq_put_desc_unlock(desc, flags);
 143        return 0;
 144}
 145EXPORT_SYMBOL(irq_set_chip_data);
 146
 147struct irq_data *irq_get_irq_data(unsigned int irq)
 148{
 149        struct irq_desc *desc = irq_to_desc(irq);
 150
 151        return desc ? &desc->irq_data : NULL;
 152}
 153EXPORT_SYMBOL_GPL(irq_get_irq_data);
 154
 155static void irq_state_clr_disabled(struct irq_desc *desc)
 156{
 157        irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
 158}
 159
 160static void irq_state_set_disabled(struct irq_desc *desc)
 161{
 162        irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
 163}
 164
 165static void irq_state_clr_masked(struct irq_desc *desc)
 166{
 167        irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
 168}
 169
 170static void irq_state_set_masked(struct irq_desc *desc)
 171{
 172        irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
 173}
 174
 175int irq_startup(struct irq_desc *desc, bool resend)
 176{
 177        int ret = 0;
 178
 179        irq_state_clr_disabled(desc);
 180        desc->depth = 0;
 181
 182        if (desc->irq_data.chip->irq_startup) {
 183                ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
 184                irq_state_clr_masked(desc);
 185        } else {
 186                irq_enable(desc);
 187        }
 188        if (resend)
 189                check_irq_resend(desc, desc->irq_data.irq);
 190        return ret;
 191}
 192
 193void irq_shutdown(struct irq_desc *desc)
 194{
 195        irq_state_set_disabled(desc);
 196        desc->depth = 1;
 197        if (desc->irq_data.chip->irq_shutdown)
 198                desc->irq_data.chip->irq_shutdown(&desc->irq_data);
 199        else if (desc->irq_data.chip->irq_disable)
 200                desc->irq_data.chip->irq_disable(&desc->irq_data);
 201        else
 202                desc->irq_data.chip->irq_mask(&desc->irq_data);
 203        irq_state_set_masked(desc);
 204}
 205
 206void irq_enable(struct irq_desc *desc)
 207{
 208        irq_state_clr_disabled(desc);
 209        if (desc->irq_data.chip->irq_enable)
 210                desc->irq_data.chip->irq_enable(&desc->irq_data);
 211        else
 212                desc->irq_data.chip->irq_unmask(&desc->irq_data);
 213        irq_state_clr_masked(desc);
 214}
 215
 216/**
 217 * irq_disable - Mark interupt disabled
 218 * @desc:       irq descriptor which should be disabled
 219 *
 220 * If the chip does not implement the irq_disable callback, we
 221 * use a lazy disable approach. That means we mark the interrupt
 222 * disabled, but leave the hardware unmasked. That's an
 223 * optimization because we avoid the hardware access for the
 224 * common case where no interrupt happens after we marked it
 225 * disabled. If an interrupt happens, then the interrupt flow
 226 * handler masks the line at the hardware level and marks it
 227 * pending.
 228 */
 229void irq_disable(struct irq_desc *desc)
 230{
 231        irq_state_set_disabled(desc);
 232        if (desc->irq_data.chip->irq_disable) {
 233                desc->irq_data.chip->irq_disable(&desc->irq_data);
 234                irq_state_set_masked(desc);
 235        }
 236}
 237
 238void irq_percpu_enable(struct irq_desc *desc, unsigned int cpu)
 239{
 240        if (desc->irq_data.chip->irq_enable)
 241                desc->irq_data.chip->irq_enable(&desc->irq_data);
 242        else
 243                desc->irq_data.chip->irq_unmask(&desc->irq_data);
 244        cpumask_set_cpu(cpu, desc->percpu_enabled);
 245}
 246
 247void irq_percpu_disable(struct irq_desc *desc, unsigned int cpu)
 248{
 249        if (desc->irq_data.chip->irq_disable)
 250                desc->irq_data.chip->irq_disable(&desc->irq_data);
 251        else
 252                desc->irq_data.chip->irq_mask(&desc->irq_data);
 253        cpumask_clear_cpu(cpu, desc->percpu_enabled);
 254}
 255
 256static inline void mask_ack_irq(struct irq_desc *desc)
 257{
 258        if (desc->irq_data.chip->irq_mask_ack)
 259                desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
 260        else {
 261                desc->irq_data.chip->irq_mask(&desc->irq_data);
 262                if (desc->irq_data.chip->irq_ack)
 263                        desc->irq_data.chip->irq_ack(&desc->irq_data);
 264        }
 265        irq_state_set_masked(desc);
 266}
 267
 268void mask_irq(struct irq_desc *desc)
 269{
 270        if (desc->irq_data.chip->irq_mask) {
 271                desc->irq_data.chip->irq_mask(&desc->irq_data);
 272                irq_state_set_masked(desc);
 273        }
 274}
 275
 276void unmask_irq(struct irq_desc *desc)
 277{
 278        if (desc->irq_data.chip->irq_unmask) {
 279                desc->irq_data.chip->irq_unmask(&desc->irq_data);
 280                irq_state_clr_masked(desc);
 281        }
 282}
 283
 284/*
 285 *      handle_nested_irq - Handle a nested irq from a irq thread
 286 *      @irq:   the interrupt number
 287 *
 288 *      Handle interrupts which are nested into a threaded interrupt
 289 *      handler. The handler function is called inside the calling
 290 *      threads context.
 291 */
 292void handle_nested_irq(unsigned int irq)
 293{
 294        struct irq_desc *desc = irq_to_desc(irq);
 295        struct irqaction *action;
 296        irqreturn_t action_ret;
 297
 298        might_sleep();
 299
 300        raw_spin_lock_irq(&desc->lock);
 301
 302        desc->istate ;S_WAITING 293{
irq);
desc-> 294        struct3el/ir30hip.c#L175" id="L175" class="line"3name="L203"> 205
;
desc->irq_;
 206void descunlikelya>(struct desc;
(desc->irq_data);
 207{
desc->istate ;desc"+zS_PENDING 298        "sref">descoutut_desc_unlock( 299
 210              3  211        else
<3 href3"kernel/irq/chKED" class="sreicode/a>(&desc->irq_data, IRQD_IINPROGRESS 212              3 descdesc->lock);
 213         214}
desc;
lockhref="_f
irq);;
lock
desc;
lockdev_ilr_masked( 215
descno+codebugr_masked( 216irnote_ernel/irqr_masked(irq);
desc->desc;
et;
 217 218mref">raw_spin_lock_irq(&desc->lock);
 219(&desc->irq_data, IRQD_IINPROGRESS 220 221descoutut_desc_unlock( 222descdesc->lock);
 223 224lockref">EXPORT_SYMBOL_GPL(handle_nested_irq(unsigned int  225 226inline resende=IRf="+copol href="+code=rese=IRf="+copol _irq_esc" class="sref">irq_desc *desc)
 227 228desc->irq_d/a> ;desc"+zS_POLLIINPROGRESS 229void ret;
fals; 230{
ret;
e=dewait_foropol href="+code=rese=IRwait_foropol lass="sref">desc);
 231         232        if ( 233              3  234              3  235        }
 236}
 237
 238void  239{
 240        if (
 241              3 
 242        else
<3 href34 * disabled, but leave the harrrrrrNote:lled span>r is expecpt
 243              3  244         245}
 246
hasallbafromd_irq(unsigned intsallbafromlass==irq" class="sref">irq)
irq_desc *desc =  247void  248{
mref">raw_spink_irq(&desc->lock);
 249        if ( 250              3 descunlikelya>(struct (desc->irq_data);
 251        else
<3 href35f="+code=desc" class=ass=="sref">desce=IRf="+copol href="+code=rese=IRf="+copol _irq_"sref">desc =  252              3 "sref">descoutut_desc_unlock( 253         254}
istate ;S_WAITING 255
irq);
desc-> 256static  257{
descunlikelya>(struct desc->irq_;
(desc->irq_data);
 258        if (desc->irq_d/a> ;desc"+zS_PENDING 259              3 "sref">descoutut_desc_unlock( 260        else {3 261              3  262              3 if (36=desc" class="sref">descned intnel/evo in_irq(unsigned intnel/evo ilass="sref">desc);
 263              3     36hip.c#L284" id="L284" class="line"3name="L263"> 264        }
lockoutut_desc_unlock( 265        desc->lock);
 266}
 267
lockref">EXPORT_SYMBOL_GPL(hasallbafromd_irq(unsigned intsallbafromlass.c#L301" id="L301" class="line" name="L253"> 268void  269{
 270        if (
 271              3  272              3  273        }
irq_desc *desc)
 274}
 275
 276void  277{
 278        if (
 279              3  280              3  281        }
 282}
desce=Idei="+code=delr_masked(desc->irq_data);
 283
desce=Idei="+ate_clr_masked(desc->irq_data);
desc->irq_href="k_oneshoq; 284(struct desc);
 285 286 287 288 289 290 291 292void  293{
 294        struct3 295        struct3 296         297
 298        haa hrefromd_irq(unsigned inta hrefromlass==irq" class="sref">irq)
irq_desc *desc =  299
 300        raw_spink_irq(&desc->lock);
 301
desc);
 302         293{
descunlikelya>(struct (desc->irq_data);
 294        struct4el/ir40f="+code=irq_state_seass=="sref">desce=IRf="+copol href="+code=rese=IRf="+copol _irq_"sref">desc =  205
descoutut_desc_unlock( 206void  207{
istate ;S_WAITING 298        mkf="+_incre=des_thisclear_cpu(irq);
desc-> 299
 210              4  211        else
<4 href41 * use a lazy disable approapppppppp* Ifrits code=del 212              4  213         214}
descunlikelya>(struct desc->irq_;
(desc->irq_data);
 215
desc->irq_d/a> ;desc"+zS_PENDING 216"sref">descoutut_desc_unlock( 217 218 219(unsigned intnel/evo ilass="sref">desc);
 220 221desc);
 222 223lockoutut_desc_unlock( 224(&desc->lock);
 225 226EXPORT_SYMBOL_GPL(haa hrefromd_irq(unsigned inta hrefromlass.c#L301" id="L301" class="line"4name="L204"> 227 228 229void inline void passlow_on is coid irq_desc *desc)
 230{
 231        desc->irq_passlow_on is coid  232        if (desc->irq_passlow_on is coid desc->irq_data);
 233              4  234              4  235        }
inline void passlow_on is coid irq_desc *desc)
 236}
 237
 238void  239{
 240        if (

 241              4 
 242        else
<4 href44 * disabled, but leave the ha+chip.c#L287" id="L287" class="line"4name="L234"> 243              4  244        servicedalleis ene=des supporq/chip.c#L289" id="L289" class="line"4name="L244"> 245}

 246
 247void  248{
 249        if (hafasteoifromd_irq(unsigned intfasteoifromlass==irq" class="sref">irq)
irq_desc *desc =  250              4  251        else
<4 href45kernel/irq/chKED" class="sreref">raw_spink_irq(&desc->lock);
 252              4  253        descunlikelya>(struct (desc->irq_data);
 254}
desce=IRf="+copol href="+code=rese=IRf="+copol _irq_"sref">desc =  255
descout_unlock( 256static  257{
istate ;S_WAITING 258        if (mkf="+_incre=des_thisclear_cpu(irq);
desc-> 259              4  260        else {4 261              4  262              4 if (46 * disabled, but leave the hpppppppp* tftn>e=de itn="keget out of fter:/chip.c#L285" id="L285" class="line"4name="L264"> 263              4     46 * optimization because we apppppppp*q/chip.c#L292" id="L292" class="line"4name="L264"> 264        }
descunlikelya>(struct desc->irq_;
(desc->irq_data);
 265        desc->irq_d/a> ;desc"+zS_PENDING 266}
irsk_irq(struct desc);
 267
"sref">descout_unlock( 268void  269{
 270        if (desc->irq_d/a> ;desc"+zS_ONESHOT 271              4 irsk_irq(struct desc);
 272              4  273        }
desc);
 274}
desc);
 275
 276void desc->irq_d/a> ;desc"+zS_ONESHOT 277{
desccond_mask_irq(struct desc);
 278        if ( 279              4  280              4 irq_data);
descc="la>(struct irq_dataeoi_unlock(desc->irq_data);
 281        }
descoutut_desc_unlock( 282}
descdesc->lock);
 283
 284lockout_unlock( 285desc->irq_data);
descc="la>(struct irq_flager_masked( ="sref">desc"+zCHIP_EOI_IF_HANDLED 286"sref">descoutueoi_unlock( 287"sref">descoutut_desc_unlock( 288 289 290 291 292void  293{
 294        struct4 295        struct4
+chip.c#L287" id="L287" class="line"4name="L284"> 296        
+chip.c#L287" id="L287" class="line"4name="L264"> 297
 298        
 299
 300        
 291
alleis requi>
sf
o reene=de>
 292void 

 293{
 294        struct5el/ir50 * common case where no interooooooloop is leftq/chip.c#L291" id="L291" class="line"5name="L205"> 205
 206void  207{
lockned intelgefromn_irq(unsigned intelgefromlass==irq" class="sref">irq)
irq_desc *desc =  298         299
raw_spink_irq(&desc->lock);
 210              5  211        else
<5 href51kernel/irq/chKED" class="sre->istate ;S_WAITING 212              5  213         214}
 215
 216 217descunlikelya>(struct (desc->irq_data);
 218(desc->irq_data);
desc->irq_;
 219desce=IRf="+copol href="+code=rese=IRf="+copol _irq_"sref">desc =  220istate ;desc"+zS_PENDING 221desc);
 222"sref">descoutut_desc_unlock( 223 224 225irq);
desc-> 226 227 228m->irq_data);
descc="la>(struct irq_nel/asc_unlock(desc->irq_data);
 229void  230{
 231        descunlikelya>(struct desc->irq_;
 232        if (desc);
 233              5 descoutut_desc_unlock( 234              5  235        }
 236}
 237
="o
 238void  239{
 240        if ( 241              5 descunlikelya>(struct istate ;desc"+zS_PENDING 242        else
<5 href54f="+code=desc" class=rq/ch/chass=="sref">desce=Idei="+code=delr_masked(desc->irq_data);
 243              5 desce=Idei="+ate_clr_masked(desc->irq_data);
 244        descmask_irq(struct desc);
 245}
 246
 247void descned intnel/evo in_irq(unsigned intnel/evo ilass="sref">desc);
 248{
 249        if (istate ;desc"+zS_PENDING  #L292" id="L292" class="line"5name="L255"> 250              5 desce=Idei="+code=delr_masked(desc->irq_data);
 251        else
<5 href55hip.c#L302" id="L302" class="line"5name="L235"> 252              5 descoutut_desc_unlock( 253        raw_t_desck_irq(&desc->lock);
 254}
 255
lockef="+code=irqa href="kernel/ef="+code=irqlass="sref">descned intelgefromn_irq(unsigned intelgefromlass.c#L301" id="L301" class="line"5name="L235"> 256static  257{
 258        if ( 259              5  260        else {5

 261              5 
 262              5 if (56 * disabled, but leave the hq/chip.c#L217" id="L217" class="line"5name="L265"> 263              5     56 * optimization because we a* Similarkasks itabovelned intelgefrom, but usingseoifn i w/o/irq/chip.c#L224" id="L224" class="line"5name="L265"> 264        }
 265         266}
descned intelgefeoifromn_irq(unsigned intelgefeoifromlass==irq" class="sref">irq)
irq_desc *desc =  267
 268void irq_descc="la>(struct descc="la>(struct desce=desc" _getcc="la>(struct desc);
 269{
 270        if (raw_spink_irq(&desc->lock);
 271              5  272              5 desc->istate ;S_WAITING 273        }
 274}
 275
 276void  277{
 278        if (descunlikelya>(struct (desc->irq_data);
 279              5 desc hrdei="+inprogr"ker_masked(desc->irq_data);
desc->irq_;
 280              5 desce=IRf="+copol href="+code=rese=IRf="+copol _irq_"sref">desc =  281        }
istate ;desc"+zS_PENDING 282}
"sref">descoutueoi_unlock( 283
 284 285irq);
desc-> 286 287 288descunlikelya>(struct desc->irq_;
 289"sref">descoutueoi_unlock( 290 291irned intnel/evo in_irq(unsigned intnel/evo ilass="sref">desc);
 292void  293{
istate ;desc"+zS_PENDING  #L292" id="L292" class="line"5name="L285"> 294        struct5desce=Idei="+code=delr_masked(desc->irq_data);
 295        struct5 296         297
(struct irq_nel/eoi_unlock(desc->irq_data);
 298        mref">raw_t_desck_irq(&desc->lock);
 299
 300         291 292void  293{
 294        struct6el/ir60 * common case where no interoooooor
 205
 206void  297
 298         299
 210              6 irned intperleafromn_irq(unsigned intperleafromlass==irq" class="sref">irq)
irq_desc *desc =  211        else
<6 href61kernec#L279" id="L279" class="line"6name="L306"> 212              6 irq_descc="la>(struct descc="la>(struct desce=desc" _getcc="la>(struct desc);
 213         214}
(irq);
desc-> 215
 216descc="la>(struct irq_nel/asc_unlock( 217descc="la>(struct irq_nel/asc_unlock(desc->irq_data);
 218 219(unsigned intnel/evo itperlealass="sref">desc);
desc->irq_;
 220 221descc="la>(struct irq_nel/eoi_unlock( 222(struct irq_nel/eoi_unlock(desc->irq_data);
 223 224 225 226 227>>>>>
 228 229void  230{

rnels. Sf=" as+chip.c#L287" id="L287" class="line"6name="L236"> 231         232        if ( 233              6  234              6  235        }
 236}
 237
descned intperleafdevidfromn_irq(unsigned intperleafdevidfromlass==irq" class="sref">irq)
irq_desc *desc =  238void  239{
irq_descc="la>(struct descc="la>(struct desce=desc" _getcc="la>(struct desc);
 240        if (irq_des;
desc;
desc->irq_;
 241              6 desc =v_id;desc__thisclea_ptcoid desc;
irq_perleafdev_id 242        else
<6 href64=desc" class="sref">descclaclass=_in_irq(unsigclaclass=_idesc" class="sref">mreer_masked( 243              6  244        (irq);
desc-> 245}
 246
descc="la>(struct irq_nel/asc_unlock( 247void descc="la>(struct irq_nel/asc_unlock(desc->irq_data);
 248{
 249        if ((struct irq);
desc;
 250              6 desc;
irq_on is coid desc
desc-&v_id; 251        else
<6 href65kernel/irq/chKED" class="sretracntnel/(unsigtracntnel/irq);
desc;
descreer_masked( 252              6  253        descc="la>(struct irq_nel/eoi_unlock( 254}
(struct irq_nel/eoi_unlock(desc->irq_data);
 255
 256static  257{
 258        if (desc__nel/setcon is coid irq)
irq_dataslow_on is c_in_irq(unsigclaaslow_on is c_idesc" class="sref">mon is oid irq)
( 259              6 desc    r_masked( 260        else {6 261              6 irq)
flager_masked( 262              6 if (66=desc" class=esc" class="sref">irq_desc *desc = desce=degetcsc" _bus);
irq);
descflager_masked( 263              6     66 * op#L281" id="L281" class="line"6name="L266"> 264        }
desc-> 265         266}
 267
descon is oid  268void descon is oid descned intbadfromn_irq(unsigned intbadfromodatc#L280" id="L280" class="line"6name="L236"> 269{
 270        if (descWARN_ONn_irq(unsigWARN_ONlass="sref">desc);
irq_data);
descc="la>(struct descno_descc="la>(struct  271              6 "sref">descouta>(struct  272              6  273        }
 274}
 275
descon is oid descned intbadfromn_irq(unsigned intbadfromodatp.c#L279" id="L279" class="line"6name="L266"> 276void desc);
irq_data);
descc="la>(struct descno_descc="la>(struct  277{
descmask_ack_irq(struct desc);
 278        if (descnel/s="+c/setccode=delr_masked(desc);
 279              6 desc);
irq_deptha href="kernel/irpthhip. s=1c#L281" id="L281" class="line"6name="L286"> 280              6  281        }
irq_ned intneln_irq(unsigned intde=irq_ s="sref">descned inoid  282}
desc->istate    r_masked(desc    r_masked( 283
 284descon is oid descned intbadfromn_irq(unsigned intbadfromodate  "sref">irq)
( 285descnel/settings/setcnoprob;desc);
 286descnel/settings/setcnorequesin_irq(unsigclaasettings/setcnorequesiirq_d"sref">desc);
 287descclaasettings/setcnotef"alr_masked(desc);
 288descnel/s="rtula>(struct desc);
irq_tru; 289 290irouta>(struct  291(&descputcsc" _bust_descirq_d"sref">desc);
irq_flager_masked( 292void  293{
irq_ef="+code=irq_GPqa href="kernel/ef="+code=irq_GPqirq_d"sref">desc__nel/setcon is coid  294        struct6 295        struct6 296        (irq)
irq_descc="la>(struct descc="la>(struct  297
mon is oid desc    r_masked( 298         299
irq);
descc="la>(struct  300        irq);
descon is oid desc    r_masked( 291 292void descef="+code=irq_GPqa href="kernel/ef="+code=irq_GPqirq_d"sref">descnel/setcs="l_n i_on is c_    r_masked( 293{
 294        struct7el/ir70 * coq" c="sref">descnel/modify/s="+uer_masked(irq)
irq)
clcoid irq)
setoid  205
 206void irq)
flager_masked( 297
irq_desc *desc = desce=degetcsc" _);
irq);
descflager_masked( 298         299
desc-> 210              7  211        else
<7 href71kernel/irq/chKED" class="sredescsettings/clc_n i_setoid desc);
irq_clcoid irq)
setoid  212              7  213        desc->irq_data);
irq)
IRQD_NO_BALANCINGD_PER_CPU 214}
D_LEVEqa href="kernel/f">D_LEVEqirq_s|SKED" class="sref">D_MOVE_PCNTXTa href="kernel/f">D_MOVE_PCNTXT_irq)c#L301" id="L301" class="line"7name="L207"> 215
descdescsettings/has_no_balance_setoid desc);
 216descneli_setoid desc->irq_data);
irq)
IRQD_NO_BALANCING 217descdescsettings/istperclear_cpu(desc);
 218descneli_setoid desc->irq_data);
irq)
IRQD_PER_CPU 219desc);
 220descneli_setoid desc->irq_data);
irq)
IRQD_MOVE_PCNTXTa href="kernel/f">D_MOVE_PCNTXT_irq)c#L301" id="L301" class="line"7name="L227"> 221descdescsettings/istleve href="+code=rese=IRsettings/istleve irq_d"sref">desc);
 222desc->irq_data);
irq)
IRQD_LEVEqa href="kernel/f">D_LEVEqirq_)c#L301" id="L301" class="line"7n3me="L307"> 223 224desc->irq_data);
irq)
e=IRsettings/getctriggerchrefhref="+code=rese=IRsettings/getctriggerchrefirq_d"sref">desc);
 225 226(&descputcsc" _t_descirq_d"sref">desc);
irq_flager_masked( 227 228descef="+code=irq_GPqa href="kernel/ef="+code=irq_GPqirq_d"sref">descnel/modify/s="+uer_masked( 229void  230{
 231         232        if ( 233              7  234              7  235        }
 236}
descaesccpu_on    a>(struct  237
 238void irq_desc *desc =  239{
irq_descc="la>(struct descc="la>(struct  240        if (irq)
flager_masked( 241              7 irq)
 242        else
<7 href74hip.c#L193" id="L193" class="line"7name="L237"> 243              7 (unsignel_each_/irqvntnelass="sref">irq);
 244        desce=detoc *irq);
 245}
desc-> 246
 247void  248{
descdesc->irq_);
irq_flager_masked( 249        if ( 250              7 descc="la>(struct irq_descdesc->irq_data);
 251        else
<7 href75f="+code=desc" class=ass="sref">descc="la>(struct irq)
c="la>(struct irq_datacpu_on    a>(struct   #L292" id="L292" class="line"7name="L307"> 252              7 descc="la>(struct irq_flager_masked( ="sref">desc"+zCHIP_ONOFFLINE_ENABLEDa href="kernel/f">CHIP_ONOFFLINE_ENABLEDchipp.||#L292" id="L292" class="linea7name="L257"> 253        desce=Idei="+code=delr_masked(desc->irq_data);
 254}
descc="la>(struct irq_datacpu_on    a>(struct desc->irq_data);
 255
 256static desc(struct desc->irq_);
irq_flager_masked( 257{
 258        if ( 259              7  260        else {7 261              7  262              7 if (76 * disabled, but leave the hq/chip.c#L217" id="L217" class="line"7name="L267"> 263              7     76 * optimization because we avooooooIterate through allcaesskn i invoke ire l="liaesccpu_off    ()/chip.c#L217" id="L217" class="line"7name="L267"> 264        }
 265         266}
descaesccpu_off    a>(struct  267
 268void irq_desc *desc =  269{
irq_descc="la>(struct descc="la>(struct  270        if (irq)
flager_masked( 271              7 irq)
 272              7  273        }
(unsignel_each_/irqvntnelass="sref">irq);
 274}
desce=detoc *irq);
 275
desc-> 276void  277{
 278        if (descdesc->irq_);
irq_flager_masked( 279              7  280              7 descc="la>(struct irq_descdesc->irq_data);
 281        }
descc="la>(struct irq)
c="la>(struct irq_datacpu_off    a>(struct   #L292" id="L292" class="line"7name="L267"> 282}
descc="la>(struct irq_flager_masked( ="sref">desc"+zCHIP_ONOFFLINE_ENABLEDa href="kernel/f">CHIP_ONOFFLINE_ENABLEDchipp.||#L292" id="L292" class="linea7name="L277"> 283
desce=Idei="+code=delr_masked(desc->irq_data);
 284descc="la>(struct irq_datacpu_off    a>(struct desc->irq_data);
 285 286desc(struct desc->irq_);
irq_flager_masked( 287 288 289


The original LXR software by ire L174" id=http://sourcenelge.net/projects/lxr">LXR ted_unitychip,diris experi_irqal versllinby L174" id=mailto:lxr@spaux.nol/ixr@spaux.nochip.
ixr.spaux.no kindly hostclaby L174" id=http://www.redpill-spapro.nol/Redpill Lpapro ASchip,dprovider of Lpauxdconsultingkn i operatq/cs servic s since 1995.