forked from Minki/linux
1099 lines
27 KiB
C
1099 lines
27 KiB
C
|
/*
|
||
|
|
* sound/sb_audio.c
|
||
|
|
*
|
||
|
|
* Audio routines for Sound Blaster compatible cards.
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* Copyright (C) by Hannu Savolainen 1993-1997
|
||
|
|
*
|
||
|
|
* OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
|
||
|
|
* Version 2 (June 1991). See the "COPYING" file distributed with this software
|
||
|
|
* for more info.
|
||
|
|
*
|
||
|
|
* Changes
|
||
|
|
* Alan Cox : Formatting and clean ups
|
||
|
|
*
|
||
|
|
* Status
|
||
|
|
* Mostly working. Weird uart bug causing irq storms
|
||
|
|
*
|
||
|
|
* Daniel J. Rodriksson: Changes to make sb16 work full duplex.
|
||
|
|
* Maybe other 16 bit cards in this code could behave
|
||
|
|
* the same.
|
||
|
|
* Chris Rankin: Use spinlocks instead of CLI/STI
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/spinlock.h>
|
||
|
|
|
||
|
|
#include "sound_config.h"
|
||
|
|
|
||
|
|
#include "sb_mixer.h"
|
||
|
|
#include "sb.h"
|
||
|
|
|
||
|
|
#include "sb_ess.h"
|
||
|
|
|
||
|
|
int sb_audio_open(int dev, int mode)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned long flags;
|
||
|
|
|
||
|
|
if (devc == NULL)
|
||
|
|
{
|
||
|
|
printk(KERN_ERR "Sound Blaster: incomplete initialization.\n");
|
||
|
|
return -ENXIO;
|
||
|
|
}
|
||
|
|
if (devc->caps & SB_NO_RECORDING && mode & OPEN_READ)
|
||
|
|
{
|
||
|
|
if (mode == OPEN_READ)
|
||
|
|
return -EPERM;
|
||
|
|
}
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (devc->opened)
|
||
|
|
{
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
return -EBUSY;
|
||
|
|
}
|
||
|
|
if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
|
||
|
|
{
|
||
|
|
if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit"))
|
||
|
|
{
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
return -EBUSY;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
devc->opened = mode;
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
|
||
|
|
devc->irq_mode = IMODE_NONE;
|
||
|
|
devc->irq_mode_16 = IMODE_NONE;
|
||
|
|
devc->fullduplex = devc->duplex &&
|
||
|
|
((mode & OPEN_READ) && (mode & OPEN_WRITE));
|
||
|
|
sb_dsp_reset(devc);
|
||
|
|
|
||
|
|
/* At first glance this check isn't enough, some ESS chips might not
|
||
|
|
* have a RECLEV. However if they don't common_mixer_set will refuse
|
||
|
|
* cause devc->iomap has no register mapping for RECLEV
|
||
|
|
*/
|
||
|
|
if (devc->model == MDL_ESS) ess_mixer_reload (devc, SOUND_MIXER_RECLEV);
|
||
|
|
|
||
|
|
/* The ALS007 seems to require that the DSP be removed from the output */
|
||
|
|
/* in order for recording to be activated properly. This is done by */
|
||
|
|
/* setting the appropriate bits of the output control register 4ch to */
|
||
|
|
/* zero. This code assumes that the output control registers are not */
|
||
|
|
/* used anywhere else and therefore the DSP bits are *always* ON for */
|
||
|
|
/* output and OFF for sampling. */
|
||
|
|
|
||
|
|
if (devc->submodel == SUBMDL_ALS007)
|
||
|
|
{
|
||
|
|
if (mode & OPEN_READ)
|
||
|
|
sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
|
||
|
|
sb_getmixer(devc,ALS007_OUTPUT_CTRL2) & 0xf9);
|
||
|
|
else
|
||
|
|
sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
|
||
|
|
sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void sb_audio_close(int dev)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
/* fix things if mmap turned off fullduplex */
|
||
|
|
if(devc->duplex
|
||
|
|
&& !devc->fullduplex
|
||
|
|
&& (devc->opened & OPEN_READ) && (devc->opened & OPEN_WRITE))
|
||
|
|
{
|
||
|
|
struct dma_buffparms *dmap_temp;
|
||
|
|
dmap_temp = audio_devs[dev]->dmap_out;
|
||
|
|
audio_devs[dev]->dmap_out = audio_devs[dev]->dmap_in;
|
||
|
|
audio_devs[dev]->dmap_in = dmap_temp;
|
||
|
|
}
|
||
|
|
audio_devs[dev]->dmap_out->dma = devc->dma8;
|
||
|
|
audio_devs[dev]->dmap_in->dma = ( devc->duplex ) ?
|
||
|
|
devc->dma16 : devc->dma8;
|
||
|
|
|
||
|
|
if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
|
||
|
|
sound_close_dma(devc->dma16);
|
||
|
|
|
||
|
|
/* For ALS007, turn DSP output back on if closing the device for read */
|
||
|
|
|
||
|
|
if ((devc->submodel == SUBMDL_ALS007) && (devc->opened & OPEN_READ))
|
||
|
|
{
|
||
|
|
sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
|
||
|
|
sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
|
||
|
|
}
|
||
|
|
devc->opened = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb_set_output_parms(int dev, unsigned long buf, int nr_bytes,
|
||
|
|
int intrflag)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
devc->trg_buf = buf;
|
||
|
|
devc->trg_bytes = nr_bytes;
|
||
|
|
devc->trg_intrflag = intrflag;
|
||
|
|
devc->irq_mode = IMODE_OUTPUT;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
devc->trg_buf_16 = buf;
|
||
|
|
devc->trg_bytes_16 = nr_bytes;
|
||
|
|
devc->trg_intrflag_16 = intrflag;
|
||
|
|
devc->irq_mode_16 = IMODE_OUTPUT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
devc->trg_buf = buf;
|
||
|
|
devc->trg_bytes = count;
|
||
|
|
devc->trg_intrflag = intrflag;
|
||
|
|
devc->irq_mode = IMODE_INPUT;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
devc->trg_buf_16 = buf;
|
||
|
|
devc->trg_bytes_16 = count;
|
||
|
|
devc->trg_intrflag_16 = intrflag;
|
||
|
|
devc->irq_mode_16 = IMODE_INPUT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* SB1.x compatible routines
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes, int intrflag)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
int count = nr_bytes;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
|
||
|
|
|
||
|
|
if (audio_devs[dev]->dmap_out->dma > 3)
|
||
|
|
count >>= 1;
|
||
|
|
count--;
|
||
|
|
|
||
|
|
devc->irq_mode = IMODE_OUTPUT;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x14)) /* 8 bit DAC using DMA */
|
||
|
|
{
|
||
|
|
sb_dsp_command(devc, (unsigned char) (count & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
printk(KERN_WARNING "Sound Blaster: unable to start DAC.\n");
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
devc->intr_active = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
int count = nr_bytes;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Start a DMA input to the buffer pointed by dmaqtail
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
|
||
|
|
|
||
|
|
if (audio_devs[dev]->dmap_out->dma > 3)
|
||
|
|
count >>= 1;
|
||
|
|
count--;
|
||
|
|
|
||
|
|
devc->irq_mode = IMODE_INPUT;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x24)) /* 8 bit ADC using DMA */
|
||
|
|
{
|
||
|
|
sb_dsp_command(devc, (unsigned char) (count & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
printk(KERN_ERR "Sound Blaster: unable to start ADC.\n");
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
|
||
|
|
devc->intr_active = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb1_audio_trigger(int dev, int bits)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
bits &= devc->irq_mode;
|
||
|
|
|
||
|
|
if (!bits)
|
||
|
|
sb_dsp_command(devc, 0xd0); /* Halt DMA */
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch (devc->irq_mode)
|
||
|
|
{
|
||
|
|
case IMODE_INPUT:
|
||
|
|
sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
|
||
|
|
devc->trg_intrflag);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IMODE_OUTPUT:
|
||
|
|
sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
|
||
|
|
devc->trg_intrflag);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
devc->trigger_bits = bits;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sb1_audio_prepare_for_input(int dev, int bsize, int bcount)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned long flags;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x40))
|
||
|
|
sb_dsp_command(devc, devc->tconst);
|
||
|
|
sb_dsp_command(devc, DSP_CMD_SPKOFF);
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
|
||
|
|
devc->trigger_bits = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sb1_audio_prepare_for_output(int dev, int bsize, int bcount)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned long flags;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x40))
|
||
|
|
sb_dsp_command(devc, devc->tconst);
|
||
|
|
sb_dsp_command(devc, DSP_CMD_SPKON);
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
devc->trigger_bits = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sb1_audio_set_speed(int dev, int speed)
|
||
|
|
{
|
||
|
|
int max_speed = 23000;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
int tmp;
|
||
|
|
|
||
|
|
if (devc->opened & OPEN_READ)
|
||
|
|
max_speed = 13000;
|
||
|
|
|
||
|
|
if (speed > 0)
|
||
|
|
{
|
||
|
|
if (speed < 4000)
|
||
|
|
speed = 4000;
|
||
|
|
|
||
|
|
if (speed > max_speed)
|
||
|
|
speed = max_speed;
|
||
|
|
|
||
|
|
devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff;
|
||
|
|
tmp = 256 - devc->tconst;
|
||
|
|
speed = (1000000 + tmp / 2) / tmp;
|
||
|
|
|
||
|
|
devc->speed = speed;
|
||
|
|
}
|
||
|
|
return devc->speed;
|
||
|
|
}
|
||
|
|
|
||
|
|
static short sb1_audio_set_channels(int dev, short channels)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
return devc->channels = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static unsigned int sb1_audio_set_bits(int dev, unsigned int bits)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
return devc->bits = 8;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb1_audio_halt_xfer(int dev)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
sb_dsp_reset(devc);
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* SB 2.0 and SB 2.01 compatible routines
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes,
|
||
|
|
int intrflag)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
int count = nr_bytes;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned char cmd;
|
||
|
|
|
||
|
|
/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
|
||
|
|
|
||
|
|
if (audio_devs[dev]->dmap_out->dma > 3)
|
||
|
|
count >>= 1;
|
||
|
|
count--;
|
||
|
|
|
||
|
|
devc->irq_mode = IMODE_OUTPUT;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x48)) /* DSP Block size */
|
||
|
|
{
|
||
|
|
sb_dsp_command(devc, (unsigned char) (count & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
|
||
|
|
|
||
|
|
if (devc->speed * devc->channels <= 23000)
|
||
|
|
cmd = 0x1c; /* 8 bit PCM output */
|
||
|
|
else
|
||
|
|
cmd = 0x90; /* 8 bit high speed PCM output (SB2.01/Pro) */
|
||
|
|
|
||
|
|
if (!sb_dsp_command(devc, cmd))
|
||
|
|
printk(KERN_ERR "Sound Blaster: unable to start DAC.\n");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
printk(KERN_ERR "Sound Blaster: unable to start DAC.\n");
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
devc->intr_active = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
|
||
|
|
{
|
||
|
|
unsigned long flags;
|
||
|
|
int count = nr_bytes;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned char cmd;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Start a DMA input to the buffer pointed by dmaqtail
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
|
||
|
|
|
||
|
|
if (audio_devs[dev]->dmap_out->dma > 3)
|
||
|
|
count >>= 1;
|
||
|
|
count--;
|
||
|
|
|
||
|
|
devc->irq_mode = IMODE_INPUT;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x48)) /* DSP Block size */
|
||
|
|
{
|
||
|
|
sb_dsp_command(devc, (unsigned char) (count & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
|
||
|
|
|
||
|
|
if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000))
|
||
|
|
cmd = 0x2c; /* 8 bit PCM input */
|
||
|
|
else
|
||
|
|
cmd = 0x98; /* 8 bit high speed PCM input (SB2.01/Pro) */
|
||
|
|
|
||
|
|
if (!sb_dsp_command(devc, cmd))
|
||
|
|
printk(KERN_ERR "Sound Blaster: unable to start ADC.\n");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
printk(KERN_ERR "Sound Blaster: unable to start ADC.\n");
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
devc->intr_active = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb20_audio_trigger(int dev, int bits)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
bits &= devc->irq_mode;
|
||
|
|
|
||
|
|
if (!bits)
|
||
|
|
sb_dsp_command(devc, 0xd0); /* Halt DMA */
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch (devc->irq_mode)
|
||
|
|
{
|
||
|
|
case IMODE_INPUT:
|
||
|
|
sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
|
||
|
|
devc->trg_intrflag);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IMODE_OUTPUT:
|
||
|
|
sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
|
||
|
|
devc->trg_intrflag);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
devc->trigger_bits = bits;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* SB2.01 specific speed setup
|
||
|
|
*/
|
||
|
|
|
||
|
|
static int sb201_audio_set_speed(int dev, int speed)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
int tmp;
|
||
|
|
int s = speed * devc->channels;
|
||
|
|
|
||
|
|
if (speed > 0)
|
||
|
|
{
|
||
|
|
if (speed < 4000)
|
||
|
|
speed = 4000;
|
||
|
|
if (speed > 44100)
|
||
|
|
speed = 44100;
|
||
|
|
if (devc->opened & OPEN_READ && speed > 15000)
|
||
|
|
speed = 15000;
|
||
|
|
devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
|
||
|
|
tmp = 256 - devc->tconst;
|
||
|
|
speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
|
||
|
|
|
||
|
|
devc->speed = speed;
|
||
|
|
}
|
||
|
|
return devc->speed;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* SB Pro specific routines
|
||
|
|
*/
|
||
|
|
|
||
|
|
static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount)
|
||
|
|
{ /* For SB Pro and Jazz16 */
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned long flags;
|
||
|
|
unsigned char bits = 0;
|
||
|
|
|
||
|
|
if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
|
||
|
|
audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma =
|
||
|
|
devc->bits == 16 ? devc->dma16 : devc->dma8;
|
||
|
|
|
||
|
|
if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
|
||
|
|
if (devc->bits == AFMT_S16_LE)
|
||
|
|
bits = 0x04; /* 16 bit mode */
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x40))
|
||
|
|
sb_dsp_command(devc, devc->tconst);
|
||
|
|
sb_dsp_command(devc, DSP_CMD_SPKOFF);
|
||
|
|
if (devc->channels == 1)
|
||
|
|
sb_dsp_command(devc, 0xa0 | bits); /* Mono input */
|
||
|
|
else
|
||
|
|
sb_dsp_command(devc, 0xa8 | bits); /* Stereo input */
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
|
||
|
|
devc->trigger_bits = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount)
|
||
|
|
{ /* For SB Pro and Jazz16 */
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned long flags;
|
||
|
|
unsigned char tmp;
|
||
|
|
unsigned char bits = 0;
|
||
|
|
|
||
|
|
if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
|
||
|
|
audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8;
|
||
|
|
if (devc->model == MDL_SBPRO)
|
||
|
|
sb_mixer_set_stereo(devc, devc->channels == 2);
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
if (sb_dsp_command(devc, 0x40))
|
||
|
|
sb_dsp_command(devc, devc->tconst);
|
||
|
|
sb_dsp_command(devc, DSP_CMD_SPKON);
|
||
|
|
|
||
|
|
if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
|
||
|
|
{
|
||
|
|
if (devc->bits == AFMT_S16_LE)
|
||
|
|
bits = 0x04; /* 16 bit mode */
|
||
|
|
|
||
|
|
if (devc->channels == 1)
|
||
|
|
sb_dsp_command(devc, 0xa0 | bits); /* Mono output */
|
||
|
|
else
|
||
|
|
sb_dsp_command(devc, 0xa8 | bits); /* Stereo output */
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
tmp = sb_getmixer(devc, 0x0e);
|
||
|
|
if (devc->channels == 1)
|
||
|
|
tmp &= ~0x02;
|
||
|
|
else
|
||
|
|
tmp |= 0x02;
|
||
|
|
sb_setmixer(devc, 0x0e, tmp);
|
||
|
|
}
|
||
|
|
devc->trigger_bits = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sbpro_audio_set_speed(int dev, int speed)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (speed > 0)
|
||
|
|
{
|
||
|
|
if (speed < 4000)
|
||
|
|
speed = 4000;
|
||
|
|
if (speed > 44100)
|
||
|
|
speed = 44100;
|
||
|
|
if (devc->channels > 1 && speed > 22050)
|
||
|
|
speed = 22050;
|
||
|
|
sb201_audio_set_speed(dev, speed);
|
||
|
|
}
|
||
|
|
return devc->speed;
|
||
|
|
}
|
||
|
|
|
||
|
|
static short sbpro_audio_set_channels(int dev, short channels)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (channels == 1 || channels == 2)
|
||
|
|
{
|
||
|
|
if (channels != devc->channels)
|
||
|
|
{
|
||
|
|
devc->channels = channels;
|
||
|
|
if (devc->model == MDL_SBPRO && devc->channels == 2)
|
||
|
|
sbpro_audio_set_speed(dev, devc->speed);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return devc->channels;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int jazz16_audio_set_speed(int dev, int speed)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (speed > 0)
|
||
|
|
{
|
||
|
|
int tmp;
|
||
|
|
int s = speed * devc->channels;
|
||
|
|
|
||
|
|
if (speed < 5000)
|
||
|
|
speed = 5000;
|
||
|
|
if (speed > 44100)
|
||
|
|
speed = 44100;
|
||
|
|
|
||
|
|
devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
|
||
|
|
|
||
|
|
tmp = 256 - devc->tconst;
|
||
|
|
speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
|
||
|
|
|
||
|
|
devc->speed = speed;
|
||
|
|
}
|
||
|
|
return devc->speed;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* SB16 specific routines
|
||
|
|
*/
|
||
|
|
|
||
|
|
static int sb16_audio_set_speed(int dev, int speed)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
int max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100;
|
||
|
|
|
||
|
|
if (speed > 0)
|
||
|
|
{
|
||
|
|
if (speed < 5000)
|
||
|
|
speed = 5000;
|
||
|
|
|
||
|
|
if (speed > max_speed)
|
||
|
|
speed = max_speed;
|
||
|
|
|
||
|
|
devc->speed = speed;
|
||
|
|
}
|
||
|
|
return devc->speed;
|
||
|
|
}
|
||
|
|
|
||
|
|
static unsigned int sb16_audio_set_bits(int dev, unsigned int bits)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (bits != 0)
|
||
|
|
{
|
||
|
|
if (bits == AFMT_U8 || bits == AFMT_S16_LE)
|
||
|
|
devc->bits = bits;
|
||
|
|
else
|
||
|
|
devc->bits = AFMT_U8;
|
||
|
|
}
|
||
|
|
|
||
|
|
return devc->bits;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (!devc->fullduplex)
|
||
|
|
{
|
||
|
|
audio_devs[dev]->dmap_out->dma =
|
||
|
|
audio_devs[dev]->dmap_in->dma =
|
||
|
|
devc->bits == AFMT_S16_LE ?
|
||
|
|
devc->dma16 : devc->dma8;
|
||
|
|
}
|
||
|
|
else if (devc->bits == AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
audio_devs[dev]->dmap_out->dma = devc->dma8;
|
||
|
|
audio_devs[dev]->dmap_in->dma = devc->dma16;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
audio_devs[dev]->dmap_out->dma = devc->dma16;
|
||
|
|
audio_devs[dev]->dmap_in->dma = devc->dma8;
|
||
|
|
}
|
||
|
|
|
||
|
|
devc->trigger_bits = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (!devc->fullduplex)
|
||
|
|
{
|
||
|
|
audio_devs[dev]->dmap_out->dma =
|
||
|
|
audio_devs[dev]->dmap_in->dma =
|
||
|
|
devc->bits == AFMT_S16_LE ?
|
||
|
|
devc->dma16 : devc->dma8;
|
||
|
|
}
|
||
|
|
else if (devc->bits == AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
audio_devs[dev]->dmap_out->dma = devc->dma8;
|
||
|
|
audio_devs[dev]->dmap_in->dma = devc->dma16;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
audio_devs[dev]->dmap_out->dma = devc->dma16;
|
||
|
|
audio_devs[dev]->dmap_in->dma = devc->dma8;
|
||
|
|
}
|
||
|
|
|
||
|
|
devc->trigger_bits = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb16_audio_output_block(int dev, unsigned long buf, int count,
|
||
|
|
int intrflag)
|
||
|
|
{
|
||
|
|
unsigned long flags, cnt;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
unsigned long bits;
|
||
|
|
|
||
|
|
if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
devc->irq_mode = IMODE_OUTPUT;
|
||
|
|
devc->intr_active = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
devc->irq_mode_16 = IMODE_OUTPUT;
|
||
|
|
devc->intr_active_16 = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* save value */
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
bits = devc->bits;
|
||
|
|
if (devc->fullduplex)
|
||
|
|
devc->bits = (devc->bits == AFMT_S16_LE) ?
|
||
|
|
AFMT_U8 : AFMT_S16_LE;
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
|
||
|
|
cnt = count;
|
||
|
|
if (devc->bits == AFMT_S16_LE)
|
||
|
|
cnt >>= 1;
|
||
|
|
cnt--;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
|
||
|
|
/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
|
||
|
|
|
||
|
|
sb_dsp_command(devc, 0x41);
|
||
|
|
sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
|
||
|
|
|
||
|
|
sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6));
|
||
|
|
sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
|
||
|
|
(devc->bits == AFMT_S16_LE ? 0x10 : 0)));
|
||
|
|
sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) (cnt >> 8));
|
||
|
|
|
||
|
|
/* restore real value after all programming */
|
||
|
|
devc->bits = bits;
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This fails on the Cyrix MediaGX. If you don't have the DMA enabled
|
||
|
|
* before the first sample arrives it locks up. However even if you
|
||
|
|
* do enable the DMA in time you just get DMA timeouts and missing
|
||
|
|
* interrupts and stuff, so for now I've not bothered fixing this either.
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag)
|
||
|
|
{
|
||
|
|
unsigned long flags, cnt;
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
devc->irq_mode = IMODE_INPUT;
|
||
|
|
devc->intr_active = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
devc->irq_mode_16 = IMODE_INPUT;
|
||
|
|
devc->intr_active_16 = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
cnt = count;
|
||
|
|
if (devc->bits == AFMT_S16_LE)
|
||
|
|
cnt >>= 1;
|
||
|
|
cnt--;
|
||
|
|
|
||
|
|
spin_lock_irqsave(&devc->lock, flags);
|
||
|
|
|
||
|
|
/* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
|
||
|
|
|
||
|
|
sb_dsp_command(devc, 0x42);
|
||
|
|
sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
|
||
|
|
|
||
|
|
sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce));
|
||
|
|
sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
|
||
|
|
(devc->bits == AFMT_S16_LE ? 0x10 : 0)));
|
||
|
|
sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
|
||
|
|
sb_dsp_command(devc, (unsigned char) (cnt >> 8));
|
||
|
|
|
||
|
|
spin_unlock_irqrestore(&devc->lock, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void sb16_audio_trigger(int dev, int bits)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
|
||
|
|
int bits_16 = bits & devc->irq_mode_16;
|
||
|
|
bits &= devc->irq_mode;
|
||
|
|
|
||
|
|
if (!bits && !bits_16)
|
||
|
|
sb_dsp_command(devc, 0xd0); /* Halt DMA */
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (bits)
|
||
|
|
{
|
||
|
|
switch (devc->irq_mode)
|
||
|
|
{
|
||
|
|
case IMODE_INPUT:
|
||
|
|
sb16_audio_start_input(dev,
|
||
|
|
devc->trg_buf,
|
||
|
|
devc->trg_bytes,
|
||
|
|
devc->trg_intrflag);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IMODE_OUTPUT:
|
||
|
|
sb16_audio_output_block(dev,
|
||
|
|
devc->trg_buf,
|
||
|
|
devc->trg_bytes,
|
||
|
|
devc->trg_intrflag);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (bits_16)
|
||
|
|
{
|
||
|
|
switch (devc->irq_mode_16)
|
||
|
|
{
|
||
|
|
case IMODE_INPUT:
|
||
|
|
sb16_audio_start_input(dev,
|
||
|
|
devc->trg_buf_16,
|
||
|
|
devc->trg_bytes_16,
|
||
|
|
devc->trg_intrflag_16);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IMODE_OUTPUT:
|
||
|
|
sb16_audio_output_block(dev,
|
||
|
|
devc->trg_buf_16,
|
||
|
|
devc->trg_bytes_16,
|
||
|
|
devc->trg_intrflag_16);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
devc->trigger_bits = bits | bits_16;
|
||
|
|
}
|
||
|
|
|
||
|
|
static unsigned char lbuf8[2048];
|
||
|
|
static signed short *lbuf16 = (signed short *)lbuf8;
|
||
|
|
#define LBUFCOPYSIZE 1024
|
||
|
|
static void
|
||
|
|
sb16_copy_from_user(int dev,
|
||
|
|
char *localbuf, int localoffs,
|
||
|
|
const char __user *userbuf, int useroffs,
|
||
|
|
int max_in, int max_out,
|
||
|
|
int *used, int *returned,
|
||
|
|
int len)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
int i, c, p, locallen;
|
||
|
|
unsigned char *buf8;
|
||
|
|
signed short *buf16;
|
||
|
|
|
||
|
|
/* if not duplex no conversion */
|
||
|
|
if (!devc->fullduplex)
|
||
|
|
{
|
||
|
|
if (copy_from_user(localbuf + localoffs,
|
||
|
|
userbuf + useroffs, len))
|
||
|
|
return;
|
||
|
|
*used = len;
|
||
|
|
*returned = len;
|
||
|
|
}
|
||
|
|
else if (devc->bits == AFMT_S16_LE)
|
||
|
|
{
|
||
|
|
/* 16 -> 8 */
|
||
|
|
/* max_in >> 1, max number of samples in ( 16 bits ) */
|
||
|
|
/* max_out, max number of samples out ( 8 bits ) */
|
||
|
|
/* len, number of samples that will be taken ( 16 bits )*/
|
||
|
|
/* c, count of samples remaining in buffer ( 16 bits )*/
|
||
|
|
/* p, count of samples already processed ( 16 bits )*/
|
||
|
|
len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1);
|
||
|
|
c = len;
|
||
|
|
p = 0;
|
||
|
|
buf8 = (unsigned char *)(localbuf + localoffs);
|
||
|
|
while (c)
|
||
|
|
{
|
||
|
|
locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
|
||
|
|
/* << 1 in order to get 16 bit samples */
|
||
|
|
if (copy_from_user(lbuf16,
|
||
|
|
userbuf + useroffs + (p << 1),
|
||
|
|
locallen << 1))
|
||
|
|
return;
|
||
|
|
for (i = 0; i < locallen; i++)
|
||
|
|
{
|
||
|
|
buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80;
|
||
|
|
}
|
||
|
|
c -= locallen; p += locallen;
|
||
|
|
}
|
||
|
|
/* used = ( samples * 16 bits size ) */
|
||
|
|
*used = max_in > ( max_out << 1) ? (max_out << 1) : max_in;
|
||
|
|
/* returned = ( samples * 8 bits size ) */
|
||
|
|
*returned = len;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* 8 -> 16 */
|
||
|
|
/* max_in, max number of samples in ( 8 bits ) */
|
||
|
|
/* max_out >> 1, max number of samples out ( 16 bits ) */
|
||
|
|
/* len, number of samples that will be taken ( 8 bits )*/
|
||
|
|
/* c, count of samples remaining in buffer ( 8 bits )*/
|
||
|
|
/* p, count of samples already processed ( 8 bits )*/
|
||
|
|
len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in;
|
||
|
|
c = len;
|
||
|
|
p = 0;
|
||
|
|
buf16 = (signed short *)(localbuf + localoffs);
|
||
|
|
while (c)
|
||
|
|
{
|
||
|
|
locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
|
||
|
|
if (copy_from_user(lbuf8,
|
||
|
|
userbuf+useroffs + p,
|
||
|
|
locallen))
|
||
|
|
return;
|
||
|
|
for (i = 0; i < locallen; i++)
|
||
|
|
{
|
||
|
|
buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8;
|
||
|
|
}
|
||
|
|
c -= locallen; p += locallen;
|
||
|
|
}
|
||
|
|
/* used = ( samples * 8 bits size ) */
|
||
|
|
*used = len;
|
||
|
|
/* returned = ( samples * 16 bits size ) */
|
||
|
|
*returned = len << 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
sb16_audio_mmap(int dev)
|
||
|
|
{
|
||
|
|
sb_devc *devc = audio_devs[dev]->devc;
|
||
|
|
devc->fullduplex = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static struct audio_driver sb1_audio_driver = /* SB1.x */
|
||
|
|
{
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.open = sb_audio_open,
|
||
|
|
.close = sb_audio_close,
|
||
|
|
.output_block = sb_set_output_parms,
|
||
|
|
.start_input = sb_set_input_parms,
|
||
|
|
.prepare_for_input = sb1_audio_prepare_for_input,
|
||
|
|
.prepare_for_output = sb1_audio_prepare_for_output,
|
||
|
|
.halt_io = sb1_audio_halt_xfer,
|
||
|
|
.trigger = sb1_audio_trigger,
|
||
|
|
.set_speed = sb1_audio_set_speed,
|
||
|
|
.set_bits = sb1_audio_set_bits,
|
||
|
|
.set_channels = sb1_audio_set_channels
|
||
|
|
};
|
||
|
|
|
||
|
|
static struct audio_driver sb20_audio_driver = /* SB2.0 */
|
||
|
|
{
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.open = sb_audio_open,
|
||
|
|
.close = sb_audio_close,
|
||
|
|
.output_block = sb_set_output_parms,
|
||
|
|
.start_input = sb_set_input_parms,
|
||
|
|
.prepare_for_input = sb1_audio_prepare_for_input,
|
||
|
|
.prepare_for_output = sb1_audio_prepare_for_output,
|
||
|
|
.halt_io = sb1_audio_halt_xfer,
|
||
|
|
.trigger = sb20_audio_trigger,
|
||
|
|
.set_speed = sb1_audio_set_speed,
|
||
|
|
.set_bits = sb1_audio_set_bits,
|
||
|
|
.set_channels = sb1_audio_set_channels
|
||
|
|
};
|
||
|
|
|
||
|
|
static struct audio_driver sb201_audio_driver = /* SB2.01 */
|
||
|
|
{
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.open = sb_audio_open,
|
||
|
|
.close = sb_audio_close,
|
||
|
|
.output_block = sb_set_output_parms,
|
||
|
|
.start_input = sb_set_input_parms,
|
||
|
|
.prepare_for_input = sb1_audio_prepare_for_input,
|
||
|
|
.prepare_for_output = sb1_audio_prepare_for_output,
|
||
|
|
.halt_io = sb1_audio_halt_xfer,
|
||
|
|
.trigger = sb20_audio_trigger,
|
||
|
|
.set_speed = sb201_audio_set_speed,
|
||
|
|
.set_bits = sb1_audio_set_bits,
|
||
|
|
.set_channels = sb1_audio_set_channels
|
||
|
|
};
|
||
|
|
|
||
|
|
static struct audio_driver sbpro_audio_driver = /* SB Pro */
|
||
|
|
{
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.open = sb_audio_open,
|
||
|
|
.close = sb_audio_close,
|
||
|
|
.output_block = sb_set_output_parms,
|
||
|
|
.start_input = sb_set_input_parms,
|
||
|
|
.prepare_for_input = sbpro_audio_prepare_for_input,
|
||
|
|
.prepare_for_output = sbpro_audio_prepare_for_output,
|
||
|
|
.halt_io = sb1_audio_halt_xfer,
|
||
|
|
.trigger = sb20_audio_trigger,
|
||
|
|
.set_speed = sbpro_audio_set_speed,
|
||
|
|
.set_bits = sb1_audio_set_bits,
|
||
|
|
.set_channels = sbpro_audio_set_channels
|
||
|
|
};
|
||
|
|
|
||
|
|
static struct audio_driver jazz16_audio_driver = /* Jazz16 and SM Wave */
|
||
|
|
{
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.open = sb_audio_open,
|
||
|
|
.close = sb_audio_close,
|
||
|
|
.output_block = sb_set_output_parms,
|
||
|
|
.start_input = sb_set_input_parms,
|
||
|
|
.prepare_for_input = sbpro_audio_prepare_for_input,
|
||
|
|
.prepare_for_output = sbpro_audio_prepare_for_output,
|
||
|
|
.halt_io = sb1_audio_halt_xfer,
|
||
|
|
.trigger = sb20_audio_trigger,
|
||
|
|
.set_speed = jazz16_audio_set_speed,
|
||
|
|
.set_bits = sb16_audio_set_bits,
|
||
|
|
.set_channels = sbpro_audio_set_channels
|
||
|
|
};
|
||
|
|
|
||
|
|
static struct audio_driver sb16_audio_driver = /* SB16 */
|
||
|
|
{
|
||
|
|
.owner = THIS_MODULE,
|
||
|
|
.open = sb_audio_open,
|
||
|
|
.close = sb_audio_close,
|
||
|
|
.output_block = sb_set_output_parms,
|
||
|
|
.start_input = sb_set_input_parms,
|
||
|
|
.prepare_for_input = sb16_audio_prepare_for_input,
|
||
|
|
.prepare_for_output = sb16_audio_prepare_for_output,
|
||
|
|
.halt_io = sb1_audio_halt_xfer,
|
||
|
|
.copy_user = sb16_copy_from_user,
|
||
|
|
.trigger = sb16_audio_trigger,
|
||
|
|
.set_speed = sb16_audio_set_speed,
|
||
|
|
.set_bits = sb16_audio_set_bits,
|
||
|
|
.set_channels = sbpro_audio_set_channels,
|
||
|
|
.mmap = sb16_audio_mmap
|
||
|
|
};
|
||
|
|
|
||
|
|
void sb_audio_init(sb_devc * devc, char *name, struct module *owner)
|
||
|
|
{
|
||
|
|
int audio_flags = 0;
|
||
|
|
int format_mask = AFMT_U8;
|
||
|
|
|
||
|
|
struct audio_driver *driver = &sb1_audio_driver;
|
||
|
|
|
||
|
|
switch (devc->model)
|
||
|
|
{
|
||
|
|
case MDL_SB1: /* SB1.0 or SB 1.5 */
|
||
|
|
DDB(printk("Will use standard SB1.x driver\n"));
|
||
|
|
audio_flags = DMA_HARDSTOP;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MDL_SB2:
|
||
|
|
DDB(printk("Will use SB2.0 driver\n"));
|
||
|
|
audio_flags = DMA_AUTOMODE;
|
||
|
|
driver = &sb20_audio_driver;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MDL_SB201:
|
||
|
|
DDB(printk("Will use SB2.01 (high speed) driver\n"));
|
||
|
|
audio_flags = DMA_AUTOMODE;
|
||
|
|
driver = &sb201_audio_driver;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MDL_JAZZ:
|
||
|
|
case MDL_SMW:
|
||
|
|
DDB(printk("Will use Jazz16 driver\n"));
|
||
|
|
audio_flags = DMA_AUTOMODE;
|
||
|
|
format_mask |= AFMT_S16_LE;
|
||
|
|
driver = &jazz16_audio_driver;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MDL_ESS:
|
||
|
|
DDB(printk("Will use ESS ES688/1688 driver\n"));
|
||
|
|
driver = ess_audio_init (devc, &audio_flags, &format_mask);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MDL_SB16:
|
||
|
|
DDB(printk("Will use SB16 driver\n"));
|
||
|
|
audio_flags = DMA_AUTOMODE;
|
||
|
|
format_mask |= AFMT_S16_LE;
|
||
|
|
if (devc->dma8 != devc->dma16 && devc->dma16 != -1)
|
||
|
|
{
|
||
|
|
audio_flags |= DMA_DUPLEX;
|
||
|
|
devc->duplex = 1;
|
||
|
|
}
|
||
|
|
driver = &sb16_audio_driver;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
DDB(printk("Will use SB Pro driver\n"));
|
||
|
|
audio_flags = DMA_AUTOMODE;
|
||
|
|
driver = &sbpro_audio_driver;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (owner)
|
||
|
|
driver->owner = owner;
|
||
|
|
|
||
|
|
if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
|
||
|
|
name,driver, sizeof(struct audio_driver),
|
||
|
|
audio_flags, format_mask, devc,
|
||
|
|
devc->dma8,
|
||
|
|
devc->duplex ? devc->dma16 : devc->dma8)) < 0)
|
||
|
|
{
|
||
|
|
printk(KERN_ERR "Sound Blaster: unable to install audio.\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev;
|
||
|
|
audio_devs[devc->dev]->min_fragment = 5;
|
||
|
|
}
|