static irqreturn_t yam_interrupt(int irq, void *dev_id, struct pt_regs *regs) { struct net_device *dev; struct yam_port *yp; unsigned char iir; int counter = 100; int i; int handled = 0; for (i = 0; i < NR_PORTS; i++) { dev = yam_devs[i]; yp = dev->priv; if (!netif_running(dev)) continue; while ((iir = IIR_MASK & inb(IIR(dev->base_addr))) != IIR_NOPEND) { unsigned char msr = inb(MSR(dev->base_addr)); unsigned char lsr = inb(LSR(dev->base_addr)); unsigned char rxb; handled = 1; if (lsr & LSR_OE) ++yp->stats.rx_fifo_errors; yp->dcd = (msr & RX_DCD) ? 1 : 0; if (--counter <= 0) { printk(KERN_ERR "%s: too many irq iir=%d\n", dev->name, iir); goto out; } if (msr & TX_RDY) { ++yp->nb_mdint; yam_tx_byte(dev, yp); } if (lsr & LSR_RXC) { ++yp->nb_rxint; rxb = inb(RBR(dev->base_addr)); if (msr & RX_FLAG) yam_rx_flag(dev, yp); else yam_rx_byte(dev, yp, rxb); } } } out: return IRQ_RETVAL(handled); }
/* The interrupt handler does all of the Rx thread work and cleans up after the Tx thread. */ static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance, struct pt_regs *regs) { struct net_device *dev = (struct net_device *) dev_instance; struct rtl8169_private *tp = dev->priv; int boguscnt = max_interrupt_work; void *ioaddr = tp->mmio_addr; int status = 0; int handled = 0; do { status = RTL_R16(IntrStatus); /* hotplug/major error/no more work/shared irq */ if ((status == 0xFFFF) || !status) break; handled = 1; /* if (status & RxUnderrun) link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit; */ RTL_W16(IntrStatus, (status & RxFIFOOver) ? (status | RxOverflow) : status); if (!(status & rtl8169_intr_mask)) break; // Rx interrupt if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver)) { rtl8169_rx_interrupt(dev, tp, ioaddr); } // Tx interrupt if (status & (TxOK | TxErr)) { spin_lock(&tp->lock); rtl8169_tx_interrupt(dev, tp, ioaddr); spin_unlock(&tp->lock); } boguscnt--; } while (boguscnt > 0); if (boguscnt <= 0) { printk(KERN_WARNING "%s: Too much work at interrupt!\n", dev->name); /* Clear all interrupt sources. */ RTL_W16(IntrStatus, 0xffff); } return IRQ_RETVAL(handled); }
irqreturn_t pci1742_interrupt_handler(int irq, void *dev_id) #endif { private_data *privdata = (private_data *) dev_id; INT16U tmp; /* printk("isr!\n"); */ /* mdelay(1000); */ tmp = advInp(privdata, 0x07) & 0x08; if (tmp) { /* interrupt from A/D or FIFO */ /* KdPrint("isr!\n"); */ if (privdata->fifo_enable) { pci1742_fifo_isr(privdata); } else { pci1742_nofifo_isr(privdata); } /* clear interrupt */ advOutp(privdata, 0x08, 0x00); /* advOutp(privdata, 0x09, 0x00); */ } else { /* interrupt from PCI9054 */ tmp = advInp(privdata, 0x6a) & 0x20; if (tmp != 0x20) { return IRQ_RETVAL(0); } pci1742_dma_isr(privdata); /* clear DMA interrupt */ /* advOutpDMA(privdata, 0xa8, advInpDMA(privdata, 0xa8) | 0x08); */ } return IRQ_RETVAL(1); }
static irqreturn_t nv_do_interrupt(struct ata_host_set *host_set, u8 irq_stat) { int i, handled = 0; for (i = 0; i < host_set->n_ports; i++) { struct ata_port *ap = host_set->ports[i]; if (ap && !(ap->flags & ATA_FLAG_DISABLED)) handled += nv_host_intr(ap, irq_stat); irq_stat >>= NV_INT_PORT_SHIFT; } return IRQ_RETVAL(handled); }
/*按键中断处理函数*/ static irqreturn_t buttons_interrupt(int irq, void *dev_id) { int i; for(i=0; i<6; i++){ if(irq == button_irqs[i]){ //printk("==>interrput number:%d\n",irq); key_value = i; ev_press =1; wake_up_interruptible(&button_waitq); } } return IRQ_RETVAL(IRQ_HANDLED); }
static irqreturn_t buttons_interrupt(int irq, void *dev_id) { struct button_irq_desc *button_irq = (struct button_irq_desc *)dev_id; int down; down = !s3c2410_gpio_getpin(button_irq->pin); if (down != (key_values[button_irq->number] & 1)) { /* printk(KERN_ALERT "key_values[button_irq->number] & 1 = %d\n", key_values[button_irq->number] & 1); */ key_values[button_irq->number] = '0' + down; ev_press = 1; wake_up_interruptible(&button_waitq); } return IRQ_RETVAL(IRQ_HANDLED); }
/* * Handle completion of command and data transfers. */ static irqreturn_t ak98_mci_irq(int irq, void *dev_id) { struct ak98_mci_host *host = dev_id; u32 status; int ret = 0; PK("+%s ", __func__); spin_lock(&host->lock); do { struct mmc_command *cmd; struct mmc_data *data; status = readl(host->base + AK98MCISTATUS); PK(" status= 0x%08x\n", status); #ifdef AKMCI_INNERFIFO_PIO if (host->data) ak98_mci_pio_irq(host, status); #endif cmd = host->cmd; if (status & (MCI_RESPCRCFAIL|MCI_RESPTIMEOUT|MCI_CMDSENT|MCI_RESPEND) && cmd) ak98_mci_cmd_irq(host, cmd, status); data = host->data; if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_DATAEND|MCI_DATABLOCKEND|MCI_STARTBIT_ERR) && data) ak98_mci_data_irq(host, data, status); #ifdef SDIO if (status & MCI_SDIOINT) { mmc_signal_sdio_irq(host->mmc); } #endif ret = 1; } while (0); spin_unlock(&host->lock); PK("-%s, irqmask: 0x%08x\n", __func__, readl(host->base + AK98MCIMASK)); return IRQ_RETVAL(ret); }
irqreturn_t pb1200_cascade_handler( int irq, void *dev_id) { unsigned short bisr = bcsr->int_status; int extirq_nr = 0; /* Clear all the edge interrupts. This has no effect on level */ bcsr->int_status = bisr; for( ; bisr; bisr &= (bisr-1) ) { extirq_nr = (PB1200_INT_BEGIN-1) + au_ffs(bisr); /* Ack and dispatch IRQ */ do_IRQ(extirq_nr); } return IRQ_RETVAL(1); }
static irqreturn_t imxmci_irq(int irq, void *devid) { struct imxmci_host *host = devid; uint32_t stat = MMC_STATUS; int handled = 1; MMC_INT_MASK = host->imask | INT_MASK_SDIO | INT_MASK_AUTO_CARD_DETECT; atomic_set(&host->stuck_timeout, 0); host->status_reg = stat; set_bit(IMXMCI_PEND_IRQ_b, &host->pending_events); set_bit(IMXMCI_PEND_STARTED_b, &host->pending_events); tasklet_schedule(&host->tasklet); return IRQ_RETVAL(handled);; }
static irqreturn_t dvfs_irq(int irq, void *dev_id) { u32 pmcr0 = __raw_readl(MXC_CCM_PMCR0); /* Config dvfs_start bit */ pmcr0 = pmcr0 | MXC_CCM_PMCR0_DVFS_START; /*Mask interrupt */ pmcr0 = pmcr0 | MXC_CCM_PMCR0_FSVAIM; __raw_writel(pmcr0, MXC_CCM_PMCR0); stored_pmcr0 = pmcr0; schedule_delayed_work(&dvfs_work, 0); return IRQ_RETVAL(1); }
static irqreturn_t altera_uart_interrupt(int irq, void *data) { struct uart_port *port = data; struct altera_uart *pp = container_of(port, struct altera_uart, port); unsigned int isr; isr = altera_uart_readl(port, ALTERA_UART_STATUS_REG) & pp->imr; spin_lock(&port->lock); if (isr & ALTERA_UART_STATUS_RRDY_MSK) altera_uart_rx_chars(pp); if (isr & ALTERA_UART_STATUS_TRDY_MSK) altera_uart_tx_chars(pp); spin_unlock(&port->lock); return IRQ_RETVAL(isr); }
static irqreturn_t sca_intr(int irq, void *dev_id) { card_t *card = dev_id; u32 isr0 = sca_inl(ISR0, card); int i, handled = 0; for (i = 0; i < 2; i++) { port_t *port = get_port(card, i); if (port && (isr0 & (i ? 0x08002200 : 0x00080022))) { handled = 1; disable_intr(port); napi_schedule(&port->napi); } } return IRQ_RETVAL(handled); }
static irqreturn_t isp_isr(int irq, void *dev_id) { struct isp_t *dev; unsigned long flags; dev = (struct isp_t *) dev_id; spin_lock_irqsave(&dev->lock, flags); dev->isp_status.status = reg_read(isp_base, ISP_STATUS_OFFSET); spin_unlock_irqrestore(&dev->lock, flags); reg_write(isp_base, ISP_STATUS_OFFSET, dev->isp_status.status); complete(&dev->irq_sem); return IRQ_RETVAL(1); }
static irqreturn_t buttons_interrupt(int irq, void *dev_id) { //获取当前按键资源的索引 int key = (int)dev_id; if(key_status[key] == KEY_UP) { //设置当前按键的状态为不确定 key_status[key] = KEY_UNCERTAIN; //设置当前按键按下去抖定时器的延时并启动定时器 key_timers[key].expires = jiffies + KEY_TIMER_DELAY1; add_timer(&key_timers[key]); } return IRQ_RETVAL(IRQ_HANDLED); }
static irqreturn_t tiny6410_keys_irq(int irq, void *dev_id) { unsigned int tmp; irq_dev = (struct key_desc *)dev_id; if ((irq_dev->irq == IRQ_EINT(19)) || (irq_dev->irq == IRQ_EINT(20))) { tmp = readl(S3C64XX_GPLDAT); irq_dev->pin_val = tmp & (1<<irq_dev->pin); }else { tmp = readl(S3C64XX_GPNDAT); irq_dev->pin_val = tmp & (1<<irq_dev->pin); } /* Start the timer after 10ms */ mod_timer(&keys_timers, jiffies+HZ/100); return IRQ_RETVAL(IRQ_HANDLED); }
/*! ******************************************************************************* * This function is the Top Half of the interrupt handler. It updates the * status of any finished descriptor chains and then tries to add any pending * requests into the hardware. It then queues the bottom half to complete * operations on the finished chains. * * @brief SAHARA Interrupt Handler Top Half * * @param irq Part of the kernel prototype. * @param dev_id Part of the kernel prototype. * * @return An IRQ_RETVAL() -- non-zero to that function means 'handled' */ static irqreturn_t sah_Intr_Top_Half(int irq, void *dev_id) { #if defined(DIAG_DRV_INTERRUPT) && defined(DIAG_DURING_INTERRUPT) LOG_KDIAG("Top half of Sahara's interrupt handler called."); #endif interrupt_count++; reset_flag = sah_Handle_Interrupt(sah_HW_Read_Status()); /* Schedule the Bottom Half of the Interrupt. */ tasklet_schedule(&BH_task); /* To get rid of the unused parameter warnings. */ irq = 0; dev_id = NULL; return IRQ_RETVAL(1); }
static irqreturn_t bsm_intr( int irq, void *dev_id ) { int handled=0; T32smSysCtl_SM_CTRL reg; //Clear the SM2SoC interrupt reg.u32=MV_SM_READ_REG32( SM_SM_SYS_CTRL_REG_BASE + RA_smSysCtl_SM_CTRL); #ifdef CONFIG_MV88DE3010_BERLIN_B0 reg.uSM_CTRL_SM2SOC_SW_INTR=0;//enable interrupt #else reg.uSM_CTRL_CTRL_INT=0; #endif MV_SM_WRITE_REG32( SM_SM_SYS_CTRL_REG_BASE + RA_smSysCtl_SM_CTRL,reg.u32); SMDriverprintf(("sm int\n")); bsm_msg_dispatch(); return IRQ_RETVAL(handled); }
irqreturn_t gusintr(int irq, void *dev_id, struct pt_regs *dummy) { unsigned char src; extern int gus_timer_enabled; int handled = 0; #ifdef CONFIG_SOUND_GUSMAX if (have_gus_max) { struct address_info *hw_config = dev_id; adintr(irq, (void *)hw_config->slots[1], NULL); } #endif #ifdef CONFIG_SOUND_GUS16 if (db16) { struct address_info *hw_config = dev_id; adintr(irq, (void *)hw_config->slots[3], NULL); } #endif while (1) { if (!(src = inb(u_IrqStatus))) break; handled = 1; if (src & DMA_TC_IRQ) { guswave_dma_irq(); } if (src & (MIDI_TX_IRQ | MIDI_RX_IRQ)) { gus_midi_interrupt(0); } if (src & (GF1_TIMER1_IRQ | GF1_TIMER2_IRQ)) { if (gus_timer_enabled) sound_timer_interrupt(); gus_write8(0x45, 0); /* Ack IRQ */ gus_timer_command(4, 0x80); /* Reset IRQ flags */ } if (src & (WAVETABLE_IRQ | ENVELOPE_IRQ)) gus_voice_irq(); } return IRQ_RETVAL(handled); }
/*本按键驱动的中断服务程序*/ static irqreturn_t buttons_interrupt(int irq, void* dev_id) { struct button_irq_desc* button_irqs = (struct button_irq_desc*)dev_id; int down; // udelay(0); /*获取被按下的按键状态*/ down = !s3c2410_gpio_getpin(button_irqs->pin); /*状态改变,按键被按下,从这句可以看出,当按键没有被按下的时候,寄存器的值为1(上拉),但按键被按下的时候,寄存器对应的值为0*/ if (down != (key_values[button_irqs->number] & 1)) { // Changed /*如果key1 被按下,则key_value[0]就变为’1’,对应的ASCII 码为31*/ key_values[button_irqs->number] = '0' + down; ev_press = 1; /*设置中断标志为1*/ wake_up_interruptible(&button_waitq); /*唤醒等待队列*/ } return IRQ_RETVAL(IRQ_HANDLED); }
/* * Interrupt service routine. */ static irqreturn_t dio200_interrupt(int irq, void *d) { struct comedi_device *dev = d; struct dio200_private *devpriv = dev->private; struct comedi_subdevice *s; int handled; if (!dev->attached) return IRQ_NONE; if (devpriv->intr_sd >= 0) { s = &dev->subdevices[devpriv->intr_sd]; handled = dio200_handle_read_intr(dev, s); } else { handled = 0; } return IRQ_RETVAL(handled); }
/* The typical workload of the driver: Handle the network interface interrupts. */ static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs * regs) { struct net_device *dev = dev_id; struct net_local *lp; int ioaddr, status, boguscount = 0; int handled = 0; ioaddr = dev->base_addr; lp = netdev_priv(dev); status = inw(SEEQ_STATUS); do { if (net_debug >2) { printk("%s: int, status=0x%04x\n",dev->name,status); } if (status & SEEQSTAT_WINDOW_INT) { handled = 1; outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD); if (net_debug) { printk("%s: window int!\n",dev->name); } } if (status & SEEQSTAT_TX_INT) { handled = 1; outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD); lp->stats.tx_packets++; netif_wake_queue(dev); /* Inform upper layers. */ } if (status & SEEQSTAT_RX_INT) { handled = 1; /* Got a packet(s). */ seeq8005_rx(dev); } status = inw(SEEQ_STATUS); } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ; if(net_debug>2) { printk("%s: eoi\n",dev->name); } return IRQ_RETVAL(handled); }
static irqreturn_t msmsdcc_irq(int irq, void *dev_id) { struct msmsdcc_host *host = dev_id; void __iomem *base = host->base; u32 status; int ret = 0; int cardint = 0; spin_lock(&host->lock); do { status = readl(base + MMCISTATUS); status &= (readl(base + MMCIMASK0) | MCI_DATABLOCKENDMASK); writel(status, base + MMCICLEAR); msmsdcc_handle_irq_data(host, status, base); if (status & (MCI_CMDSENT | MCI_CMDRESPEND | MCI_CMDCRCFAIL | MCI_CMDTIMEOUT) && host->curr.cmd) { msmsdcc_do_cmdirq(host, status); } if (status & MCI_SDIOINTOPER) { cardint = 1; status &= ~MCI_SDIOINTOPER; } ret = 1; } while (status); spin_unlock(&host->lock); /* * We have to delay handling the card interrupt as it calls * back into the driver. */ if (cardint) mmc_signal_sdio_irq(host->mmc); return IRQ_RETVAL(ret); }
static irqreturn_t nic_interrupt(int irq, void *dev_num,struct pt_regs *regs) { struct net_device *dev = (struct net_device *)dev_num; struct nic_private *np = netdev_priv(dev); u16 status; int txstatus; u16 handled=0; printk("In interrupt..."); status = readb(np->iobase+ISR); /* shared irq? */ if (status == 0) goto out; handled = 1; /* Receive packets are processed by poll routine. If not running start it now. */ if(status & RxAckBits){ if (netif_rx_schedule_prep(dev)) __netif_rx_schedule(dev); } /*handle trasmission interrupts*/ if (status & (TxOK | TxErr)) { /*get txstatus form TSD*/ txstatus= readl(np->iobase+TxStatus0); if (!(txstatus & TxStatOK)) goto out; /* It still hasn't been Txed */ np->txcount++; if (status & TxErr) writew (TxErr,np->iobase+ISR); } out: return IRQ_RETVAL(handled); }
static irqreturn_t rio_interrupt (int irq, void *dev_instance) { struct net_device *dev = dev_instance; struct netdev_private *np; unsigned int_status; long ioaddr; int cnt = max_intrloop; int handled = 0; ioaddr = dev->base_addr; np = netdev_priv(dev); while (1) { int_status = readw (ioaddr + IntStatus); writew (int_status, ioaddr + IntStatus); int_status &= DEFAULT_INTR; if (int_status == 0 || --cnt < 0) break; handled = 1; /* Processing received packets */ if (int_status & RxDMAComplete) receive_packet (dev); /* TxDMAComplete interrupt */ if ((int_status & (TxDMAComplete|IntRequested))) { int tx_status; tx_status = readl (ioaddr + TxStatus); if (tx_status & 0x01) tx_error (dev, tx_status); /* Free used tx skbuffs */ rio_free_tx (dev, 1); } /* Handle uncommon events */ if (int_status & (HostError | LinkEvent | UpdateStats)) rio_error (dev, int_status); } if (np->cur_tx != np->old_tx) writel (100, ioaddr + CountDown); return IRQ_RETVAL(handled); }
static irqreturn_t snd_gusmax_interrupt(int irq, void *dev_id) { struct snd_gusmax *maxcard = dev_id; int loop, max = 5; int handled = 0; do { loop = 0; if (inb(maxcard->gus_status_reg)) { handled = 1; snd_gus_interrupt(irq, maxcard->gus); loop++; } if (inb(maxcard->pcm_status_reg) & 0x01) { handled = 1; snd_wss_interrupt(irq, maxcard->wss); loop++; } } while (loop && --max > 0); return IRQ_RETVAL(handled); }
irqreturn_t nv_gvi_kern_isr( int irq, void *arg #if !defined(NV_IRQ_HANDLER_T_PRESENT) || (NV_IRQ_HANDLER_T_ARGUMENT_COUNT == 3) ,struct pt_regs *regs #endif ) { nv_linux_state_t *nvl = (void *) arg; nv_state_t *nv = NV_STATE_PTR(nvl); NvU32 need_to_run_bottom_half = 0; BOOL ret = TRUE; ret = rm_gvi_isr(nvl->isr_sp, nv, &need_to_run_bottom_half); if (need_to_run_bottom_half && !(nv->flags & NV_FLAG_GVI_IN_SUSPEND)) { NV_TASKQUEUE_SCHEDULE(&nvl->work.task); } return IRQ_RETVAL(ret); }
static irqreturn_t cx25821_upstream_irq(int irq, void *dev_id) { struct cx25821_channel *chan = dev_id; struct cx25821_dev *dev = chan->dev; u32 vid_status; int handled = 0; const struct sram_channel *sram_ch; if (!dev) return -1; sram_ch = chan->sram_channels; vid_status = cx_read(sram_ch->int_stat); /* Only deal with our interrupt */ if (vid_status) handled = cx25821_video_upstream_irq(chan, vid_status); return IRQ_RETVAL(handled); }
/* * 确定按键值 */ static irqreturn_t buttons_irq(int irq, void *dev_id) { struct pin_desc *pindesc = (struct pin_desc *)dev_id; unsigned int pinval; pinval = s3c2410_gpio_getpin(pindesc->pin); if(pinval){ /*松开*/ key_val = 0x80 | pindesc->key_val; } else{ /*按下*/ key_val = pindesc->key_val; } ev_press = 1; /*表示中断发生了*/ wake_up_interruptible(&button_waitq); /*唤醒休眠的进程*/ return IRQ_RETVAL(IRQ_HANDLED); }
static irqreturn_t dev_isr(int irq, void *data) { struct mm_core *core_dev = (struct mm_core *)data; MM_CORE_HW_IFC *hw_ifc = &core_dev->mm_device; int ret = 0; mm_isr_type_e retval = hw_ifc->mm_process_irq(hw_ifc->mm_device_id); switch (retval) { case MM_ISR_ERROR: pr_err("mm_isr %d", retval); case MM_ISR_SUCCESS: SCHEDULER_WORK(core_dev, &core_dev->job_scheduler); case MM_ISR_PROCESSED: ret = 1; break; default: ret = 0; break; } return IRQ_RETVAL(ret); }
static irqreturn_t snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *regs) { struct snd_gusmax *maxcard = (struct snd_gusmax *) dev_id; int loop, max = 5; int handled = 0; do { loop = 0; if (inb(maxcard->gus_status_reg)) { handled = 1; snd_gus_interrupt(irq, maxcard->gus, regs); loop++; } if (inb(maxcard->pcm_status_reg) & 0x01) { /* IRQ bit is set? */ handled = 1; snd_cs4231_interrupt(irq, maxcard->cs4231, regs); loop++; } } while (loop && --max > 0); return IRQ_RETVAL(handled); }