minix/drivers/sb16/sb16_dsp.c
Cristiano Giuffrida 1f5841c8ed Basic System Event Framework (SEF) with ping and live update.
SYSLIB CHANGES:
- SEF must be used by every system process and is thereby part of the system
library.
- The framework provides a receive() interface (sef_receive) for system
processes to automatically catch known system even messages and process them.
- SEF provides a default behavior for each type of system event, but allows
system processes to register callbacks to override the default behavior.
- Custom (local to the process) or predefined (provided by SEF) callback
implementations can be registered to SEF.
- SEF currently includes support for 2 types of system events:
  1. SEF Ping. The event occurs every time RS sends a ping to figure out
  whether a system process is still alive. The default callback implementation
  provided by SEF is to notify RS back to let it know the process is alive
  and kicking.
  2. SEF Live update. The event occurs every time RS sends a prepare to update
  message to let a system process know an update is available and to prepare
  for it. The live update support is very basic for now. SEF only deals with
  verifying if the prepare state can be supported by the process, dumping the
  state for debugging purposes, and providing an event-driven programming
  model to the process to react to state changes check-in when ready to update.
- SEF should be extended in the future to integrate support for more types of
system events. Ideally, all the cross-cutting concerns should be integrated into
SEF to avoid duplicating code and ease extensibility. Examples include:
  * PM notify messages primarily used at shutdown.
  * SYSTEM notify messages primarily used for signals.
  * CLOCK notify messages used for system alarms.
  * Debug messages. IS could still be in charge of fkey handling but would
  forward the debug message to the target process (e.g. PM, if the user
  requested debug information about PM). SEF would then catch the message and
  do nothing unless the process has registered an appropriate callback to
  deal with the event. This simplifies the programming model to print debug
  information, avoids duplicating code, and reduces the effort to print
  debug information.

SYSTEM PROCESSES CHANGES:
- Every system process registers SEF callbacks it needs to override the default
system behavior and calls sef_startup() right after being started.
- sef_startup() does almost nothing now, but will be extended in the future to
support callbacks of its own to let RS control and synchronize with every
system process at initialization time.
- Every system process calls sef_receive() now rather than receive() directly,
to let SEF handle predefined system events.

RS CHANGES:
- RS supports a basic single-component live update protocol now, as follows:
  * When an update command is issued (via "service update *"), RS notifies the
  target system process to prepare for a specific update state.
  * If the process doesn't respond back in time, the update is aborted.
  * When the process responds back, RS kills it and marks it for refreshing.
  * The process is then automatically restarted as for a buggy process and can
  start running again.
  * Live update is currently prototyped as a controlled failure.
2009-12-21 14:12:21 +00:00

700 lines
20 KiB
C

/* This file contains the driver for a DSP (Digital Sound Processor) on
* a SoundBlaster 16 soundcard.
*
* The driver supports the following operations (using message format m2):
*
* m_type DEVICE IO_ENDPT COUNT POSITION ADRRESS
* ----------------------------------------------------------------
* | DEV_OPEN | device | proc nr | | | |
* |------------+---------+---------+---------+---------+---------|
* | DEV_CLOSE | device | proc nr | | | |
* |------------+---------+---------+---------+---------+---------|
* | DEV_READ | device | proc nr | bytes | | buf ptr |
* |------------+---------+---------+---------+---------+---------|
* | DEV_WRITE | device | proc nr | bytes | | buf ptr |
* |------------+---------+---------+---------+---------+---------|
* | DEV_IOCTL | device | proc nr |func code| | buf ptr |
* ----------------------------------------------------------------
*
* The file contains one entry point:
*
* main: main entry when driver is brought up
*
* August 24 2005 Ported driver to user space (only audio playback) (Peter Boonstoppel)
* May 20 1995 Author: Michel R. Prevenier
*/
#include <minix/endpoint.h>
#include "sb16.h"
_PROTOTYPE(void main, (void));
FORWARD _PROTOTYPE( int dsp_open, (void) );
FORWARD _PROTOTYPE( int dsp_close, (void) );
FORWARD _PROTOTYPE( int dsp_ioctl, (message *m_ptr) );
FORWARD _PROTOTYPE( void dsp_write, (message *m_ptr) );
FORWARD _PROTOTYPE( void dsp_hardware_msg, (void) );
FORWARD _PROTOTYPE( void dsp_status, (message *m_ptr) );
FORWARD _PROTOTYPE( void reply, (int code, int replyee, int process, int status) );
FORWARD _PROTOTYPE( void init_buffer, (void) );
FORWARD _PROTOTYPE( int dsp_init, (void) );
FORWARD _PROTOTYPE( int dsp_reset, (void) );
FORWARD _PROTOTYPE( int dsp_command, (int value) );
FORWARD _PROTOTYPE( int dsp_set_size, (unsigned int size) );
FORWARD _PROTOTYPE( int dsp_set_speed, (unsigned int speed) );
FORWARD _PROTOTYPE( int dsp_set_stereo, (unsigned int stereo) );
FORWARD _PROTOTYPE( int dsp_set_bits, (unsigned int bits) );
FORWARD _PROTOTYPE( int dsp_set_sign, (unsigned int sign) );
FORWARD _PROTOTYPE( void dsp_dma_setup, (phys_bytes address, int count) );
FORWARD _PROTOTYPE( void dsp_setup, (void) );
PRIVATE int irq_hook_id; /* id of irq hook at the kernel */
PRIVATE char DmaBuffer[DMA_SIZE + 64 * 1024];
PRIVATE char* DmaPtr;
PRIVATE phys_bytes DmaPhys;
PRIVATE char Buffer[DSP_MAX_FRAGMENT_SIZE * DSP_NR_OF_BUFFERS];
PRIVATE int DspVersion[2];
PRIVATE unsigned int DspStereo = DEFAULT_STEREO;
PRIVATE unsigned int DspSpeed = DEFAULT_SPEED;
PRIVATE unsigned int DspBits = DEFAULT_BITS;
PRIVATE unsigned int DspSign = DEFAULT_SIGN;
PRIVATE unsigned int DspFragmentSize = DSP_MAX_FRAGMENT_SIZE;
PRIVATE int DspAvail = 0;
PRIVATE int DspBusy = 0;
PRIVATE int DmaMode = 0;
PRIVATE int DmaBusy = -1;
PRIVATE int DmaFillNext = 0;
PRIVATE int BufReadNext = -1;
PRIVATE int BufFillNext = 0;
PRIVATE int revivePending = 0;
PRIVATE int reviveStatus;
PRIVATE int reviveProcNr;
#define dprint (void)
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
EXTERN _PROTOTYPE( void sef_cb_lu_prepare, (int state) );
EXTERN _PROTOTYPE( int sef_cb_lu_state_isvalid, (int state) );
EXTERN _PROTOTYPE( void sef_cb_lu_state_dump, (int state) );
PUBLIC int is_processing = FALSE;
PUBLIC int is_status_msg_expected = FALSE;
/*===========================================================================*
* main
*===========================================================================*/
PUBLIC void main()
{
int r, caller, proc_nr, s;
message mess;
/* SEF local startup. */
sef_local_startup();
dprint("sb16_dsp.c: main()\n");
/* Get a DMA buffer. */
init_buffer();
while(TRUE) {
/* Wait for an incoming message */
sef_receive(ANY, &mess);
caller = mess.m_source;
proc_nr = mess.IO_ENDPT;
if (is_notify(mess.m_type)) {
switch (_ENDPOINT_P(mess.m_source)) {
case HARDWARE:
dsp_hardware_msg();
continue; /* don't reply */
case SYSTEM:
continue; /* don't reply */
default:
r = EINVAL;
}
/* dont with this message */
goto send_reply;
}
/* Now carry out the work. */
switch(mess.m_type) {
case DEV_OPEN: r = dsp_open(); break;
case DEV_CLOSE: r = dsp_close(); break;
#ifdef DEV_IOCTL
case DEV_IOCTL: r = dsp_ioctl(&mess); break;
#endif
#ifdef DEV_READ
case DEV_READ: r = EINVAL; break; /* Not yet implemented */
case DEV_WRITE: dsp_write(&mess); continue; /* don't reply */
#endif
case DEV_STATUS: dsp_status(&mess); continue; /* don't reply */
default: r = EINVAL;
}
send_reply:
/* Finally, prepare and send the reply message. */
reply(TASK_REPLY, caller, proc_nr, r);
}
}
/*===========================================================================*
* sef_local_startup *
*===========================================================================*/
PRIVATE void sef_local_startup()
{
/* Register live update callbacks. */
sef_setcb_lu_prepare(sef_cb_lu_prepare);
sef_setcb_lu_state_isvalid(sef_cb_lu_state_isvalid);
sef_setcb_lu_state_dump(sef_cb_lu_state_dump);
/* Let SEF perform startup. */
sef_startup();
}
/*===========================================================================*
* dsp_open
*===========================================================================*/
PRIVATE int dsp_open()
{
dprint("sb16_dsp.c: dsp_open()\n");
/* try to detect SoundBlaster card */
if(!DspAvail && dsp_init() != OK) return EIO;
/* Only one open at a time with soundcards */
if(DspBusy) return EBUSY;
/* Start with a clean DSP */
if(dsp_reset() != OK) return EIO;
/* Setup default values */
DspStereo = DEFAULT_STEREO;
DspSpeed = DEFAULT_SPEED;
DspBits = DEFAULT_BITS;
DspSign = DEFAULT_SIGN;
DspFragmentSize = DMA_SIZE / 2;
DspBusy = 1;
return OK;
}
/*===========================================================================*
* dsp_close
*===========================================================================*/
PRIVATE int dsp_close()
{
dprint("sb16_dsp.c: dsp_close()\n");
DspBusy = 0; /* soundcard available again */
return OK;
}
/*===========================================================================*
* dsp_ioctl
*===========================================================================*/
PRIVATE int dsp_ioctl(m_ptr)
message *m_ptr;
{
int status;
phys_bytes user_phys;
unsigned int val;
dprint("sb16_dsp.c: dsp_ioctl()\n");
/* Cannot change parameters during play or recording */
if(DmaBusy >= 0) return EBUSY;
/* Get user data */
if(m_ptr->REQUEST != DSPIORESET) {
sys_vircopy(m_ptr->IO_ENDPT, D, (vir_bytes)m_ptr->ADDRESS, SELF, D, (vir_bytes)&val, sizeof(val));
}
dprint("dsp_ioctl: got ioctl %d, argument: %d\n", m_ptr->REQUEST, val);
switch(m_ptr->REQUEST) {
case DSPIORATE: status = dsp_set_speed(val); break;
case DSPIOSTEREO: status = dsp_set_stereo(val); break;
case DSPIOBITS: status = dsp_set_bits(val); break;
case DSPIOSIZE: status = dsp_set_size(val); break;
case DSPIOSIGN: status = dsp_set_sign(val); break;
case DSPIOMAX:
val = DSP_MAX_FRAGMENT_SIZE;
sys_vircopy(SELF, D, (vir_bytes)&val, m_ptr->IO_ENDPT, D, (vir_bytes)m_ptr->ADDRESS, sizeof(val));
status = OK;
break;
case DSPIORESET: status = dsp_reset(); break;
default: status = ENOTTY; break;
}
return status;
}
/*===========================================================================*
* dsp_write
*===========================================================================*/
PRIVATE void dsp_write(m_ptr)
message *m_ptr;
{
int s;
message mess;
dprint("sb16_dsp.c: dsp_write()\n");
if(m_ptr->COUNT != DspFragmentSize) {
reply(TASK_REPLY, m_ptr->m_source, m_ptr->IO_ENDPT, EINVAL);
return;
}
if(m_ptr->m_type != DmaMode && DmaBusy >= 0) {
reply(TASK_REPLY, m_ptr->m_source, m_ptr->IO_ENDPT, EBUSY);
return;
}
reply(TASK_REPLY, m_ptr->m_source, m_ptr->IO_ENDPT, SUSPEND);
is_processing = TRUE;
if(DmaBusy < 0) { /* Dma tranfer not yet started */
DmaMode = DEV_WRITE_S; /* Dma mode is writing */
sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)DmaPtr, (phys_bytes)DspFragmentSize);
dsp_dma_setup(DmaPhys, DspFragmentSize * DMA_NR_OF_BUFFERS);
dsp_setup();
DmaBusy = 0; /* Dma is busy */
dprint(" filled dma[0]\n");
DmaFillNext = 1;
} else if(DmaBusy != DmaFillNext) { /* Dma transfer started, but Dma buffer not yet full */
sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)DmaPtr + DmaFillNext * DspFragmentSize, (phys_bytes)DspFragmentSize);
dprint(" filled dma[%d]\n", DmaFillNext);
DmaFillNext = (DmaFillNext + 1) % DMA_NR_OF_BUFFERS;
} else if(BufReadNext < 0) { /* Dma buffer full, fill first element of second buffer */
sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)Buffer, (phys_bytes)DspFragmentSize);
dprint(" filled buf[0]\n");
BufReadNext = 0;
BufFillNext = 1;
} else { /* Dma buffer is full, filling second buffer */
while(BufReadNext == BufFillNext) { /* Second buffer also full, wait for space to become available */
sef_receive(HARDWARE, &mess);
dsp_hardware_msg();
}
sys_datacopy(m_ptr->IO_ENDPT, (vir_bytes)m_ptr->ADDRESS, SELF, (vir_bytes)Buffer + BufFillNext * DspFragmentSize, (phys_bytes)DspFragmentSize);
dprint(" filled buf[%d]\n", BufFillNext);
BufFillNext = (BufFillNext + 1) % DSP_NR_OF_BUFFERS;
}
is_status_msg_expected = TRUE;
revivePending = 1;
reviveStatus = DspFragmentSize;
reviveProcNr = m_ptr->IO_ENDPT;
notify(m_ptr->m_source);
}
/*===========================================================================*
* dsp_hardware_msg
*===========================================================================*/
PRIVATE void dsp_hardware_msg()
{
dprint("Interrupt: ");
if(DmaBusy >= 0) { /* Dma transfer was actually busy */
dprint("Finished playing dma[%d]; ", DmaBusy);
DmaBusy = (DmaBusy + 1) % DMA_NR_OF_BUFFERS;
if(DmaBusy == DmaFillNext) { /* Dma buffer empty, stop Dma transfer */
dsp_command((DspBits == 8 ? DSP_CMD_DMA8HALT : DSP_CMD_DMA16HALT));
dprint("No more work...!\n");
DmaBusy = -1;
} else if(BufReadNext >= 0) { /* Data in second buffer, copy one fragment to Dma buffer */
/* Acknowledge the interrupt on the DSP */
sb16_inb((DspBits == 8 ? DSP_DATA_AVL : DSP_DATA16_AVL));
memcpy(DmaPtr + DmaFillNext * DspFragmentSize, Buffer + BufReadNext * DspFragmentSize, DspFragmentSize);
dprint("copy buf[%d] -> dma[%d]; ", BufReadNext, DmaFillNext);
BufReadNext = (BufReadNext + 1) % DSP_NR_OF_BUFFERS;
DmaFillNext = (DmaFillNext + 1) % DMA_NR_OF_BUFFERS;
if(BufReadNext == BufFillNext) {
BufReadNext = -1;
}
dprint("Starting dma[%d]\n", DmaBusy);
return;
} else { /* Second buffer empty, still data in Dma buffer, continue playback */
dprint("Starting dma[%d]\n", DmaBusy);
}
}
/* Acknowledge the interrupt on the DSP */
sb16_inb((DspBits == 8 ? DSP_DATA_AVL : DSP_DATA16_AVL));
}
/*===========================================================================*
* dsp_status *
*===========================================================================*/
PRIVATE void dsp_status(m_ptr)
message *m_ptr; /* pointer to the newly arrived message */
{
if(revivePending) {
m_ptr->m_type = DEV_REVIVE; /* build message */
m_ptr->REP_ENDPT = reviveProcNr;
m_ptr->REP_STATUS = reviveStatus;
revivePending = 0; /* unmark event */
is_processing = FALSE;
} else {
m_ptr->m_type = DEV_NO_STATUS;
is_status_msg_expected = FALSE;
}
send(m_ptr->m_source, m_ptr); /* send the message */
}
/*===========================================================================*
* reply *
*===========================================================================*/
PRIVATE void reply(code, replyee, process, status)
int code;
int replyee;
int process;
int status;
{
message m;
m.m_type = code; /* TASK_REPLY or REVIVE */
m.REP_STATUS = status; /* result of device operation */
m.REP_ENDPT = process; /* which user made the request */
send(replyee, &m);
}
/*===========================================================================*
* init_buffer
*===========================================================================*/
PRIVATE void init_buffer()
{
/* Select a buffer that can safely be used for dma transfers.
* Its absolute address is 'DmaPhys', the normal address is 'DmaPtr'.
*/
#if (CHIP == INTEL)
unsigned left;
DmaPtr = DmaBuffer;
sys_umap(SELF, D, (vir_bytes)DmaBuffer, (phys_bytes)sizeof(DmaBuffer), &DmaPhys);
if((left = dma_bytes_left(DmaPhys)) < DMA_SIZE) {
/* First half of buffer crosses a 64K boundary, can't DMA into that */
DmaPtr += left;
DmaPhys += left;
}
#else /* CHIP != INTEL */
panic("SB16DSP","init_buffer() failed, CHIP != INTEL", 0);
#endif /* CHIP == INTEL */
}
/*===========================================================================*
* dsp_init
*===========================================================================*/
PRIVATE int dsp_init()
{
int i, s;
if(dsp_reset () != OK) {
dprint("sb16: No SoundBlaster card detected\n");
return -1;
}
DspVersion[0] = DspVersion[1] = 0;
dsp_command(DSP_GET_VERSION); /* Get DSP version bytes */
for(i = 1000; i; i--) {
if(sb16_inb(DSP_DATA_AVL) & 0x80) {
if(DspVersion[0] == 0) {
DspVersion[0] = sb16_inb(DSP_READ);
} else {
DspVersion[1] = sb16_inb(DSP_READ);
break;
}
}
}
if(DspVersion[0] < 4) {
dprint("sb16: No SoundBlaster 16 compatible card detected\n");
return -1;
}
dprint("sb16: SoundBlaster DSP version %d.%d detected\n", DspVersion[0], DspVersion[1]);
/* set SB to use our IRQ and DMA channels */
mixer_set(MIXER_SET_IRQ, (1 << (SB_IRQ / 2 - 1)));
mixer_set(MIXER_SET_DMA, (1 << SB_DMA_8 | 1 << SB_DMA_16));
/* register interrupt vector and enable irq */
if ((s=sys_irqsetpolicy(SB_IRQ, IRQ_REENABLE, &irq_hook_id )) != OK)
panic("SB16DSP", "Couldn't set IRQ policy", s);
if ((s=sys_irqenable(&irq_hook_id)) != OK)
panic("SB16DSP", "Couldn't enable IRQ", s);
DspAvail = 1;
return OK;
}
/*===========================================================================*
* dsp_reset
*===========================================================================*/
PRIVATE int dsp_reset()
{
int i;
sb16_outb(DSP_RESET, 1);
for(i = 0; i < 1000; i++); /* wait a while */
sb16_outb(DSP_RESET, 0);
for(i = 0; i < 1000 && !(sb16_inb(DSP_DATA_AVL) & 0x80); i++);
if(sb16_inb(DSP_READ) != 0xAA) return EIO; /* No SoundBlaster */
DmaBusy = -1;
return OK;
}
/*===========================================================================*
* dsp_command
*===========================================================================*/
PRIVATE int dsp_command(value)
int value;
{
int i, status;
for (i = 0; i < SB_TIMEOUT; i++) {
if((sb16_inb(DSP_STATUS) & 0x80) == 0) {
sb16_outb(DSP_COMMAND, value);
return OK;
}
}
dprint("sb16: SoundBlaster: DSP Command(%x) timeout\n", value);
return -1;
}
/*===========================================================================*
* dsp_set_size
*===========================================================================*/
static int dsp_set_size(size)
unsigned int size;
{
dprint("dsp_set_size(): set fragment size to %u\n", size);
/* Sanity checks */
if(size < DSP_MIN_FRAGMENT_SIZE || size > DSP_MAX_FRAGMENT_SIZE || size % 2 != 0) {
return EINVAL;
}
DspFragmentSize = size;
return OK;
}
/*===========================================================================*
* dsp_set_speed
*===========================================================================*/
static int dsp_set_speed(speed)
unsigned int speed;
{
dprint("sb16: setting speed to %u, stereo = %d\n", speed, DspStereo);
if(speed < DSP_MIN_SPEED || speed > DSP_MAX_SPEED) {
return EPERM;
}
/* Soundblaster 16 can be programmed with real sample rates
* instead of time constants
*
* Since you cannot sample and play at the same time
* we set in- and output rate to the same value
*/
dsp_command(DSP_INPUT_RATE); /* set input rate */
dsp_command(speed >> 8); /* high byte of speed */
dsp_command(speed); /* low byte of speed */
dsp_command(DSP_OUTPUT_RATE); /* same for output rate */
dsp_command(speed >> 8);
dsp_command(speed);
DspSpeed = speed;
return OK;
}
/*===========================================================================*
* dsp_set_stereo
*===========================================================================*/
static int dsp_set_stereo(stereo)
unsigned int stereo;
{
if(stereo) {
DspStereo = 1;
} else {
DspStereo = 0;
}
return OK;
}
/*===========================================================================*
* dsp_set_bits
*===========================================================================*/
static int dsp_set_bits(bits)
unsigned int bits;
{
/* Sanity checks */
if(bits != 8 && bits != 16) {
return EINVAL;
}
DspBits = bits;
return OK;
}
/*===========================================================================*
* dsp_set_sign
*===========================================================================*/
static int dsp_set_sign(sign)
unsigned int sign;
{
dprint("sb16: set sign to %u\n", sign);
DspSign = (sign > 0 ? 1 : 0);
return OK;
}
/*===========================================================================*
* dsp_dma_setup
*===========================================================================*/
PRIVATE void dsp_dma_setup(address, count)
phys_bytes address;
int count;
{
pvb_pair_t pvb[9];
dprint("Setting up %d bit DMA\n", DspBits);
if(DspBits == 8) { /* 8 bit sound */
count--;
pv_set(pvb[0], DMA8_MASK, SB_DMA_8 | 0x04); /* Disable DMA channel */
pv_set(pvb[1], DMA8_CLEAR, 0x00); /* Clear flip flop */
/* set DMA mode */
pv_set(pvb[2], DMA8_MODE, (DmaMode == DEV_WRITE_S ? DMA8_AUTO_PLAY : DMA8_AUTO_REC));
pv_set(pvb[3], DMA8_ADDR, (address >> 0) & 0xff); /* Low_byte of address */
pv_set(pvb[4], DMA8_ADDR, (address >> 8) & 0xff); /* High byte of address */
pv_set(pvb[5], DMA8_PAGE, (address >> 16) & 0xff); /* 64K page number */
pv_set(pvb[6], DMA8_COUNT, (count >> 0) & 0xff); /* Low byte of count */
pv_set(pvb[7], DMA8_COUNT, (count >> 8) & 0xff); /* High byte of count */
pv_set(pvb[8], DMA8_MASK, SB_DMA_8); /* Enable DMA channel */
sys_voutb(pvb, 9);
} else { /* 16 bit sound */
count-= 2;
pv_set(pvb[0], DMA16_MASK, (SB_DMA_16 & 3) | 0x04); /* Disable DMA channel */
pv_set(pvb[1], DMA16_CLEAR, 0x00); /* Clear flip flop */
/* Set dma mode */
pv_set(pvb[2], DMA16_MODE, (DmaMode == DEV_WRITE_S ? DMA16_AUTO_PLAY : DMA16_AUTO_REC));
pv_set(pvb[3], DMA16_ADDR, (address >> 1) & 0xFF); /* Low_byte of address */
pv_set(pvb[4], DMA16_ADDR, (address >> 9) & 0xFF); /* High byte of address */
pv_set(pvb[5], DMA16_PAGE, (address >> 16) & 0xFE); /* 128K page number */
pv_set(pvb[6], DMA16_COUNT, (count >> 1) & 0xff); /* Low byte of count */
pv_set(pvb[7], DMA16_COUNT, (count >> 9) & 0xff); /* High byte of count */
pv_set(pvb[8], DMA16_MASK, SB_DMA_16 & 3); /* Enable DMA channel */
sys_voutb(pvb, 9);
}
}
/*===========================================================================*
* dsp_setup()
*===========================================================================*/
PRIVATE void dsp_setup()
{
/* Set current sample speed */
dsp_set_speed(DspSpeed);
/* Put the speaker on */
if(DmaMode == DEV_WRITE_S) {
dsp_command (DSP_CMD_SPKON); /* put speaker on */
/* Program DSP with dma mode */
dsp_command((DspBits == 8 ? DSP_CMD_8BITAUTO_OUT : DSP_CMD_16BITAUTO_OUT));
} else {
dsp_command (DSP_CMD_SPKOFF); /* put speaker off */
/* Program DSP with dma mode */
dsp_command((DspBits == 8 ? DSP_CMD_8BITAUTO_IN : DSP_CMD_16BITAUTO_IN));
}
/* Program DSP with transfer mode */
if (!DspSign) {
dsp_command((DspStereo == 1 ? DSP_MODE_STEREO_US : DSP_MODE_MONO_US));
} else {
dsp_command((DspStereo == 1 ? DSP_MODE_STEREO_S : DSP_MODE_MONO_S));
}
/* Give length of fragment to DSP */
if (DspBits == 8) { /* 8 bit transfer */
/* #bytes - 1 */
dsp_command((DspFragmentSize - 1) >> 0);
dsp_command((DspFragmentSize - 1) >> 8);
} else { /* 16 bit transfer */
/* #words - 1 */
dsp_command((DspFragmentSize - 1) >> 1);
dsp_command((DspFragmentSize - 1) >> 9);
}
}