Updates all sound drivers to the new IRQ API.
The patch also fixes
- a return-with-lock-held
- a bunch of warnings and 64-bit bugs (CPU flags must be held in an
unsigned long)
- jiffies must use unsigned longs
- two functions returning uninitialised values
*/
#include "pcm.h"
+#include <linux/interrupt.h>
/* IO ports */
int snd_ad1848_pcm(ad1848_t * chip, int device, snd_pcm_t **rpcm);
const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction);
int snd_ad1848_mixer(ad1848_t * chip);
-void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
/* exported mixer stuffs */
enum { AD1848_MIX_SINGLE, AD1848_MIX_DOUBLE, AD1848_MIX_CAPTURE };
void snd_cs4231_mce_up(cs4231_t *chip);
void snd_cs4231_mce_down(cs4231_t *chip);
-void snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs);
const char *snd_cs4231_chip_id(cs4231_t *chip);
#include <sound/hwdep.h>
#include <sound/ac97_codec.h>
#include <sound/util_mem.h>
+#include <linux/interrupt.h>
#include <asm/io.h>
#ifndef PCI_VENDOR_ID_CREATIVE
int snd_emu10k1_mixer(emu10k1_t * emu);
int snd_emu10k1_fx8010_new(emu10k1_t *emu, int device, snd_hwdep_t ** rhwdep);
-void snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs);
/* initialization */
void snd_emu10k1_voice_init(emu10k1_t * emu, int voice);
#include "control.h"
#include "pcm.h"
+#include <linux/interrupt.h>
#define ES1688_HW_AUTO 0x0000
#define ES1688_HW_688 0x0001
void snd_es1688_mixer_write(es1688_t *chip, unsigned char reg, unsigned char data);
unsigned char snd_es1688_mixer_read(es1688_t *chip, unsigned char reg);
-void snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs);
int snd_es1688_create(snd_card_t * card,
unsigned long port,
};
#if 0
-extern void snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice);
+extern irqreturn_t snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice);
#endif
extern void snd_gf1_lfo_init(snd_gus_card_t * gus);
extern void snd_gf1_lfo_done(snd_gus_card_t * gus);
/* gus_irq.c */
-void snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs);
#ifdef CONFIG_SND_DEBUG
void snd_gus_irq_profile_init(snd_gus_card_t *gus);
#endif
#ifdef SNDRV_LEGACY_FIND_FREE_IRQ
#include <linux/interrupt.h>
-static void snd_legacy_empty_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_legacy_empty_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
{
+ return IRQ_HANDLED;
}
static int snd_legacy_find_free_irq(int *irq_table)
*/
#include "rawmidi.h"
+#include <linux/interrupt.h>
#define MPU401_HW_MPU401 1 /* native MPU401 */
#define MPU401_HW_SB 2 /* SoundBlaster MPU-401 UART */
#include "pcm.h"
#include "rawmidi.h"
+#include <linux/interrupt.h>
#include <asm/io.h>
enum sb_hw_type {
snd_rawmidi_t *rmidi;
snd_rawmidi_substream_t *midi_substream_input;
snd_rawmidi_substream_t *midi_substream_output;
- void (*rmidi_callback)(int irq, void *dev_id, struct pt_regs *regs);
+ irqreturn_t (*rmidi_callback)(int irq, void *dev_id, struct pt_regs *regs);
spinlock_t reg_lock;
spinlock_t open_lock;
int snd_sbdsp_create(snd_card_t *card,
unsigned long port,
int irq,
- void (*irq_handler)(int, void *, struct pt_regs *),
+ irqreturn_t (*irq_handler)(int, void *, struct pt_regs *),
int dma8, int dma16,
unsigned short hardware,
sb_t **r_chip);
const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction);
int snd_sb16dsp_configure(sb_t *chip);
/* sb16.c */
-void snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs);
int snd_sb16_playback_open(snd_pcm_substream_t *substream);
int snd_sb16_capture_open(snd_pcm_substream_t *substream);
int snd_sb16_playback_close(snd_pcm_substream_t *substream);
} while (sbyt & SIGS_BYTE);
}
-static void snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
{
mtpav_t *mcard = snd_magic_cast(mtpav_t, dev_id, return);
spin_lock(&mcard->spinlock);
snd_mtpav_read_bytes(mcard);
spin_unlock(&mcard->spinlock);
+ return IRQ_HANDLED;
}
/*
* Note that some devices need OUT2 to be set before they will generate
* interrupts at all. (Possibly tied to an internal pull-up on CTS?)
*/
-static void snd_uart16550_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_uart16550_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
snd_uart16550_t *uart;
spin_lock(&uart->open_lock);
if (uart->filemode == SERIAL_MODE_NOT_OPENED) {
spin_unlock(&uart->open_lock);
- return;
+ return IRQ_NONE;
}
inb(uart->base + UART_IIR); /* indicate to the UART that the interrupt has been serviced */
snd_uart16550_io_loop(uart);
spin_unlock(&uart->open_lock);
+ return IRQ_HANDLED;
}
/* When the polling mode, this function calls snd_uart16550_io_loop. */
}
-static void snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
ad1816a_t *chip = snd_magic_cast(ad1816a_t, dev_id, return);
unsigned char status;
spin_lock(&chip->lock);
snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
spin_unlock(&chip->lock);
+ return IRQ_HANDLED;
}
return 0;
}
-void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
ad1848_t *chip = snd_magic_cast(ad1848_t, dev_id, return);
(chip->mode & AD1848_MODE_RUNNING))
snd_pcm_period_elapsed(chip->capture_substream);
outb(0, AD1848P(chip, STATUS)); /* clear global interrupt bit */
+ return IRQ_HANDLED;
}
static snd_pcm_uframes_t snd_ad1848_playback_pointer(snd_pcm_substream_t * substream)
chip->capture_substream->runtime->overrange++;
}
-void snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
cs4231_t *chip = snd_magic_cast(cs4231_t, dev_id, return);
unsigned char status;
spin_lock(&chip->reg_lock);
snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0);
spin_unlock(&chip->reg_lock);
+ return IRQ_HANDLED;
}
#ifdef LEGACY_SUPPORT
return snd_es1688_trigger(chip, cmd, 0x0f);
}
-void snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
es1688_t *chip = snd_magic_cast(es1688_t, dev_id, return);
snd_pcm_period_elapsed(chip->capture_substream);
inb(ES1688P(chip, DATA_AVAIL)); /* ack interrupt */
+ return IRQ_HANDLED;
}
static snd_pcm_uframes_t snd_es1688_playback_pointer(snd_pcm_substream_t * substream)
return snd_es18xx_playback2_trigger(chip, substream, cmd);
}
-static void snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
es18xx_t *chip = snd_magic_cast(es18xx_t, dev_id, return);
unsigned char status;
-
if (chip->caps & ES18XX_CONTROL) {
/* Read Interrupt status */
status = inb(chip->ctrl_port + 6);
/* ack interrupt */
snd_es18xx_mixer_write(chip, 0x66, 0x00);
}
-
+ return IRQ_HANDLED;
}
static snd_pcm_uframes_t snd_es18xx_playback_pointer(snd_pcm_substream_t * substream)
#define STAT_ADD(x) while (0) { ; }
#endif
-void snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
snd_gus_card_t * gus = snd_magic_cast(snd_gus_card_t, dev_id, return);
unsigned char status;
int loop = 100;
-
- __again:
+ int handled = 0;
+
+__again:
status = inb(gus->gf1.reg_irqstat);
if (status == 0)
- return;
+ return IRQ_RETVAL(handled);
+ handled = 1;
// snd_printk("IRQ: status = 0x%x\n", status);
if (status & 0x02) {
STAT_ADD(gus->gf1.interrupt_stat_midi_in);
}
if (--loop > 0)
goto __again;
+ return IRQ_NONE;
}
#ifdef CONFIG_SND_DEBUG
return 0;
}
-static void snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+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);
}
static void __init snd_gusmax_init(int dev, snd_card_t * card, snd_gus_card_t * gus)
return -ENODEV;
}
-static void snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct snd_interwave *iwcard = (struct snd_interwave *) dev_id;
int loop, max = 5;
+ int handled = 0;
do {
loop = 0;
if (inb(iwcard->gus_status_reg)) {
+ handled = 1;
snd_gus_interrupt(irq, iwcard->gus, regs);
loop++;
}
if (inb(iwcard->pcm_status_reg) & 0x01) { /* IRQ bit is set? */
+ handled = 1;
snd_cs4231_interrupt(irq, iwcard->cs4231, regs);
loop++;
}
} while (loop && --max > 0);
+ return IRQ_RETVAL(handled);
}
static void __devinit snd_interwave_reset(snd_gus_card_t * gus)
return 0;
}
-static void snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned short status;
opl3sa2_t *chip = snd_magic_cast(opl3sa2_t, dev_id, return);
+ int handled = 0;
if (chip == NULL || chip->card == NULL)
- return;
+ return IRQ_NONE;
status = snd_opl3sa2_read(chip, OPL3SA2_IRQ_STATUS);
- if (status & 0x20)
+ if (status & 0x20) {
+ handled = 1;
snd_opl3_interrupt(chip->synth);
+ }
- if ((status & 0x10) && chip->rmidi != NULL)
+ if ((status & 0x10) && chip->rmidi != NULL) {
+ handled = 1;
snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
+ }
- if (status & 0x07) /* TI,CI,PI */
+ if (status & 0x07) { /* TI,CI,PI */
+ handled = 1;
snd_cs4231_interrupt(irq, chip->cs4231, regs);
+ }
if (status & 0x40) { /* hardware volume change */
+ handled = 1;
/* reading from Master Lch register at 0x07 clears this bit */
snd_opl3sa2_read(chip, OPL3SA2_MASTER_RIGHT);
snd_opl3sa2_read(chip, OPL3SA2_MASTER_LEFT);
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
}
}
+ return IRQ_RETVAL(handled);
}
#define OPL3SA2_SINGLE(xname, xindex, reg, shift, mask, invert) \
spin_unlock_irqrestore(&chip->lock, flags);
}
-void snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
opti93x_t *codec = snd_magic_cast(opti93x_t, dev_id, return);
unsigned char status;
snd_pcm_period_elapsed(codec->capture_substream);
}
outb(0x00, OPTi93X_PORT(codec, STATUS));
+ return IRQ_HANDLED;
}
return result;
}
-void snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
sb_t *chip = snd_magic_cast(sb_t, dev_id, return);
unsigned char status;
snd_sb_ack_16bit(chip);
spin_unlock(&chip->reg_lock);
}
+ return IRQ_HANDLED;
}
/*
static snd_card_t *snd_sb8_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
-static void snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
sb_t *chip = snd_magic_cast(sb_t, dev_id, return);
} else {
snd_sb8dsp_midi_interrupt(chip);
}
+ return IRQ_HANDLED;
}
static void snd_sb8_free(snd_card_t *card)
int snd_sbdsp_create(snd_card_t *card,
unsigned long port,
int irq,
- void (*irq_handler)(int, void *, struct pt_regs *),
+ irqreturn_t (*irq_handler)(int, void *, struct pt_regs *),
int dma8,
int dma16,
unsigned short hardware,
return 0;
}
-static void snd_sgalaxy_dummy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_sgalaxy_dummy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
+ return IRQ_NONE;
}
static int __init snd_sgalaxy_setup_wss(unsigned long port, int irq, int dma)
#endif /* CONFIG_PNP */
-static void snd_wavefront_ics2115_interrupt(int irq,
+static irqreturn_t snd_wavefront_ics2115_interrupt(int irq,
void *dev_id,
struct pt_regs *regs)
{
acard = (snd_wavefront_card_t *) dev_id;
if (acard == NULL)
- return;
+ return IRQ_NONE;
if (acard->wavefront.interrupts_are_midi) {
snd_wavefront_midi_interrupt (acard);
} else {
snd_wavefront_internal_interrupt (acard);
}
+ return IRQ_HANDLED;
}
snd_hwdep_t * __devinit
/* Interrupt handler */
-static void ad1816_interrupt (int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t ad1816_interrupt (int irq, void *dev_id, struct pt_regs *dummy)
{
unsigned char status;
ad1816_info *devc;
if (irq < 0 || irq > 15) {
printk(KERN_WARNING "ad1816: Got bogus interrupt %d\n", irq);
- return;
+ return IRQ_NONE;
}
dev = irq2dev[irq];
if (dev < 0 || dev >= num_audiodevs) {
printk(KERN_WARNING "ad1816: IRQ2AD1816-mapping failed for "
"irq %d device %d\n", irq,dev);
- return;
+ return IRQ_NONE;
}
devc = (ad1816_info *) audio_devs[dev]->devc;
DMAbuf_outputintr (dev, 1);
spin_unlock(&devc->lock);
+ return IRQ_HANDLED;
}
/* ------------------------------------------------------------------- */
printk(KERN_ERR "ad1848: Can't find device to be unloaded. Base=%x\n", io_base);
}
-void adintr(int irq, void *dev_id, struct pt_regs *dummy)
+irqreturn_t adintr(int irq, void *dev_id, struct pt_regs *dummy)
{
unsigned char status;
ad1848_info *devc;
{
goto interrupt_again;
}
+ return IRQ_HANDLED;
}
/*
+#include <linux/interrupt.h>
+
#define AD_F_CS4231 0x0001 /* Returned if a CS4232 (or compatible) detected */
#define AD_F_CS4248 0x0001 /* Returned if a CS4248 (or compatible) detected */
int ad1848_detect (int io_base, int *flags, int *osp);
int ad1848_control(int cmd, int arg);
-void adintr(int irq, void *dev_id, struct pt_regs * dummy);
+irqreturn_t adintr(int irq, void *dev_id, struct pt_regs * dummy);
void attach_ms_sound(struct address_info * hw_config, struct module * owner);
int probe_ms_sound(struct address_info *hw_config);
"RISCI", "FBUS", "FTRGT", "FDSR", "PPERR",
"RIPERR", "PABORT", "OCERR", "SCERR" };
-static void btaudio_irq(int irq, void *dev_id, struct pt_regs * regs)
+static irqreturn_t btaudio_irq(int irq, void *dev_id, struct pt_regs * regs)
{
int count = 0;
u32 stat,astat;
struct btaudio *bta = dev_id;
+ int handled = 0;
for (;;) {
count++;
stat = btread(REG_INT_STAT);
astat = stat & btread(REG_INT_MASK);
if (!astat)
- return;
+ return IRQ_RETVAL(handled);
+ handled = 1;
btwrite(astat,REG_INT_STAT);
if (irq_debug) {
btwrite(0, REG_INT_MASK);
}
}
- return;
+ return IRQ_NONE;
}
/* -------------------------------------------------------------- */
}
#endif
-static void cm_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t cm_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct cm_state *s = (struct cm_state *)dev_id;
unsigned int intsrc, intstat;
/* fastpath out, to ease interrupt sharing */
intsrc = inl(s->iobase + CODEC_CMI_INT_STATUS);
if (!(intsrc & 0x80000000))
- return;
+ return IRQ_NONE;
spin_lock(&s->lock);
intstat = inb(s->iobase + CODEC_CMI_INT_HLDCLR + 2);
/* acknowledge interrupt */
cm_handle_midi(s);
#endif
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
#ifdef CONFIG_SOUND_CMPCI_MIDI
-static void cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct cs4281_state *s = (struct cs4281_state *) dev_id;
unsigned int temp1;
writel(HICR_IEV | HICR_CHGM, s->pBA0 + BA0_HICR);
CS_DBGOUT(CS_INTERRUPT, 9, printk(KERN_INFO
"cs4281: cs4281_interrupt(): returning not cs4281 interrupt.\n"));
- return;
+ return IRQ_NONE;
}
if (temp1 & HISR_DMA0) // If play interrupt,
cs4281_update_ptr(s,CS_TRUE);
cs4281_handle_midi(s);
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
// **************************************************************************
wake_up(&card->midi.owait);
}
-static void cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct cs_card *card = (struct cs_card *)dev_id;
/* Single channel card */
{
cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
spin_unlock(&card->lock);
- return;
+ return IRQ_HANDLED; /* Might be IRQ_NONE.. */
}
/*
cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
spin_unlock(&card->lock);
CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
+ return IRQ_HANDLED;
}
static int FalconSetVolume(int volume);
static void AtaPlayNextFrame(int index);
static void AtaPlay(void);
-static void AtaInterrupt(int irq, void *dummy, struct pt_regs *fp);
+static irqreturn_t AtaInterrupt(int irq, void *dummy, struct pt_regs *fp);
/*** Mid level stuff *********************************************************/
}
-static void AtaInterrupt(int irq, void *dummy, struct pt_regs *fp)
+static irqreturn_t AtaInterrupt(int irq, void *dummy, struct pt_regs *fp)
{
#if 0
/* ++TeSche: if you should want to test this... */
if (++cnt == 10) {
/* simulate losing an interrupt */
cnt = 0;
- return;
+ return IRQ_HANDLED;
}
#endif
spin_lock(&dmasound.lock);
* (almost) like on the TT.
*/
write_sq_ignore_int = 0;
- return;
+ return IRQ_HANDLED;
}
if (!write_sq.active) {
* the sq variables, so better don't do anything here.
*/
WAKE_UP(write_sq.sync_queue);
- return;
+ return IRQ_HANDLED;
}
/* Probably ;) one frame is finished. Well, in fact it may be that a
is nothing to play any more. Wake up a process
waiting for audio output to drain. */
spin_unlock(&dmasound.lock);
+ return IRQ_HANDLED;
}
static int PMacSetVolume(int volume);
static void PMacPlay(void);
static void PMacRecord(void);
-static void pmac_awacs_tx_intr(int irq, void *devid, struct pt_regs *regs);
-static void pmac_awacs_rx_intr(int irq, void *devid, struct pt_regs *regs);
-static void pmac_awacs_intr(int irq, void *devid, struct pt_regs *regs);
+static irqreturn_t pmac_awacs_tx_intr(int irq, void *devid, struct pt_regs *regs);
+static irqreturn_t pmac_awacs_rx_intr(int irq, void *devid, struct pt_regs *regs);
+static irqreturn_t pmac_awacs_intr(int irq, void *devid, struct pt_regs *regs);
static void awacs_write(int val);
static int awacs_get_volume(int reg, int lshift);
static int awacs_volume_setter(int volume, int n, int mute, int lshift);
return ((pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio_addr, 0) & 0x02) !=0);
}
-static void
+static irqreturn_t
headphone_intr(int irq, void *devid, struct pt_regs *regs)
{
+ int handled = 0;
spin_lock(&dmasound.lock);
if (read_audio_gpio(gpio_headphone_detect) == gpio_headphone_detect_pol) {
+ handled = 1;
printk(KERN_INFO "Audio jack plugged, muting speakers.\n");
write_audio_gpio(gpio_amp_mute, gpio_amp_mute_pol);
write_audio_gpio(gpio_headphone_mute, !gpio_headphone_mute_pol);
} else {
+ handled = 1;
printk(KERN_INFO "Audio jack unplugged, enabling speakers.\n");
write_audio_gpio(gpio_amp_mute, !gpio_amp_mute_pol);
write_audio_gpio(gpio_headphone_mute, gpio_headphone_mute_pol);
}
spin_unlock(&dmasound.lock);
+ return IRQ_RETVAL(handled);
}
'next_cmd' field will already point back to the original loop of blocks.
*/
-static void
+static irqreturn_t
pmac_awacs_tx_intr(int irq, void *devid, struct pt_regs *regs)
{
int i = write_sq.front;
if (!write_sq.active && (write_sq.syncing & 1))
WAKE_UP(write_sq.sync_queue); /* any time we're empty */
spin_unlock(&dmasound.lock);
+ return IRQ_HANDLED;
}
-static void
+static irqreturn_t
pmac_awacs_rx_intr(int irq, void *devid, struct pt_regs *regs)
{
int stat ;
* just blow it off.
*/
if (in_le32(&awacs_rxdma->cmdptr) == 0)
- return;
+ return IRQ_HANDLED;
/* We also want to blow 'em off when shutting down.
*/
if (read_sq.active == 0)
- return;
+ return IRQ_HANDLED;
spin_lock(&dmasound.lock);
/* Check multiple buffers in case we were held off from
out_le32(&awacs_rxdma->control,
((RUN|WAKE) << 16) + (RUN|WAKE));
spin_unlock(&dmasound.lock);
- return; /* try this block again */
+ return IRQ_HANDLED; /* try this block again */
}
/* Clear status and move on to next buffer.
*/
WAKE_UP(read_sq.action_queue);
spin_unlock(&dmasound.lock);
+ return IRQ_HANDLED;
}
-static void
+static irqreturn_t
pmac_awacs_intr(int irq, void *devid, struct pt_regs *regs)
{
int ctrl;
/* Writing 1s to the CNTLERR and PORTCHG bits clears them... */
out_le32(&awacs->control, ctrl);
spin_unlock(&dmasound.lock);
+ return IRQ_HANDLED;
}
static void
static int AmiSetTreble(int treble);
static void AmiPlayNextFrame(int index);
static void AmiPlay(void);
-static void AmiInterrupt(int irq, void *dummy, struct pt_regs *fp);
+static irqreturn_t AmiInterrupt(int irq, void *dummy, struct pt_regs *fp);
#ifdef CONFIG_HEARTBEAT
}
-static void AmiInterrupt(int irq, void *dummy, struct pt_regs *fp)
+static irqreturn_t AmiInterrupt(int irq, void *dummy, struct pt_regs *fp)
{
int minframes = 1;
* the sq variables, so better don't do anything here.
*/
WAKE_UP(write_sq.sync_queue);
- return;
+ return IRQ_HANDLED;
}
if (write_sq.active & AMI_PLAY_PLAYING) {
/* Nothing to play anymore.
Wake up a process waiting for audio output to drain. */
WAKE_UP(write_sq.sync_queue);
+ return IRQ_HANDLED;
}
/*** Mid level stuff *********************************************************/
static int Q40SetVolume(int volume);
static void Q40PlayNextFrame(int index);
static void Q40Play(void);
-static void Q40StereoInterrupt(int irq, void *dummy, struct pt_regs *fp);
-static void Q40MonoInterrupt(int irq, void *dummy, struct pt_regs *fp);
+static irqreturn_t Q40StereoInterrupt(int irq, void *dummy, struct pt_regs *fp);
+static irqreturn_t Q40MonoInterrupt(int irq, void *dummy, struct pt_regs *fp);
static void Q40Interrupt(void);
spin_unlock_irqrestore_flags(&dmasound.lock, flags);
}
-static void Q40StereoInterrupt(int irq, void *dummy, struct pt_regs *fp)
+static irqreturn_t Q40StereoInterrupt(int irq, void *dummy, struct pt_regs *fp)
{
spin_lock(&dmasound.lock);
if (q40_sc>1){
master_outb(1,SAMPLE_CLEAR_REG);
}else Q40Interrupt();
spin_unlock(&dmasound.lock);
+ return IRQ_HANDLED;
}
-static void Q40MonoInterrupt(int irq, void *dummy, struct pt_regs *fp)
+static irqreturn_t Q40MonoInterrupt(int irq, void *dummy, struct pt_regs *fp)
{
spin_lock(&dmasound.lock);
if (q40_sc>0){
master_outb(1,SAMPLE_CLEAR_REG);
}else Q40Interrupt();
spin_unlock(&dmasound.lock);
+ return IRQ_HANDLED;
}
static void Q40Interrupt(void)
{
while (len) {
for (voice_num = 0; voice_num < woinst->num_voices; voice_num++) {
if (__copy_from_user((u8 *)(voice[voice_num].mem.addr[pg]) + pgoff, src, woinst->format.bytespervoicesample))
- return -EFAULT;
+ return;
src += woinst->format.bytespervoicesample;
}
/* Interrupt handler */
-void emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct emu10k1_card *card = (struct emu10k1_card *) dev_id;
u32 irqstatus, irqstatus_tmp;
+ int handled = 0;
DPD(4, "emu10k1_interrupt called, irq = %u\n", irq);
}
/* acknowledge interrupt */
- outl(irqstatus_tmp, card->iobase + IPR);
+ outl(irqstatus_tmp, card->iobase + IPR);
+ handled = 1;
}
+ return IRQ_RETVAL(handled);
}
static struct midi_operations emu10k1_midi_operations;
#endif
-extern void emu10k1_interrupt(int, void *, struct pt_regs *s);
+extern irqreturn_t emu10k1_interrupt(int, void *, struct pt_regs *s);
static int __devinit emu10k1_audio_init(struct emu10k1_card *card)
{
outb((s->midi.ocnt > 0) ? UCTRL_RXINTEN | UCTRL_ENA_TXINT : UCTRL_RXINTEN, s->io+ES1370_REG_UART_CONTROL);
}
-static void es1370_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t es1370_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct es1370_state *s = (struct es1370_state *)dev_id;
unsigned int intsrc, sctl;
/* fastpath out, to ease interrupt sharing */
intsrc = inl(s->io+ES1370_REG_STATUS);
if (!(intsrc & 0x80000000))
- return;
+ return IRQ_NONE;
spin_lock(&s->lock);
/* clear audio interrupts first */
sctl = s->sctrl;
es1370_update_ptr(s);
es1370_handle_midi(s);
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
/* --------------------------------------------------------------------- */
outb((s->midi.ocnt > 0) ? UCTRL_RXINTEN | UCTRL_ENA_TXINT : UCTRL_RXINTEN, s->io+ES1371_REG_UART_CONTROL);
}
-static void es1371_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t es1371_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct es1371_state *s = (struct es1371_state *)dev_id;
unsigned int intsrc, sctl;
/* fastpath out, to ease interrupt sharing */
intsrc = inl(s->io+ES1371_REG_STATUS);
if (!(intsrc & 0x80000000))
- return;
+ return IRQ_NONE;
spin_lock(&s->lock);
/* clear audio interrupts first */
sctl = s->sctrl;
es1371_update_ptr(s);
es1371_handle_midi(s);
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
/* --------------------------------------------------------------------- */
wake_up(&s->midi.owait);
}
-static void solo1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t solo1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct solo1_state *s = (struct solo1_state *)dev_id;
unsigned int intsrc;
/* fastpath out, to ease interrupt sharing */
intsrc = inb(s->iobase+7); /* get interrupt source(s) */
if (!intsrc)
- return;
+ return IRQ_NONE;
(void)inb(s->sbbase+0xe); /* clear interrupt */
spin_lock(&s->lock);
/* clear audio interrupts first */
solo1_update_ptr(s);
solo1_handle_midi(s);
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
static void solo1_midi_timer(unsigned long data)
/* From gus_card.c */
int gus_set_midi_irq(int num);
-void gusintr(int irq, void *dev_id, struct pt_regs * dummy);
+irqreturn_t gusintr(int irq, void *dev_id, struct pt_regs * dummy);
/* From gus_wave.c */
int gus_wave_detect(int baseaddr);
#include "gus.h"
#include "gus_hw.h"
-void gusintr(int irq, void *dev_id, struct pt_regs *dummy);
+irqreturn_t gusintr(int irq, void *dev_id, struct pt_regs *dummy);
int gus_base = 0, gus_irq = 0, gus_dma = 0;
int gus_no_wave_dma = 0;
sound_free_dma(hw_config->dma2);
}
-void gusintr(int irq, void *dev_id, struct pt_regs *dummy)
+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) {
while (1)
{
if (!(src = inb(u_IrqStatus)))
- return;
-
+ break;
+ handled = 1;
if (src & DMA_TC_IRQ)
{
guswave_dma_irq();
if (src & (WAVETABLE_IRQ | ENVELOPE_IRQ))
gus_voice_irq();
}
+ return IRQ_RETVAL(handled);
}
/*
{
unsigned vol, prev_vol, phase;
unsigned char rate;
- long int flags;
+ unsigned long flags;
if (voices[voice].mode & WAVE_SUSTAIN_ON && voices[voice].env_phase == 2)
{
static void gus_voice_fade(int voice)
{
int instr_no = sample_map[voice], is16bits;
- long int flags;
+ unsigned long flags;
spin_lock_irqsave(&gus_lock,flags);
gus_select_voice(voice);
static int guswave_start_note(int dev, int voice, int note_num, int volume)
{
- long int flags;
+ unsigned long flags;
int mode;
int ret_val = 0;
#endif
}
-static void i810_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t i810_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct i810_card *card = (struct i810_card *)dev_id;
u32 status;
if(!(status & INT_MASK))
{
spin_unlock(&card->lock);
- return; /* not for us */
+ return IRQ_NONE; /* not for us */
}
if(status & (INT_PO|INT_PI|INT_MC))
/* clear 'em */
outl(status & INT_MASK, card->iobase + GLOB_STA);
spin_unlock(&card->lock);
+ return IRQ_HANDLED;
}
/* in this loop, dmabuf.count signifies the amount of data that is
/* hold spinlock for the following! */
-static void it8172_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t it8172_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct it8172_state *s = (struct it8172_state *)dev_id;
struct dmabuf* dac = &s->dma_dac;
isc = inb(s->io+IT_AC_ISC);
/* fastpath out, to ease interrupt sharing */
- if (!(isc & (ISC_VCI | ISC_CCI | ISC_PCI)))
- return;
+ if (!(isc & (ISC_VCI | ISC_CCI | ISC_PCI))) {
+ spin_unlock(&s->lock);
+ return IRQ_NONE;
+ }
/* clear audio interrupts first */
outb(isc | ISC_VCI | ISC_CCI | ISC_PCI, s->io+IT_AC_ISC);
}
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
/* --------------------------------------------------------------------- */
* Meet Bob, the timer...
*/
-static void ess_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t ess_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static void stop_bob(struct ess_state *s)
{
}
}
-static void
+static irqreturn_t
ess_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct ess_state *s;
int i;
u32 event;
- if ( ! (event = inb(c->iobase+0x1A)) ) return;
+ if ( ! (event = inb(c->iobase+0x1A)) )
+ return IRQ_NONE;
outw(inw(c->iobase+4)&1, c->iobase+4);
ess_update_ptr(s);
spin_unlock(&s->lock);
}
+ return IRQ_HANDLED;
}
}
}
-static void m3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t m3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct m3_card *c = (struct m3_card *)dev_id;
struct m3_state *s = &c->channels[0];
status = inb(c->iobase+0x1A);
- if(status == 0xff) return;
+ if(status == 0xff)
+ return IRQ_NONE;
/* presumably acking the ints? */
outw(status, c->iobase+0x1A);
if(c->in_suspend)
- return;
+ return IRQ_HANDLED;
/*
* ack an assp int if its running
/* XXX is this needed? */
if(status & 0x40)
outb(0x40, c->iobase+0x1A);
+ return IRQ_HANDLED;
}
return 0;
}
-static void mauiintr(int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t mauiintr(int irq, void *dev_id, struct pt_regs *dummy)
{
irq_ok = 1;
+ return IRQ_HANDLED;
}
static int __init download_code(void)
return input_avail(devc);
}
-void mpuintr(int irq, void *dev_id, struct pt_regs *dummy)
+irqreturn_t mpuintr(int irq, void *dev_id, struct pt_regs *dummy)
{
struct mpu_config *devc;
int dev = (int) dev_id;
+ int handled = 0;
devc = &dev_conf[dev];
if (input_avail(devc))
{
+ handled = 1;
if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
mpu401_input_loop(devc);
else
read_data(devc);
}
}
+ return IRQ_RETVAL(handled);
}
static int mpu401_open(int dev, int mode,
{
if (!try_module_get(coprocessor->owner)) {
mpu401_close(dev);
- return err;
+ return -ENODEV;
}
if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
coprocessor = midi_devs[midi_dev]->coproc;
if (coprocessor) {
if (!try_module_get(coprocessor->owner))
- return err;
+ return -ENODEV;
if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
{
int probe_uart401 (struct address_info *hw_config, struct module *owner);
void unload_uart401 (struct address_info *hw_config);
-void uart401intr (int irq, void *dev_id, struct pt_regs * dummy);
+irqreturn_t uart401intr (int irq, void *dev_id, struct pt_regs * dummy);
/* From mpu401.c */
int probe_mpu401(struct address_info *hw_config);
void unload_mpu401(struct address_info *hw_info);
int intchk_mpu401(void *dev_id);
-void mpuintr(int irq, void *dev_id, struct pt_regs * dummy);
+irqreturn_t mpuintr(int irq, void *dev_id, struct pt_regs * dummy);
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/init.h>
+#include <linux/interrupt.h>
#include <linux/smp_lock.h>
#include <asm/irq.h>
#include <asm/io.h>
}
}
-static void intr(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *regs)
{
/* Send ack to DSP */
inb(dev.io + HP_RXL);
else
isa_writew(wTmp, dev.DSPQ + JQS_wHead);
}
+ return IRQ_HANDLED;
}
static struct file_operations dev_fileops = {
wake_up_interruptible(&dac->wait);
}
-static void vrc5477_ac97_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t vrc5477_ac97_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct vrc5477_ac97_state *s = (struct vrc5477_ac97_state *)dev_id;
u32 irqStatus;
}
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
/* --------------------------------------------------------------------- */
#define _NM256_H_
#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+
#include "ac97.h"
/* The revisions that we currently handle. */
int has_irq;
/* The card interrupt service routine. */
- void (*introutine) (int, void *, struct pt_regs *);
+ irqreturn_t (*introutine) (int, void *, struct pt_regs *);
/* Current audio config, cached. */
struct sinfo {
static int nm256_grabInterrupt (struct nm256_info *card);
static int nm256_releaseInterrupt (struct nm256_info *card);
-static void nm256_interrupt (int irq, void *dev_id, struct pt_regs *dummy);
-static void nm256_interrupt_zx (int irq, void *dev_id, struct pt_regs *dummy);
+static irqreturn_t nm256_interrupt (int irq, void *dev_id, struct pt_regs *dummy);
+static irqreturn_t nm256_interrupt_zx (int irq, void *dev_id, struct pt_regs *dummy);
static int handle_pm_event (struct pm_dev *dev, pm_request_t rqst, void *data);
/* These belong in linux/pci.h. */
* I suppose...yucky bleah.)
*/
-static void
+static irqreturn_t
nm256_interrupt (int irq, void *dev_id, struct pt_regs *dummy)
{
struct nm256_info *card = (struct nm256_info *)dev_id;
u16 status;
static int badintrcount = 0;
+ int handled = 0;
if ((card == NULL) || (card->magsig != NM_MAGIC_SIG)) {
printk (KERN_ERR "NM256: Bad card pointer\n");
- return;
+ return IRQ_NONE;
}
status = nm256_readPort16 (card, 2, NM_INT_REG);
* inserted a PCMCIA card and someone's spamming us with IRQ 9s.
*/
+ handled = 1;
if (card->playing)
stopPlay (card);
if (card->recording)
stopRecord (card);
badintrcount = 0;
}
- return;
+ return IRQ_RETVAL(handled);
}
badintrcount = 0;
/* Rather boring; check for individual interrupts and process them. */
if (status & NM_PLAYBACK_INT) {
+ handled = 1;
status &= ~NM_PLAYBACK_INT;
NM_ACK_INT (card, NM_PLAYBACK_INT);
}
if (status & NM_RECORD_INT) {
+ handled = 1;
status &= ~NM_RECORD_INT;
NM_ACK_INT (card, NM_RECORD_INT);
if (status & NM_MISC_INT_1) {
u8 cbyte;
+ handled = 1;
status &= ~NM_MISC_INT_1;
printk (KERN_ERR "NM256: Got misc interrupt #1\n");
NM_ACK_INT (card, NM_MISC_INT_1);
if (status & NM_MISC_INT_2) {
u8 cbyte;
+ handled = 1;
status &= ~NM_MISC_INT_2;
printk (KERN_ERR "NM256: Got misc interrupt #2\n");
NM_ACK_INT (card, NM_MISC_INT_2);
/* Unknown interrupt. */
if (status) {
+ handled = 1;
printk (KERN_ERR "NM256: Fire in the hole! Unknown status 0x%x\n",
status);
/* Pray. */
NM_ACK_INT (card, status);
}
+ return IRQ_RETVAL(handled);
}
/*
* routine.
*/
-static void
+static irqreturn_t
nm256_interrupt_zx (int irq, void *dev_id, struct pt_regs *dummy)
{
struct nm256_info *card = (struct nm256_info *)dev_id;
u32 status;
static int badintrcount = 0;
+ int handled = 0;
if ((card == NULL) || (card->magsig != NM_MAGIC_SIG)) {
printk (KERN_ERR "NM256: Bad card pointer\n");
- return;
+ return IRQ_NONE;
}
status = nm256_readPort32 (card, 2, NM_INT_REG);
* IRQ 9s.
*/
+ handled = 1;
if (card->playing)
stopPlay (card);
if (card->recording)
stopRecord (card);
badintrcount = 0;
}
- return;
+ return IRQ_RETVAL(handled);
}
badintrcount = 0;
/* Rather boring; check for individual interrupts and process them. */
if (status & NM2_PLAYBACK_INT) {
+ handled = 1;
status &= ~NM2_PLAYBACK_INT;
NM2_ACK_INT (card, NM2_PLAYBACK_INT);
}
if (status & NM2_RECORD_INT) {
+ handled = 1;
status &= ~NM2_RECORD_INT;
NM2_ACK_INT (card, NM2_RECORD_INT);
if (status & NM2_MISC_INT_1) {
u8 cbyte;
+ handled = 1;
status &= ~NM2_MISC_INT_1;
printk (KERN_ERR "NM256: Got misc interrupt #1\n");
NM2_ACK_INT (card, NM2_MISC_INT_1);
if (status & NM2_MISC_INT_2) {
u8 cbyte;
+ handled = 1;
status &= ~NM2_MISC_INT_2;
printk (KERN_ERR "NM256: Got misc interrupt #2\n");
NM2_ACK_INT (card, NM2_MISC_INT_2);
/* Unknown interrupt. */
if (status) {
+ handled = 1;
printk (KERN_ERR "NM256: Fire in the hole! Unknown status 0x%x\n",
status);
/* Pray. */
NM2_ACK_INT (card, status);
}
+ return IRQ_RETVAL(handled);
}
/*
/******************* Begin of the Interrupt Handler ********************/
-void pasintr(int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t pasintr(int irq, void *dev_id, struct pt_regs *dummy)
{
int status;
pas_midi_interrupt();
status &= ~0x10;
}
+ return IRQ_HANDLED;
}
int pas_set_intr(int mask)
static void pss_write(pss_confdata *devc, int data)
{
- int i, limit;
+ unsigned long i, limit;
limit = jiffies + HZ/10; /* The timeout is 0.1 seconds */
/*
static int pss_download_boot(pss_confdata * devc, unsigned char *block, int size, int flags)
{
- int i, limit, val, count;
+ int i, val, count;
+ unsigned long limit;
if (flags & CPF_FIRST)
{
inline int rme96xx_gethwptr(rme96xx_info* s,int exact)
{
- long flags;
+ unsigned long flags;
if (exact) {
unsigned int hwp;
/* the hwptr seems to be rather unreliable :(, so we don't use it */
static int rme96xx_startcard(rme96xx_info *s,int stop)
{
int i;
- long flags;
+ unsigned long flags;
COMM ("startcard");
if(s->control_register & RME96xx_IE){
}
-static void rme96xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t rme96xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
int i;
rme96xx_info *s = (rme96xx_info *)dev_id;
status = readl(s->iobase + RME96xx_status_register);
if (!(status & RME96xx_IRQ)) {
- return;
+ return IRQ_NONE;
}
spin_lock_irqsave(&s->lock,flags);
wake_up(&(db->wait));
}
spin_unlock_irqrestore(&s->lock,flags);
+ return IRQ_HANDLED;
}
sb_intr(devc);
}
-static void sbintr(int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t sbintr(int irq, void *dev_id, struct pt_regs *dummy)
{
sb_devc *devc = dev_id;
sb_intr (devc);
break;
}
+ return IRQ_HANDLED;
}
int sb_dsp_reset(sb_devc * devc)
wake_up(&s->midi.owait);
}
-static void sv_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t sv_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct sv_state *s = (struct sv_state *)dev_id;
unsigned int intsrc;
/* fastpath out, to ease interrupt sharing */
intsrc = inb(s->ioenh + SV_CODEC_STATUS);
if (!(intsrc & (SV_CSTAT_DMAA | SV_CSTAT_DMAC | SV_CSTAT_MIDI)))
- return;
+ return IRQ_NONE;
spin_lock(&s->lock);
sv_update_ptr(s);
sv_handle_midi(s);
spin_unlock(&s->lock);
+ return IRQ_HANDLED;
}
static void sv_midi_timer(unsigned long data)
}
}
-static void trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct trident_card *card = (struct trident_card *)dev_id;
u32 event;
event = inl(TRID_REG(card, T4D_MISCINT));
outl(event | (ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(card, T4D_MISCINT));
spin_unlock(&card->lock);
- return;
+ return IRQ_HANDLED;
}
/* manually clear interrupt status, bad hardware design, blame T^2 */
outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW),
TRID_REG(card, T4D_MISCINT));
spin_unlock(&card->lock);
+ return IRQ_HANDLED;
}
/* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
printk(KERN_WARNING "Too much work in interrupt on uart401 (0x%X). UART jabbering ??\n", devc->base);
}
-void uart401intr(int irq, void *dev_id, struct pt_regs *dummy)
+irqreturn_t uart401intr(int irq, void *dev_id, struct pt_regs *dummy)
{
uart401_devc *devc = dev_id;
if (devc == NULL)
{
printk(KERN_ERR "uart401: bad devc\n");
- return;
+ return IRQ_NONE;
}
if (input_avail(devc))
uart401_input_loop(devc);
+ return IRQ_HANDLED;
}
static int
}
}
-void m6850intr(int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t m6850intr(int irq, void *dev_id, struct pt_regs *dummy)
{
if (input_avail())
uart6850_input_loop();
+ return IRQ_HANDLED;
}
/*
}
-static void via_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t via_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct via_info *card = dev_id;
u32 status32;
+ int handled = 0;
/* to minimize interrupt sharing costs, we use the SGD status
* shadow register to check the status of all inputs and
if (!(status32 & VIA_INTR_MASK))
{
#ifdef CONFIG_MIDI_VIA82CXXX
- if (card->midi_devc)
+ if (card->midi_devc) {
uart401intr(irq, card->midi_devc, regs);
+ handled = 1;
+ }
#endif
- return;
+ goto out;
}
DPRINTK ("intr, status32 == 0x%08X\n", status32);
*/
spin_lock (&card->lock);
- if (status32 & VIA_INTR_OUT)
+ if (status32 & VIA_INTR_OUT) {
+ handled = 1;
via_intr_channel (&card->ch_out);
- if (status32 & VIA_INTR_IN)
+ }
+ if (status32 & VIA_INTR_IN) {
+ handled = 1;
via_intr_channel (&card->ch_in);
- if (status32 & VIA_INTR_FM)
+ }
+ if (status32 & VIA_INTR_FM) {
+ handled = 1;
via_intr_channel (&card->ch_fm);
-
+ }
spin_unlock (&card->lock);
+out:
+ return IRQ_RETVAL(handled);
}
* DMA Interrupt handler
*/
-extern void vidc_sound_dma_irq(int irqnr, void *ref, struct pt_regs *regs);
+extern irqreturn_t vidc_sound_dma_irq(int irqnr, void *ref, struct pt_regs *regs);
/*
* Filler routine pointer
* ip = corrupted
*/
+%%%%%%%%%%%%%%%%%%%
+fixme! This funtion needs to return IRQ_HANDLED
+%%%%%%%%%%%%%%%%%%%
+
ENTRY(vidc_sound_dma_irq)
stmfd sp!, {r4 - r8, lr}
ldr r8, =dma_start
pcm_output(devc, underflown, 0);
}
-static void vwsnd_audio_intr(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t vwsnd_audio_intr(int irq, void *dev_id, struct pt_regs *regs)
{
vwsnd_dev_t *devc = (vwsnd_dev_t *) dev_id;
unsigned int status;
status = li_get_clear_intr_status(&devc->lith);
vwsnd_audio_read_intr(devc, status);
vwsnd_audio_write_intr(devc, status);
+ return IRQ_HANDLED;
}
static ssize_t vwsnd_audio_do_read(struct file *file,
};
-static void
+static irqreturn_t
waveartist_intr(int irq, void *dev_id, struct pt_regs *regs)
{
wavnc_info *devc = (wavnc_info *)dev_id;
// We do not use SB mode natively...
printk(KERN_WARNING "waveartist: Unexpected SB interrupt...\n");
spin_unlock(&waveartist_lock);
+ return IRQ_HANDLED;
}
/* -------------------------------------------------------------------------
/* WaveFront: Linux modular sound kernel installation interface */
/***********************************************************************/
-void
-wavefrontintr (int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t
+wavefrontintr(int irq, void *dev_id, struct pt_regs *dummy)
{
struct wf_config *hw = dev_id;
*/
if ((wavefront_status() & (STAT_INTR_READ|STAT_INTR_WRITE)) == 0) {
- return;
+ return IRQ_NONE;
}
hw->irq_ok = 1;
hw->irq_cnt++;
wake_up_interruptible (&hw->interrupt_sleeper);
+ return IRQ_HANDLED;
}
/* STATUS REGISTER
return 1;
}
-void
-wf_mpuintr (int irq, void *dev_id, struct pt_regs *dummy)
+static irqreturn_t
+wf_mpuintr(int irq, void *dev_id, struct pt_regs *dummy)
{
struct wf_mpu_config *physical_dev = dev_id;
int n;
if (!input_avail()) { /* not for us */
- return;
+ return IRQ_NONE;
}
- if (mi->m_busy) return;
+ if (mi->m_busy)
+ return IRQ_HANDLED;
spin_lock(&lock);
mi->m_busy = 1;
mi->m_busy = 0;
spin_unlock(&lock);
+ return IRQ_HANDLED;
}
static int
return 0;
}
-void ymf_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t ymf_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
ymfpci_t *codec = dev_id;
u32 status, nvoice, mode;
/* timer handler */
ymfpci_writel(codec, YDSXGR_INTFLAG, ~0);
}
+ return IRQ_HANDLED;
}
static void ymf_pcm_free_substream(struct ymf_pcm *ypcm)
}
-static void snd_ali_card_interrupt(int irq,
+static irqreturn_t snd_ali_card_interrupt(int irq,
void *dev_id,
struct pt_regs *regs)
{
ali_t *codec = snd_magic_cast(ali_t, dev_id, return);
if (codec == NULL)
- return;
+ return IRQ_NONE;
snd_ali_interrupt(codec);
+ return IRQ_HANDLED;
}
return bytes_to_frames( substream->runtime, result );
}
-static void snd_als4000_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_als4000_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
sb_t *chip = snd_magic_cast(sb_t, dev_id, return);
unsigned long flags;
inb(chip->mpu_port);
if (sb_status & 0x20)
inb(SBP(chip, RESET));
+ return IRQ_HANDLED;
}
/*****************************************************************/
/*
* interrupt handler
*/
-static void snd_cmipci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_cmipci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
cmipci_t *cm = snd_magic_cast(cmipci_t, dev_id, return);
unsigned int status, mask = 0;
/* fastpath out, to ease interrupt sharing */
status = snd_cmipci_read(cm, CM_REG_INT_STATUS);
if (!(status & CM_INTR))
- return;
+ return IRQ_NONE;
/* acknowledge interrupt */
spin_lock(&cm->reg_lock);
if ((status & CM_CHINT1) && cm->channel[1].running)
snd_pcm_period_elapsed(cm->channel[1].substream);
}
+ return IRQ_HANDLED;
}
/*
};
-static void snd_cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static struct pci_device_id snd_cs4281_ids[] __devinitdata = {
{ 0x1013, 0x6005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* CS4281 */
* Interrupt handler
*/
-static void snd_cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
cs4281_t *chip = snd_magic_cast(cs4281_t, dev_id, return);
unsigned int status, dma, val;
cs4281_dma_t *cdma;
if (chip == NULL)
- return;
+ return IRQ_NONE;
status = snd_cs4281_peekBA0(chip, BA0_HISR);
if ((status & 0x7fffffff) == 0) {
snd_cs4281_pokeBA0(chip, BA0_HICR, BA0_HICR_EOI);
- return;
+ return IRQ_HANDLED;
}
if (status & (BA0_HISR_DMA(0)|BA0_HISR_DMA(1)|BA0_HISR_DMA(2)|BA0_HISR_DMA(3))) {
/* EOI to the PCI part... reenables interrupts */
snd_cs4281_pokeBA0(chip, BA0_HICR, BA0_HICR_EOI);
+ return IRQ_HANDLED;
}
return 0;
}
-static void snd_cs46xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_cs46xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
cs46xx_t *chip = snd_magic_cast(cs46xx_t, dev_id, return);
u32 status1;
status1 = snd_cs46xx_peekBA0(chip, BA0_HISR);
if ((status1 & 0x7fffffff) == 0) {
snd_cs46xx_pokeBA0(chip, BA0_HICR, HICR_CHGM | HICR_IEV);
- return;
+ return IRQ_HANDLED;
}
#ifdef CONFIG_SND_CS46XX_NEW_DSP
* EOI to the PCI part....reenables interrupts
*/
snd_cs46xx_pokeBA0(chip, BA0_HICR, HICR_CHGM | HICR_IEV);
+ return IRQ_HANDLED;
}
static snd_pcm_hardware_t snd_cs46xx_playback =
#include <sound/core.h>
#include <sound/emu10k1.h>
-void snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_emu10k1_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
emu10k1_t *emu = snd_magic_cast(emu10k1_t, dev_id, return);
unsigned int status;
+ int handled = 0;
while ((status = inl(emu->port + IPR)) != 0) {
// printk("irq - status = 0x%x\n", status);
+ handled = 1;
if (status & IPR_PCIERROR) {
snd_printk("interrupt: PCI error\n");
snd_emu10k1_intr_disable(emu, INTE_PCIERRORENABLE);
outl(IPR_FXDSP, emu->port + IPR);
}
}
+ return IRQ_RETVAL(handled);
}
#endif
};
-static void snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static struct pci_device_id snd_es1938_ids[] __devinitdata = {
{ 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */
/* --------------------------------------------------------------------
* Interrupt handler
* -------------------------------------------------------------------- */
-static void snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
es1938_t *chip = snd_magic_cast(es1938_t, dev_id, return);
unsigned char status, audiostatus;
+ int handled = 0;
status = inb(SLIO_REG(chip, IRQCONTROL));
#if 0
printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS)));
#endif
/* clear irq */
+ handled = 1;
audiostatus = inb(SLSB_REG(chip, STATUS));
if (chip->active & ADC1)
snd_pcm_period_elapsed(chip->capture_substream);
#endif
/* clear irq */
+ handled = 1;
snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
if (chip->active & DAC2)
snd_pcm_period_elapsed(chip->playback1_substream);
/* Hardware volume */
if (status & 0x40) {
int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
+ handled = 1;
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
if (!split) {
/* MPU401 */
if (status & 0x80) {
// snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
- if (chip->rmidi)
+ if (chip->rmidi) {
+ handled = 1;
snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
+ }
}
+ return IRQ_RETVAL(handled);
}
#define ES1938_DMA_SIZE 64
#endif
};
-static void snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static struct pci_device_id snd_es1968_ids[] __devinitdata = {
/* Maestro 1 */
/*
* interrupt handler
*/
-static void snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_es1968_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
es1968_t *chip = snd_magic_cast(es1968_t, dev_id, return);
u32 event;
if (!(event = inb(chip->io_port + 0x1A)))
- return;
+ return IRQ_NONE;
outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
}
spin_unlock(&chip->substream_lock);
}
+ return IRQ_HANDLED;
}
/*
return bytes_to_frames(substream->runtime, ptr);
}
-static void snd_fm801_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_fm801_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
fm801_t *chip = snd_magic_cast(fm801_t, dev_id, return);
unsigned short status;
status = inw(FM801_REG(chip, IRQ_STATUS));
status &= FM801_IRQ_PLAYBACK|FM801_IRQ_CAPTURE|FM801_IRQ_MPU|FM801_IRQ_VOLUME;
if (! status)
- return;
+ return IRQ_NONE;
/* ack first */
outw(status, FM801_REG(chip, IRQ_STATUS));
if (chip->pcm && (status & FM801_IRQ_PLAYBACK) && chip->playback_substream) {
snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
if (status & FM801_IRQ_VOLUME)
;/* TODO */
+ return IRQ_HANDLED;
}
static snd_pcm_hardware_t snd_fm801_playback =
* Interrupt handler
*/
-static void snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return);
unsigned char status;
+ int handled = 0;
while (1) {
status = inb(ICEREG(ice, IRQSTAT));
if (status == 0)
break;
+ handled = 1;
if (status & ICE1712_IRQ_MPU1) {
if (ice->rmidi[0])
snd_mpu401_uart_interrupt(irq, ice->rmidi[0]->private_data, regs);
outb(ICE1712_IRQ_CONPBK, ICEREG(ice, IRQSTAT));
}
}
+ return IRQ_RETVAL(handled);
}
* Interrupt handler
*/
-static void snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return);
unsigned char status;
+ int handled = 0;
while (1) {
status = inb(ICEREG1724(ice, IRQSTAT));
if (status == 0)
break;
-
+
+ handled = 1;
/* these should probably be separated at some point,
but as we don't currently have MPU support on the board I will leave it */
if ((status & VT1724_IRQ_MPU_RX)||(status & VT1724_IRQ_MPU_TX)) {
}
}
+ return IRQ_RETVAL(handled);
}
/*
snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
}
-static void snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
u32 doorbellValue;
korg1212_t *korg1212 = snd_magic_cast(korg1212_t, dev_id, return);
if(irq != korg1212->irq)
- return;
+ return IRQ_NONE;
doorbellValue = readl(korg1212->inDoorbellPtr);
if (!doorbellValue)
- return;
+ return IRQ_HANDLED;
spin_lock(&korg1212->lock);
korg1212->inIRQ--;
spin_unlock(&korg1212->lock);
+ return IRQ_HANDLED;
}
static int snd_korg1212_downloadDSPCode(korg1212_t *korg1212)
}
}
-static void
+static irqreturn_t
snd_m3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
m3_t *chip = snd_magic_cast(m3_t, dev_id, );
status = inb(chip->iobase + 0x1A);
if (status == 0xff)
- return;
+ return IRQ_NONE;
/* presumably acking the ints? */
outw(status, chip->iobase + 0x1A);
/* XXX is this needed? */
if (status & 0x40)
outb(0x40, chip->iobase+0x1A);
+ return IRQ_HANDLED;
}
int mixer_status_mask; /* bit mask to test the mixer status */
int irq;
- void (*interrupt)(int, void *, struct pt_regs *);
+ irqreturn_t (*interrupt)(int, void *, struct pt_regs *);
int badintrcount; /* counter to check bogus interrupts */
nm256_stream_t streams[2];
* I suppose...yucky bleah.)
*/
-static void
+static irqreturn_t
snd_nm256_interrupt(int irq, void *dev_id, struct pt_regs *dummy)
{
nm256_t *chip = snd_magic_cast(nm256_t, dev_id, return);
/* Not ours. */
if (status == 0) {
snd_nm256_intr_check(chip);
- return;
+ return IRQ_NONE;
}
chip->badintrcount = 0;
}
spin_unlock(&chip->reg_lock);
+ return IRQ_HANDLED;
}
/*
* routine.
*/
-static void
+static irqreturn_t
snd_nm256_interrupt_zx(int irq, void *dev_id, struct pt_regs *dummy)
{
nm256_t *chip = snd_magic_cast(nm256_t, dev_id, return);
/* Not ours. */
if (status == 0) {
snd_nm256_intr_check(chip);
- return;
+ return IRQ_NONE;
}
chip->badintrcount = 0;
}
spin_unlock(&chip->reg_lock);
+ return IRQ_HANDLED;
}
/*
writel(rme32->wcreg, rme32->iobase + RME32_IO_CONTROL_REGISTER);
}
-static void
+static irqreturn_t
snd_rme32_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
rme32_t *rme32 = (rme32_t *) dev_id;
rme32->rcreg = readl(rme32->iobase + RME32_IO_CONTROL_REGISTER);
if (!(rme32->rcreg & RME32_RCR_IRQ)) {
- return;
+ return IRQ_NONE;
} else {
if (rme32->capture_substream) {
snd_pcm_period_elapsed(rme32->capture_substream);
}
writel(0, rme32->iobase + RME32_IO_CONFIRM_ACTION_IRQ);
}
+ return IRQ_HANDLED;
}
static unsigned int period_bytes[] = { RME32_BLOCK_SIZE };
writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
}
-static void
+static irqreturn_t
snd_rme96_interrupt(int irq,
void *dev_id,
struct pt_regs *regs)
if (!((rme96->rcreg & RME96_RCR_IRQ) ||
(rme96->rcreg & RME96_RCR_IRQ_2)))
{
- return;
+ return IRQ_NONE;
}
if (rme96->rcreg & RME96_RCR_IRQ) {
snd_pcm_period_elapsed(rme96->capture_substream);
writel(0, rme96->iobase + RME96_IO_CONFIRM_REC_IRQ);
}
+ return IRQ_HANDLED;
}
static unsigned int period_bytes[] = { RME96_SMALL_BLOCK_SIZE, RME96_LARGE_BLOCK_SIZE };
}
}
-void snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
hdsp_t *hdsp = (hdsp_t *) dev_id;
unsigned int status;
midi1 = status & HDSP_midi1IRQPending;
if (!audio && !midi0 && !midi1) {
- return;
+ return IRQ_NONE;
}
hdsp_write(hdsp, HDSP_interruptConfirmation, 0);
}
if (schedule)
tasklet_hi_schedule(&hdsp->midi_tasklet);
+ return IRQ_HANDLED;
}
static snd_pcm_uframes_t snd_hdsp_hw_pointer(snd_pcm_substream_t *substream)
rme9652_set_rate(rme9652, 48000);
}
-void snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
rme9652_t *rme9652 = (rme9652_t *) dev_id;
if (!(rme9652_read(rme9652, RME9652_status_register) & RME9652_IRQ)) {
- return;
+ return IRQ_NONE;
}
rme9652_write(rme9652, RME9652_irq_clear, 0);
if (rme9652->playback_substream) {
snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
}
+ return IRQ_HANDLED;
}
static snd_pcm_uframes_t snd_rme9652_hw_pointer(snd_pcm_substream_t *substream)
return result;
}
-static void snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
sonicvibes_t *sonic = snd_magic_cast(sonicvibes_t, dev_id, return);
unsigned char status;
status = inb(SV_REG(sonic, STATUS));
if (!(status & (SV_DMAA_IRQ | SV_DMAC_IRQ | SV_MIDI_IRQ)))
- return;
+ return IRQ_NONE;
if (status == 0xff) { /* failure */
outb(sonic->irqmask = ~0, SV_REG(sonic, IRQMASK));
snd_printk("IRQ failure - interrupts disabled!!\n");
- return;
+ return IRQ_HANDLED;
}
if (sonic->pcm) {
if (status & SV_DMAA_IRQ)
snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_mute->id);
snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_volume->id);
}
+ return IRQ_HANDLED;
}
/*
static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream);
static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream);
-static void snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs);
#ifdef CONFIG_PM
static int snd_trident_set_power_state(snd_card_t *card, unsigned int power_state);
#endif
---------------------------------------------------------------------------*/
-static void snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
trident_t *trident = snd_magic_cast(trident_t, dev_id, return);
unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
audio_int = inl(TRID_REG(trident, T4D_MISCINT));
if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
- return;
+ return IRQ_NONE;
if (audio_int & ADDRESS_IRQ) {
// get interrupt status for all channels
spin_lock(&trident->reg_lock);
}
}
// outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
+ return IRQ_HANDLED;
}
/*---------------------------------------------------------------------------
* Interrupt handler
*/
-static void snd_via82xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_via82xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
via82xx_t *chip = snd_magic_cast(via82xx_t, dev_id, return);
unsigned int status;
spin_unlock(&chip->reg_lock);
if (chip->rmidi)
/* check mpu401 interrupt */
- snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
- return;
+ return snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
+ return IRQ_NONE;
}
// _skip_sgd:
outb(c_status, VIADEV_REG(viadev, OFFSET_STATUS)); /* ack */
}
spin_unlock(&chip->reg_lock);
+ return IRQ_HANDLED;
}
/*
}
}
-static void snd_ymfpci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_ymfpci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
ymfpci_t *chip = snd_magic_cast(ymfpci_t, dev_id, return);
u32 status, nvoice, mode;
if (chip->rawmidi)
snd_mpu401_uart_interrupt(irq, chip->rawmidi->private_data, regs);
+ return IRQ_HANDLED;
}
static snd_pcm_hardware_t snd_ymfpci_playback =
/*
* interrupt handlers
*/
-static void
+static irqreturn_t
snd_pmac_tx_intr(int irq, void *devid, struct pt_regs *regs)
{
pmac_t *chip = snd_magic_cast(pmac_t, devid, return);
snd_pmac_pcm_update(chip, &chip->playback);
+ return IRQ_HANDLED;
}
-static void
+static irqreturn_t
snd_pmac_rx_intr(int irq, void *devid, struct pt_regs *regs)
{
pmac_t *chip = snd_magic_cast(pmac_t, devid, return);
snd_pmac_pcm_update(chip, &chip->capture);
+ return IRQ_HANDLED;
}
-static void
+static irqreturn_t
snd_pmac_ctrl_intr(int irq, void *devid, struct pt_regs *regs)
{
pmac_t *chip = snd_magic_cast(pmac_t, devid, return);
}
/* Writing 1s to the CNTLERR and PORTCHG bits clears them... */
out_le32(&chip->awacs->control, ctrl);
+ return IRQ_HANDLED;
}
/* interrupt - headphone plug changed */
-static void headphone_intr(int irq, void *devid, struct pt_regs *regs)
+static irqreturn_t headphone_intr(int irq, void *devid, struct pt_regs *regs)
{
pmac_t *chip = snd_magic_cast(pmac_t, devid, return);
- if (chip->update_automute && chip->initialized)
+ if (chip->update_automute && chip->initialized) {
chip->update_automute(chip, 1);
+ return IRQ_HANDLED;
+ }
+ return IRQ_NONE;
}
/* look for audio-gpio device */
__amd7930_write_map(amd);
}
-static void snd_amd7930_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_amd7930_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
amd7930_t *amd = dev_id;
unsigned int elapsed;
snd_pcm_period_elapsed(amd->playback_substream);
else
snd_pcm_period_elapsed(amd->capture_substream);
+ return IRQ_HANDLED;
}
static int snd_amd7930_trigger(amd7930_t *amd, unsigned int flag, int cmd)
}
#ifdef SBUS_SUPPORT
-static void snd_cs4231_sbus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_cs4231_sbus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
cs4231_t *chip = snd_magic_cast(cs4231_t, dev_id, return);
u32 csr;
APC_GENL_INT |
APC_XINT_PEMP |
APC_XINT_CEMP)))
- return;
+ return IRQ_NONE;
/* ACK the APC interrupt. */
sbus_writel(csr, chip->port + APCCSR);
snd_cs4231_generic_interrupt(chip);
+ return IRQ_HANDLED;
}
#endif
projects / linux / commitdiff