ae28ee13b4
Amancio. There is some SoundSource support here that is primitive and probably doesn't work, but I'll let the two submitters let me know how my integration of that was since I don't have this card to test. I've only tested this on my GUS MAX since it's all I have. This all probably needs to be re-done anyway since we're widely variant from the original VOXWARE source in the current layout. Submitted by: Amancio Hasty and Jim Lowe Obtained from: Hannu Savolainen
839 lines
24 KiB
C
839 lines
24 KiB
C
/*
|
|
sound/aedsp16.c
|
|
|
|
Audio Excel DSP 16 software configuration routines
|
|
|
|
Copyright (C) 1995 Riccardo Facchetti (riccardo@cdc8g5.cdc.polimi.it)
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are
|
|
met: 1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer. 2.
|
|
Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
|
|
READ THIS
|
|
|
|
This module is intended for Audio Excel DSP 16 Sound Card.
|
|
|
|
Audio Excel DSP 16 is an SB pro II, Microsoft Sound System
|
|
and MPU-401 compatible card.
|
|
It is software-only configurable (no jumpers to hard-set irq/dma/mpu-irq),
|
|
so before this module, the only way to configure the DSP under linux was
|
|
boot the MS-BAU loading the sound.sys device driver (this driver soft-
|
|
configure the sound board hardware by massaging someone of its registers),
|
|
and then ctrl-alt-del to boot linux with the DSP configured by the DOG
|
|
driver.
|
|
|
|
This module works configuring your Audio Excel DSP 16's
|
|
irq, dma and mpu-401-irq. The voxware probe routines rely on the
|
|
fact that if the hardware is there, they can detect it. The problem
|
|
with AEDSP16 is that no hardware can be found by the probe routines
|
|
if the sound card is not well configured. Sometimes the kernel probe
|
|
routines can find an SBPRO even when the card is not configured (this
|
|
is the standard setup of the card), but the SBPRO emulation don't work
|
|
well if the card is not properly initialized. For this reason
|
|
|
|
InitAEDSP16_...()
|
|
|
|
routines are called before the voxware probe routines try to detect the
|
|
hardware.
|
|
|
|
NOTE (READ THE NOTE TOO, IT CONTAIN USEFUL INFORMATIONS)
|
|
|
|
The Audio Excel DSP 16 Sound Card emulates both SBPRO and MSS;
|
|
the voxware sound driver can be configured for SBPRO and MSS cards
|
|
at the same time, but the aedsp16 can't be two cards!!
|
|
When we configure it, we have to choose the SBPRO or the MSS emulation
|
|
for AEDSP16. We also can install a *REAL* card of the other type
|
|
(see [1], not tested but I can't see any reason for it to fail).
|
|
|
|
NOTE: If someone can test the combination AEDSP16+MSS or AEDSP16+SBPRO
|
|
please let me know if it works.
|
|
|
|
The MPU-401 support can be compiled in together with one of the other
|
|
two operating modes.
|
|
|
|
The board configuration calls, are in the probe_...() routines because
|
|
we have to configure the board before probing it for a particular
|
|
hardware. After card configuration, we can probe the hardware.
|
|
|
|
NOTE: This is something like plug-and-play: we have only to plug
|
|
the AEDSP16 board in the socket, and then configure and compile
|
|
a kernel that uses the AEDSP16 software configuration capability.
|
|
No jumper setting is needed!
|
|
|
|
For example, if you want AEDSP16 to be an SBPro, on irq 10, dma 3
|
|
you have just to make config the voxware package, configuring
|
|
the SBPro sound card with that parameters, then when configure
|
|
asks if you have an AEDSP16, answer yes. That's it.
|
|
Compile the kernel and run it.
|
|
|
|
NOTE: This means that you can choose irq and dma, but not the
|
|
I/O addresses. To change I/O addresses you have to set them
|
|
with jumpers.
|
|
|
|
NOTE: InitAEDSP16_...() routines get as parameter the hw_config,
|
|
the hardware configuration of the - to be configured - board.
|
|
The InitAEDSP16() routine, configure the board following our
|
|
wishes, that are in the hw_config structure.
|
|
|
|
You can change the irq/dma/mirq settings WITHOUT THE NEED to open
|
|
your computer and massage the jumpers (there are no irq/dma/mirq
|
|
jumpers to be configured anyway, only I/O port ones have to be
|
|
configured with jumpers)
|
|
|
|
For some ununderstandable reason, the card default of irq 7, dma 1,
|
|
don't work for me. Seems to be an IRQ or DMA conflict. Under heavy
|
|
HDD work, the kernel start to erupt out a lot of messages like:
|
|
|
|
'Sound: DMA timed out - IRQ/DRQ config error?'
|
|
|
|
For what I can say, I have NOT any conflict at irq 7 (under linux I'm
|
|
using the lp polling driver), and dma line 1 is unused as stated by
|
|
/proc/dma. I can suppose this is a bug of AEDSP16. I know my hardware so
|
|
I'm pretty sure I have not any conflict, but may be I'm wrong. Who knows!
|
|
Anyway a setting of irq 10, dma 3 works really fine.
|
|
|
|
NOTE: if someone can use AEDSP16 with irq 7, dma 1, please let me know
|
|
the emulation mode, all the installed hardware and the hardware
|
|
configuration (irq and dma settings of all the hardware).
|
|
|
|
This init module should work with SBPRO+MSS, when one of the two is
|
|
the AEDSP16 emulation and the other the real card. (see [1])
|
|
For example:
|
|
|
|
AEDSP16 (0x220) in SBPRO emu (0x220) + real MSS + other
|
|
AEDSP16 (0x220) in MSS emu + real SBPRO (0x240) + other
|
|
|
|
MPU401 should work. (see [1])
|
|
|
|
[1] Not tested by me for lack of hardware.
|
|
|
|
TODO, WISHES AND TECH
|
|
|
|
May be there's lot of redundant delays, but for now I want to leave it
|
|
this way.
|
|
|
|
Should be interesting eventually write down a new ioctl for the
|
|
aedsp16, to let the suser() change the irq/dma/mirq on the fly.
|
|
The thing is not trivial.
|
|
In the real world, there's no need to have such an ioctl because
|
|
when we configure the kernel for compile, we can choose the config
|
|
parameters. If we change our mind, we can easily re-config the kernel
|
|
and re-compile.
|
|
Why let the suser() change the config parameters on the fly ?
|
|
If anyone have a reasonable answer to this question, I will write down
|
|
the code to do it.
|
|
|
|
More integration with voxware, using voxware low level routines to
|
|
read-write dsp is not possible because you may want to have MSS
|
|
support and in that case we can not rely on the functions included
|
|
in sb_dsp.c to control 0x2yy I/O ports. I will continue to use my
|
|
own I/O functions.
|
|
|
|
- About I/O ports allocation -
|
|
|
|
The request_region should be done at device probe in every sound card
|
|
module. This module is not the best site for requesting regions.
|
|
When the request_region code will be added to the main modules such as
|
|
sb, adlib, gus, ad1848, etc, the requesting code in this module should
|
|
go away.
|
|
|
|
I think the request regions should be done this way:
|
|
|
|
if (check_region(...))
|
|
return ERR; // I/O region alredy reserved
|
|
device_probe(...);
|
|
device_attach(...);
|
|
request_region(...); // reserve only when we are sure all is okay
|
|
|
|
Request the 2x0h region in any case if we are using this card.
|
|
|
|
NOTE: the "(sbpro)" string with which we are requesting the aedsp16 region
|
|
(see code) does not mean necessarly that we are emulating sbpro.
|
|
It mean that the region is the sbpro I/O ports region. We use this
|
|
region to access the control registers of the card, and if emulating
|
|
sbpro, I/O sbpro registers too. If we are emulating MSS, the sbpro
|
|
registers are not used, in no way, to emulate an sbpro: they are
|
|
used only for configuration pourposes.
|
|
|
|
Someone pointed out that should be possible use both the SBPRO and MSS
|
|
modes because the sound card have all the two chipsets, supposing that
|
|
the card is really two cards. I have tried something to have the two
|
|
modes work together, but, for some reason unknown to me, without success.
|
|
|
|
I think all the soft-config only cards have an init sequence similar to
|
|
this. If you have a card that is not an aedsp16, you can try to start
|
|
with this module changing it (mainly in the CMD? I think) to fit your
|
|
needs.
|
|
|
|
Started Fri Mar 17 16:13:18 MET 1995
|
|
|
|
v0.1 (ALPHA, was an user-level program called AudioExcelDSP16.c)
|
|
- Initial code.
|
|
v0.2 (ALPHA)
|
|
- Cleanups.
|
|
- Integrated with Linux voxware v 2.90-2 kernel sound driver.
|
|
- SoundBlaster Pro mode configuration.
|
|
- Microsoft Sound System mode configuration.
|
|
- MPU-401 mode configuration.
|
|
v0.3 (ALPHA)
|
|
- Cleanups.
|
|
- Rearranged the code to let InitAEDSP16 be more general.
|
|
- Erased the REALLY_SLOW_IO. We don't need it. Erased the linux/io.h
|
|
inclusion too. We rely on os.h
|
|
- Used the INB and OUTB #defined in os.h instead of inb and outb.
|
|
- Corrected the code for GetCardName (DSP Copyright) to get a variable
|
|
len string (we are not sure about the len of Copyright string).
|
|
This works with any SB and compatible.
|
|
- Added the code to request_region at device init (should go in
|
|
the main body of voxware).
|
|
v0.4 (BETA)
|
|
- Better configure.c patch for aedsp16 configuration (better
|
|
logic of inclusion of AEDSP16 support)
|
|
- Modified the conditional compilation to better support more than
|
|
one sound card of the emulated type (read the NOTES above)
|
|
- Moved the sb init routine from the attach to the very first
|
|
probe in sb_card.c
|
|
- Rearrangemens and cleanups
|
|
- Wiped out some unnecessary code and variables: this is kernel
|
|
code so it is better save some TEXT and DATA
|
|
- Fixed the request_region code. We must allocate the aedsp16 (sbpro)
|
|
I/O ports in any case because they are used to access the DSP
|
|
configuration registers and we can not allow anyone to get them.
|
|
v0.5
|
|
- cleanups on comments
|
|
- prep for diffs against v3.0-proto-950402
|
|
|
|
*/
|
|
|
|
/*
|
|
* Include the main voxware header file. It include all the os/voxware/etc
|
|
* headers needed by this source.
|
|
*/
|
|
#include "sound_config.h"
|
|
/*
|
|
* all but ioport.h :)
|
|
*/
|
|
#include <linux/ioport.h>
|
|
|
|
#if defined(CONFIGURE_SOUNDCARD) && !defined(EXCLUDE_AEDSP16)
|
|
|
|
#define VERSION "0.5" /* Version of Audio Excel DSP 16 driver */
|
|
|
|
#undef AEDSP16_DEBUG /* Define this to enable debug code */
|
|
/* Actually no debug code is activated */
|
|
|
|
/*
|
|
* Hardware related defaults
|
|
*/
|
|
#define IRQ 7 /* 5 7(default) 9 10 11 */
|
|
#define MIRQ 0 /* 5 7 9 10 0(default), 0 means disable */
|
|
#define DMA 1 /* 0 1(default) 3 */
|
|
|
|
/*
|
|
* Commands of AEDSP16's DSP (SBPRO+special).
|
|
* For now they are CMDn, in the future they may change.
|
|
*/
|
|
#define CMD1 0xe3 /* Get DSP Copyright */
|
|
#define CMD2 0xe1 /* Get DSP Version */
|
|
#define CMD3 0x88 /* */
|
|
#define CMD4 0x5c /* */
|
|
#define CMD5 0x50 /* Set M&I&DRQ mask (the real config) */
|
|
#define CMD6 0x8c /* Enable Microsoft Sound System mode */
|
|
|
|
/*
|
|
* Offsets of AEDSP16 DSP I/O ports. The offest is added to portbase
|
|
* to have the actual I/O port.
|
|
* Register permissions are:
|
|
* (wo) == Write Only
|
|
* (ro) == Read Only
|
|
* (w-) == Write
|
|
* (r-) == Read
|
|
*/
|
|
#define DSP_RESET 0x06 /* offset of DSP RESET (wo) */
|
|
#define DSP_READ 0x0a /* offset of DSP READ (ro) */
|
|
#define DSP_WRITE 0x0c /* offset of DSP WRITE (w-) */
|
|
#define DSP_COMMAND 0x0c /* offset of DSP COMMAND (w-) */
|
|
#define DSP_STATUS 0x0c /* offset of DSP STATUS (r-) */
|
|
#define DSP_DATAVAIL 0x0e /* offset of DSP DATA AVAILABLE (ro) */
|
|
|
|
|
|
#define RETRY 10 /* Various retry values on I/O opera- */
|
|
#define STATUSRETRY 1000 /* tions. Sometimes we have to */
|
|
#define HARDRETRY 500000 /* wait for previous cmd to complete */
|
|
|
|
/*
|
|
* Size of character arrays that store name and version of sound card
|
|
*/
|
|
#define CARDNAMELEN 15 /* Size of the card's name in chars */
|
|
#define CARDVERLEN 2 /* Size of the card's version in chars */
|
|
|
|
/*
|
|
* Bit mapped flags for calling InitAEDSP16(), and saving the current
|
|
* emulation mode.
|
|
*/
|
|
#define INIT_NONE (0 )
|
|
#define INIT_SBPRO (1<<0)
|
|
#define INIT_MSS (1<<1)
|
|
#define INIT_MPU401 (1<<2)
|
|
#define RESET_DSP16 (1<<3)
|
|
|
|
/* Base HW Port for Audio Card */
|
|
static int portbase = AEDSP16_BASE;
|
|
static int irq = IRQ; /* irq for DSP I/O */
|
|
static int mirq = MIRQ; /* irq for MPU-401 I/O */
|
|
static int dma = DMA; /* dma for DSP I/O */
|
|
|
|
/* Init status of the card */
|
|
static int ae_init = INIT_NONE; /* (bitmapped variable) */
|
|
static int oredparams = 0; /* Will contain or'ed values of params */
|
|
static int gc = 0; /* generic counter (utility counter) */
|
|
struct orVals
|
|
{ /* Contain the values to be or'ed */
|
|
int val; /* irq|mirq|dma */
|
|
int or; /* oredparams |= TheStruct.or */
|
|
};
|
|
|
|
/*
|
|
* Magic values that the DSP will eat when configuring irq/mirq/dma
|
|
*/
|
|
/* DSP IRQ conversion array */
|
|
static struct orVals orIRQ[] =
|
|
{
|
|
{0x05, 0x28},
|
|
{0x07, 0x08},
|
|
{0x09, 0x10},
|
|
{0x0a, 0x18},
|
|
{0x0b, 0x20},
|
|
{0x00, 0x00}
|
|
};
|
|
|
|
/* MPU-401 IRQ conversion array */
|
|
static struct orVals orMIRQ[] =
|
|
{
|
|
{0x05, 0x04},
|
|
{0x07, 0x44},
|
|
{0x09, 0x84},
|
|
{0x0a, 0xc4},
|
|
{0x00, 0x00}
|
|
};
|
|
|
|
/* DMA Channels conversion array */
|
|
static struct orVals orDMA[] =
|
|
{
|
|
{0x00, 0x01},
|
|
{0x01, 0x02},
|
|
{0x03, 0x03},
|
|
{0x00, 0x00}
|
|
};
|
|
|
|
/*
|
|
* Buffers to store audio card informations
|
|
*/
|
|
static char AudioExcelName[CARDNAMELEN + 1];
|
|
static char AudioExcelVersion[CARDVERLEN + 1];
|
|
|
|
static void
|
|
tenmillisec (void)
|
|
{
|
|
|
|
for (gc = 0; gc < 1000; gc++)
|
|
tenmicrosec ();
|
|
}
|
|
|
|
static int
|
|
WaitForDataAvail (int port)
|
|
{
|
|
int loop = STATUSRETRY;
|
|
unsigned char ret = 0;
|
|
|
|
do
|
|
{
|
|
ret = INB (port + DSP_DATAVAIL);
|
|
/*
|
|
* Wait for data available (bit 7 of ret == 1)
|
|
*/
|
|
}
|
|
while (!(ret & 0x80) && loop--);
|
|
|
|
if (ret & 0x80)
|
|
return 0;
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
ReadData (int port)
|
|
{
|
|
if (WaitForDataAvail (port))
|
|
return -1;
|
|
return INB (port + DSP_READ);
|
|
}
|
|
|
|
static int
|
|
CheckDSPOkay (int port)
|
|
{
|
|
return ((ReadData (port) == 0xaa) ? 0 : -1);
|
|
}
|
|
|
|
static int
|
|
ResetBoard (int port)
|
|
{
|
|
/*
|
|
* Reset DSP
|
|
*/
|
|
OUTB (1, (port + DSP_RESET));
|
|
tenmicrosec ();
|
|
OUTB (0, (port + DSP_RESET));
|
|
tenmicrosec ();
|
|
tenmicrosec ();
|
|
return CheckDSPOkay (port);
|
|
}
|
|
|
|
static int
|
|
WriteDSPCommand (int port, int cmd)
|
|
{
|
|
unsigned char ret;
|
|
int loop = HARDRETRY;
|
|
|
|
do
|
|
{
|
|
ret = INB (port + DSP_STATUS);
|
|
/*
|
|
* DSP ready to receive data if bit 7 of ret == 0
|
|
*/
|
|
if (!(ret & 0x80))
|
|
{
|
|
OUTB (cmd, port + DSP_COMMAND);
|
|
return 0;
|
|
}
|
|
}
|
|
while (loop--);
|
|
|
|
printk ("[aedsp16] DSP Command (0x%x) timeout.\n", cmd);
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
InitMSS (int port)
|
|
{
|
|
|
|
tenmillisec ();
|
|
|
|
if (WriteDSPCommand (port, CMD6))
|
|
{
|
|
printk ("[aedsp16] CMD 0x%x: failed!\n", CMD6);
|
|
return -1;
|
|
}
|
|
|
|
tenmillisec ();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
SetUpBoard (int port)
|
|
{
|
|
int loop = RETRY;
|
|
|
|
do
|
|
{
|
|
if (WriteDSPCommand (portbase, CMD3))
|
|
{
|
|
printk ("[aedsp16] CMD 0x%x: failed!\n", CMD3);
|
|
return -1;
|
|
}
|
|
|
|
tenmillisec ();
|
|
|
|
}
|
|
while (WaitForDataAvail (port) && loop--);
|
|
|
|
#if defined(THIS_SHOULD_GO_AWAY)
|
|
if (CheckDSPOkay (port))
|
|
{
|
|
printk ("[aedsp16] CheckDSPOkay: failed\n");
|
|
return -1;
|
|
}
|
|
#else
|
|
if (ReadData (port) == -1)
|
|
{
|
|
printk ("[aedsp16] ReadData after CMD 0x%x: failed\n", CMD3);
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if (WriteDSPCommand (portbase, CMD4))
|
|
{
|
|
printk ("[aedsp16] CMD 0x%x: failed!\n", CMD4);
|
|
return -1;
|
|
}
|
|
|
|
if (WriteDSPCommand (portbase, CMD5))
|
|
{
|
|
printk ("[aedsp16] CMD 0x%x: failed!\n", CMD5);
|
|
return -1;
|
|
}
|
|
|
|
if (WriteDSPCommand (portbase, oredparams))
|
|
{
|
|
printk ("[aedsp16] Initialization of (M)IRQ and DMA: failed!\n");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
GetCardVersion (int port)
|
|
{
|
|
int len = 0;
|
|
int ret;
|
|
int ver[3];
|
|
|
|
do
|
|
{
|
|
if ((ret = ReadData (port)) == -1)
|
|
return -1;
|
|
/*
|
|
* We alredy know how many int are stored (2), so we know when the
|
|
* string is finished.
|
|
*/
|
|
ver[len++] = ret;
|
|
}
|
|
while (len < CARDVERLEN);
|
|
sprintf (AudioExcelVersion, "%d.%d", ver[0], ver[1]);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
GetCardName (int port)
|
|
{
|
|
int len = 0;
|
|
int ret;
|
|
|
|
do
|
|
{
|
|
if ((ret = ReadData (port)) == -1)
|
|
/*
|
|
* If no more data availabe, return to the caller, no error if len>0.
|
|
* We have no other way to know when the string is finished.
|
|
*/
|
|
return (len ? 0 : -1);
|
|
|
|
AudioExcelName[len++] = ret;
|
|
|
|
}
|
|
while (len < CARDNAMELEN);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
InitializeHardParams (void)
|
|
{
|
|
|
|
memset (AudioExcelName, 0, CARDNAMELEN + 1);
|
|
memset (AudioExcelVersion, 0, CARDVERLEN + 1);
|
|
|
|
for (gc = 0; orIRQ[gc].or; gc++)
|
|
if (orIRQ[gc].val == irq)
|
|
oredparams |= orIRQ[gc].or;
|
|
|
|
for (gc = 0; orMIRQ[gc].or; gc++)
|
|
if (orMIRQ[gc].or == mirq)
|
|
oredparams |= orMIRQ[gc].or;
|
|
|
|
for (gc = 0; orDMA[gc].or; gc++)
|
|
if (orDMA[gc].val == dma)
|
|
oredparams |= orDMA[gc].or;
|
|
}
|
|
|
|
static int
|
|
InitAEDSP16 (int which)
|
|
{
|
|
static char *InitName = NULL;
|
|
|
|
InitializeHardParams ();
|
|
|
|
if (ResetBoard (portbase))
|
|
{
|
|
printk ("[aedsp16] ResetBoard: failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
#if defined(THIS_SHOULD_GO_AWAY)
|
|
if (CheckDSPOkay (portbase))
|
|
{
|
|
printk ("[aedsp16] CheckDSPOkay: failed!\n");
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if (WriteDSPCommand (portbase, CMD1))
|
|
{
|
|
printk ("[aedsp16] CMD 0x%x: failed!\n", CMD1);
|
|
return -1;
|
|
}
|
|
|
|
if (GetCardName (portbase))
|
|
{
|
|
printk ("[aedsp16] GetCardName: failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* My AEDSP16 card return SC-6000 in AudioExcelName, so
|
|
* if we have something different, we have to be warned.
|
|
*/
|
|
if (strcmp ("SC-6000", AudioExcelName))
|
|
printk ("[aedsp16] Warning: non SC-6000 audio card!\n");
|
|
|
|
if (WriteDSPCommand (portbase, CMD2))
|
|
{
|
|
printk ("[aedsp16] CMD 0x%x: failed!\n", CMD2);
|
|
return -1;
|
|
}
|
|
|
|
if (GetCardVersion (portbase))
|
|
{
|
|
printk ("[aedsp16] GetCardVersion: failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
if (SetUpBoard (portbase))
|
|
{
|
|
printk ("[aedsp16] SetUpBoard: failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
if (which == INIT_MSS)
|
|
{
|
|
if (InitMSS (portbase))
|
|
{
|
|
printk ("[aedsp16] Can't initialize Microsoft Sound System mode.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we are resetting, do not print any message because we may be
|
|
* in playing and we do not want lost too much time.
|
|
*/
|
|
if (!(which & RESET_DSP16))
|
|
{
|
|
if (which & INIT_MPU401)
|
|
InitName = "MPU401";
|
|
else if (which & INIT_SBPRO)
|
|
InitName = "SBPro";
|
|
else if (which & INIT_MSS)
|
|
InitName = "MSS";
|
|
else
|
|
InitName = "None";
|
|
|
|
printk ("Audio Excel DSP 16 init v%s (%s %s) [%s]\n",
|
|
VERSION, AudioExcelName,
|
|
AudioExcelVersion, InitName);
|
|
}
|
|
|
|
tenmillisec ();
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(AEDSP16_SBPRO)
|
|
|
|
int
|
|
InitAEDSP16_SBPRO (struct address_info *hw_config)
|
|
{
|
|
/*
|
|
* If the card is alredy init'ed MSS, we can not init it to SBPRO too
|
|
* because the board can not emulate simultaneously MSS and SBPRO.
|
|
*/
|
|
if (ae_init & INIT_MSS)
|
|
return -1;
|
|
if (ae_init & INIT_SBPRO)
|
|
return 0;
|
|
|
|
/*
|
|
* For now we will leave this
|
|
* code included only when INCLUDE_AEDSP16 is configured in, but it should
|
|
* be better include it every time.
|
|
*/
|
|
if (!(ae_init & INIT_MPU401))
|
|
{
|
|
if (check_region (hw_config->io_base, 0x0f))
|
|
{
|
|
printk ("AEDSP16/SBPRO I/O port region is alredy in use.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set up the internal hardware parameters, to let the driver reach
|
|
* the Sound Card.
|
|
*/
|
|
portbase = hw_config->io_base;
|
|
irq = hw_config->irq;
|
|
dma = hw_config->dma;
|
|
if (InitAEDSP16 (INIT_SBPRO))
|
|
return -1;
|
|
|
|
if (!(ae_init & INIT_MPU401))
|
|
request_region (hw_config->io_base, 0x0f, "aedsp16 (sbpro)");
|
|
|
|
ae_init |= INIT_SBPRO;
|
|
return 0;
|
|
}
|
|
|
|
#endif /* AEDSP16_SBPRO */
|
|
|
|
#if defined(AEDSP16_MSS)
|
|
|
|
int
|
|
InitAEDSP16_MSS (struct address_info *hw_config)
|
|
{
|
|
/*
|
|
* If the card is alredy init'ed SBPRO, we can not init it to MSS too
|
|
* because the board can not emulate simultaneously MSS and SBPRO.
|
|
*/
|
|
if (ae_init & INIT_SBPRO)
|
|
return -1;
|
|
if (ae_init & INIT_MSS)
|
|
return 0;
|
|
|
|
/*
|
|
* For now we will leave this
|
|
* code included only when INCLUDE_AEDSP16 is configured in, but it should
|
|
* be better include it every time.
|
|
*/
|
|
if (check_region (hw_config->io_base, 0x08))
|
|
{
|
|
printk ("MSS I/O port region is alredy in use.\n");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* We must allocate the AEDSP16 region too because these are the I/O ports
|
|
* to access card's control registers.
|
|
*/
|
|
if (!(ae_init & INIT_MPU401))
|
|
{
|
|
if (check_region (AEDSP16_BASE, 0x0f))
|
|
{
|
|
printk ("AEDSP16 I/O port region is alredy in use.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* If we are configuring the card for MSS, the portbase for card configuration
|
|
* is the default one (0x220 unless you have changed the factory default
|
|
* with board switches), so no need to modify the portbase variable.
|
|
* The default is AEDSP16_BASE, that is the right value.
|
|
*/
|
|
irq = hw_config->irq;
|
|
dma = hw_config->dma;
|
|
if (InitAEDSP16 (INIT_MSS))
|
|
return -1;
|
|
|
|
request_region (hw_config->io_base, 0x08, "aedsp16 (mss)");
|
|
|
|
if (!(ae_init & INIT_MPU401))
|
|
request_region (AEDSP16_BASE, 0x0f, "aedsp16 (sbpro)");
|
|
|
|
ae_init |= INIT_MSS;
|
|
return 0;
|
|
}
|
|
|
|
#endif /* AEDSP16_MSS */
|
|
|
|
#if defined(AEDSP16_MPU401)
|
|
|
|
int
|
|
InitAEDSP16_MPU401 (struct address_info *hw_config)
|
|
{
|
|
if (ae_init & INIT_MPU401)
|
|
return 0;
|
|
|
|
/*
|
|
* For now we will leave this
|
|
* code included only when INCLUDE_AEDSP16 is configured in, but it should
|
|
* be better include it every time.
|
|
*/
|
|
if (check_region (hw_config->io_base, 0x02))
|
|
{
|
|
printk ("SB I/O port region is alredy in use.\n");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* We must allocate the AEDSP16 region too because these are the I/O ports
|
|
* to access card's control registers.
|
|
*/
|
|
if (!(ae_init & (INIT_MSS | INIT_SBPRO)))
|
|
{
|
|
if (check_region (AEDSP16_BASE, 0x0f))
|
|
{
|
|
printk ("AEDSP16 I/O port region is alredy in use.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If mpu401, the irq and dma are not important, do not touch it
|
|
* because we may use the default if sbpro is not yet configured,
|
|
* we may use the sbpro ones if configured, and nothing wrong
|
|
* should happen.
|
|
*
|
|
* The mirq default is 0, but once set it to non-0 value, we should
|
|
* not touch it anymore (unless I write an ioctl to do it, of course).
|
|
*/
|
|
mirq = hw_config->irq;
|
|
if (InitAEDSP16 (INIT_MPU401))
|
|
return -1;
|
|
|
|
request_region (hw_config->io_base, 0x02, "aedsp16 (mpu401)");
|
|
|
|
if (!(ae_init & (INIT_MSS | INIT_SBPRO)))
|
|
request_region (AEDSP16_BASE, 0x0f, "aedsp16 (sbpro)");
|
|
|
|
ae_init |= INIT_MPU401;
|
|
return 0;
|
|
}
|
|
|
|
#endif /* AEDSP16_MPU401 */
|
|
|
|
#if 0 /* Leave it out for now. We are not using this portion of code. */
|
|
|
|
/*
|
|
* Entry point for a reset function.
|
|
* May be I will write the infamous ioctl :)
|
|
*/
|
|
int
|
|
ResetAEDSP16 (void)
|
|
{
|
|
#if defined(AEDSP16_DEBUG)
|
|
printk ("[aedsp16] ResetAEDSP16 called.\n");
|
|
#endif
|
|
return InitAEDSP16 (RESET_DSP16);
|
|
}
|
|
|
|
#endif /* 0 */
|
|
|
|
#endif /* !EXCLUDE_AEDSP16 */
|