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);
}
