ref: 83d4cf3fd1a257df21468f5bb3b4329e5cf8a40f
dir: /u/snd_gus.c/
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
//=============================================================================
// Routines for GUS support in QUAKE
//
// Author(s): Jayeson Lee-Steere
//=============================================================================
#include "quakedef.h"
#include "dosisms.h"
//=============================================================================
// Author(s): Jayeson Lee-Steere
#define INI_STRING_SIZE 0x100
FILE *ini_fopen(const char *filename, const char *modes);
int ini_fclose(FILE *f);
void ini_fgets(FILE *f, const char *section, const char *field, char *s);
// Routines for reading from .INI files
// The read routines are fairly efficient.
//
// Author(s): Jayeson Lee-Steere
#define MAX_SECTION_WIDTH 20
#define MAX_FIELD_WIDTH 20
#define NUM_SECTION_BUFFERS 10
#define NUM_FIELD_BUFFERS 20
struct section_buffer
{
long offset;
char name[MAX_SECTION_WIDTH+1];
};
struct field_buffer
{
long offset;
int section;
char name[MAX_FIELD_WIDTH+1];
};
static FILE *current_file=NULL;
static int current_section;
static int current_section_buffer=0;
static int current_field_buffer=0;
static struct section_buffer section_buffers[NUM_SECTION_BUFFERS];
static struct field_buffer field_buffers[NUM_FIELD_BUFFERS];
//***************************************************************************
// Internal routines
//***************************************************************************
static char toupper(char c)
{
if (c>='a' && c<='z')
c-=('a'-'A');
return(c);
}
static void reset_buffer(FILE *f)
{
int i;
for (i=0;i<NUM_SECTION_BUFFERS;i++)
section_buffers[i].name[0]=0;
for (i=0;i<NUM_FIELD_BUFFERS;i++)
field_buffers[i].name[0]=0;
current_file=f;
}
// Sees if the current string is section "name" (i.e. ["name"]).
// If "name"=="*", sees if the current string is any section
// (i.e. [....]). Returns 1 if true else 0 if false.
static int is_section(char *s,const char *name)
{
int wild=0;
// See if wild search
if (strcmp("*",name)==0)
wild=1;
// Skip leading spaces
while (s[0]==' ')
s++;
// Look for leading "["
if (s[0]!='[')
return(0);
s++;
// Make sure name matches
while (s[0]!=']' && s[0]!=13 && s[0]!=10 && s[0]!=0 && name[0]!=0)
{
if (!wild)
if (toupper(s[0])!=toupper(name[0]))
return(0);
s++;
if (!wild)
name++;
}
if (!wild)
if (name[0]!=0)
return(0);
// Skip trailing spaces
while (s[0]==' ')
s++;
// Make sure we have trailing "]"
if (s[0]!=']')
return(0);
return(1);
}
// Sees if the current string is field "name" (i.e. "name"=...).
// If "name"=="*", sees if the current string is any field
// (i.e. ...=...). Returns 1 if true else 0 if false.
static int is_field(char *s,const char *name)
{
int wild=0;
// See if wild search
if (strcmp("*",name)==0)
wild=1;
// Skip leading spaces
while (s[0]==' ')
s++;
// Make sure name matches
while (s[0]!='=' && s[0]!=13 && s[0]!=10 && s[0]!=0 && name[0]!=0)
{
if (!wild)
if (toupper(s[0])!=toupper(name[0]))
return(0);
s++;
if (!wild)
name++;
}
if (!wild)
if (name[0]!=0)
return(0);
// Skip trailing spaces
while (s[0]==' ')
s++;
// Make sure we have an "="
if (s[0]!='=')
return(0);
return(1);
}
// Extracts the section name from a section heading
// e.g. in="[hey man]" gives out="hey man"
static void get_section_name(char *out, char *in)
{
int i=0;
// Skip spaces before '['
while (in[0]==' ')
in++;
// Make sure there is a '['
if (in[0]!='[')
{
out[0]=0;
return;
}
// Skip past '['
in++;
// Copy string if any to output string.
while (in[0]!=']' && in[0]!=13 && in[0]!=10 && in[0]!=0)
{
if (i<MAX_SECTION_WIDTH)
{
out[i]=in[0];
i++;
}
in++;
}
// Make sure string was terminated with ']'
if (in[0]!=']')
{
out[0]=0;
return;
}
// Remove trailing spaces
while (i>0 && out[i-1]==' ')
i--;
// Null terminate the output string.
out[i]=0;
}
// Extracts the field name from a field line
// e.g. in="sooty=life be in it" gives out="sooty"
static void get_field_name(char *out, char *in)
{
int i=0;
// Skip leading spaces
while (in[0]==' ')
in++;
// Copy name to output string
while (in[0]!='=' && in[0]!=13 && in[0]!=10 && in[0]!=0)
{
if (i<MAX_FIELD_WIDTH)
{
out[i]=in[0];
i++;
}
in++;
}
// Make sure we stopped on "="
if (in[0]!='=')
{
out[0]=0;
return;
}
// Remove trailing spaces
while (i>0 && out[i-1]==' ')
i--;
// Null terminate the output string.
out[i]=0;
}
// Returns the field data from string s.
// e.g. in="wally = golly man" gives out="golly man"
static void get_field_string(char *out, char *in)
{
int i=0;
// Find '=' if it exists
while (in[0]!='=' && in[0]!=13 && in[0]!=10 && in[0]!=0)
in++;
// If there is an '=', skip past it.
if (in[0]=='=')
in++;
// Skip any spaces between the '=' and string.
while (in[0]==' ' || in[0]=='[')
in++;
// Copy string, if there is one, to the output string.
while (in[0]!=13 && in[0]!=10 && in[0]!=0 && i<(INI_STRING_SIZE-1))
{
out[i]=in[0];
in++;
i++;
}
// Null terminate the output string.
out[i]=0;
}
// Adds a section to the buffer
static int add_section(char *instring, long offset)
{
int i;
char section[MAX_SECTION_WIDTH+1];
// Extract section name
get_section_name(section,instring);
// See if section already exists.
for (i=0;i<NUM_SECTION_BUFFERS;i++)
if (stricmp(section,section_buffers[i].name)==0)
return(i);
// Increment current_section_buffer
current_section_buffer++;
if (current_section_buffer>NUM_SECTION_BUFFERS)
current_section_buffer=0;
// Delete any field buffers that correspond to this section
for (i=0;i<NUM_FIELD_BUFFERS;i++)
if (field_buffers[i].section==current_section_buffer)
field_buffers[i].name[0]=0;
// Set buffer information
strcpy(section_buffers[current_section_buffer].name,section);
section_buffers[current_section_buffer].offset=offset;
return(current_section_buffer);
}
// Adds a field to the buffer
static void add_field(char *instring, int section, long offset)
{
int i;
char field[MAX_FIELD_WIDTH+1];
// Extract field name
get_field_name(field,instring);
// See if field already exists
for (i=0;i<NUM_FIELD_BUFFERS;i++)
if (field_buffers[i].section==section)
if (stricmp(field_buffers[i].name,field)==0)
return;
// Increment current_field_buffer
current_field_buffer++;
if (current_field_buffer>NUM_FIELD_BUFFERS)
current_field_buffer=0;
// Set buffer information
strcpy(field_buffers[current_field_buffer].name,field);
field_buffers[current_field_buffer].section=section;
field_buffers[current_field_buffer].offset=offset;
}
// Identical to fgets except the string is trucated at the first ';',
// carriage return or line feed.
static char *stripped_fgets(char *s, int n, FILE *f)
{
int i=0;
if (fgets(s,n,f)==NULL)
return(NULL);
while (s[i]!=';' && s[i]!=13 && s[i]!=10 && s[i]!=0)
i++;
s[i]=0;
return(s);
}
//***************************************************************************
// Externally accessable routines
//***************************************************************************
// Opens an .INI file. Works like fopen
FILE *ini_fopen(const char *filename, const char *modes)
{
return(fopen(filename,modes));
}
// Closes a .INI file. Works like fclose
int ini_fclose(FILE *f)
{
if (f==current_file)
reset_buffer(NULL);
return(fclose(f));
}
// Puts "field" from "section" from .ini file "f" into "s".
// If "section" does not exist or "field" does not exist in
// section then s="";
void ini_fgets(FILE *f, const char *section, const char *field, char *s)
{
int i;
long start_pos,string_start_pos;
char ts[INI_STRING_SIZE*2];
if (f!=current_file)
reset_buffer(f);
// Default to "Not found"
s[0]=0;
// See if section is in buffer
for (i=0;i<NUM_SECTION_BUFFERS;i++)
if (strnicmp(section_buffers[i].name,section,MAX_SECTION_WIDTH)==0)
break;
// If section is in buffer, seek to it if necessary
if (i<NUM_SECTION_BUFFERS)
{
if (i!=current_section)
{
current_section=i;
fseek(f,section_buffers[i].offset,SEEK_SET);
}
}
// else look through .ini file for it.
else
{
// Make sure we are not at eof or this will cause trouble.
if (feof(f))
rewind(f);
start_pos=ftell(f);
while (1)
{
stripped_fgets(ts,INI_STRING_SIZE*2,f);
// If it is a section, add it to the section buffer
if (is_section(ts,"*"))
current_section=add_section(ts,ftell(f));
// If it is the section we are looking for, break.
if (is_section(ts,section))
break;
// If we reach the end of the file, rewind to the start.
if (feof(f))
rewind(f);
if (ftell(f)==start_pos)
return;
}
}
// See if field is in buffer
for (i=0;i<NUM_FIELD_BUFFERS;i++)
if (field_buffers[i].section==current_section)
if (strnicmp(field_buffers[i].name,field,MAX_FIELD_WIDTH)==0)
break;
// If field is in buffer, seek to it and read it
if (i<NUM_FIELD_BUFFERS)
{
fseek(f,field_buffers[i].offset,SEEK_SET);
stripped_fgets(ts,INI_STRING_SIZE*2,f);
get_field_string(s,ts);
}
else
// else search through section for field.
{
// Make sure we do not start at eof or this will cause problems.
if (feof(f))
fseek(f,section_buffers[current_section].offset,SEEK_SET);
start_pos=ftell(f);
while (1)
{
string_start_pos=ftell(f);
stripped_fgets(ts,INI_STRING_SIZE*2,f);
// If it is a field, add it to the buffer
if (is_field(ts,"*"))
add_field(ts,current_section,string_start_pos);
// If it is the field we are looking for, save it
if (is_field(ts,field))
{
get_field_string(s,ts);
break;
}
// If we reach the end of the section, start over
if (feof(f) || is_section(ts,"*"))
fseek(f,section_buffers[current_section].offset,SEEK_SET);
if (ftell(f)==start_pos)
return;
}
}
}
//=============================================================================
#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned long
#define BUFFER_SIZE 4096
#define CODEC_ADC_INPUT_CONTROL_LEFT 0x00
#define CODEC_ADC_INPUT_CONTROL_RIGHT 0x01
#define CODEC_AUX1_INPUT_CONTROL_LEFT 0x02
#define CODEC_AUX1_INPUT_CONTROL_RIGHT 0x03
#define CODEC_AUX2_INPUT_CONTROL_LEFT 0x04
#define CODEC_AUX2_INPUT_CONTROL_RIGHT 0x05
#define CODEC_DAC_OUTPUT_CONTROL_LEFT 0x06
#define CODEC_DAC_OUTPUT_CONTROL_RIGHT 0x07
#define CODEC_FS_FORMAT 0x08
#define CODEC_INTERFACE_CONFIG 0x09
#define CODEC_PIN_CONTROL 0x0A
#define CODEC_ERROR_STATUS_AND_INIT 0x0B
#define CODEC_MODE_AND_ID 0x0C
#define CODEC_LOOPBACK_CONTROL 0x0D
#define CODEC_PLAYBACK_UPPER_BASE_COUNT 0x0E
#define CODEC_PLAYBACK_LOWER_BASE_COUNT 0x0F
#define SET_CONTROL 0x00
#define SET_FREQUENCY 0x01
#define SET_START_HIGH 0x02
#define SET_START_LOW 0x03
#define SET_END_HIGH 0x04
#define SET_END_LOW 0x05
#define SET_VOLUME_RATE 0x06
#define SET_VOLUME_START 0x07
#define SET_VOLUME_END 0x08
#define SET_CURR_VOLUME 0x09
#define SET_VOLUME 0x09
#define SET_ACC_HIGH 0x0A
#define SET_ACC_LOW 0x0B
#define SET_BALANCE 0x0C
#define SET_VOLUME_CONTROL 0x0D
#define SET_VOICES 0x0E
#define DMA_CONTROL 0x41
#define SET_DMA_ADDRESS 0x42
#define SET_DRAM_LOW 0x43
#define SET_DRAM_HIGH 0x44
#define ADLIB_CONTROL 0x45
#define ADLIB_TIMER1 0x46
#define ADLIB_TIMER2 0x47
#define SET_RECORD_RATE 0x48
#define RECORD_CONTROL 0x49
#define SET_JOYSTICK 0x4B
#define MASTER_RESET 0x4C
#define GET_CONTROL 0x80
#define GET_FREQUENCY 0x81
#define GET_START_HIGH 0x82
#define GET_START_LOW 0x83
#define GET_END_HIGH 0x84
#define GET_END_LOW 0x85
#define GET_VOLUME_RATE 0x86
#define GET_VOLUME_START 0x87
#define GET_VOLUME_END 0x88
#define GET_VOLUME 0x89
#define GET_ACC_HIGH 0x8A
#define GET_ACC_LOW 0x8B
#define GET_BALANCE 0x8C
#define GET_VOLUME_CONTROL 0x8D
#define GET_VOICES 0x8E
#define GET_IRQV 0x8F
struct CodecRateStruct
{
WORD Rate;
BYTE FSVal;
};
struct Gf1RateStruct
{
WORD Rate;
BYTE Voices;
};
//=============================================================================
// Reference variables in SND_DOS.C
//=============================================================================
extern short *dma_buffer;
//=============================================================================
// GUS-only variables
//=============================================================================
static BYTE HaveCodec=0;
static WORD CodecRegisterSelect;
static WORD CodecData;
static WORD CodecStatus;
static WORD Gf1TimerControl;
static WORD Gf1PageRegister;
static WORD Gf1RegisterSelect;
static WORD Gf1DataLow;
static WORD Gf1DataHigh;
static BYTE DmaChannel;
static BYTE PageRegs[] = { 0x87, 0x83, 0x81, 0x82, 0x8f, 0x8b, 0x89, 0x8a };
static BYTE AddrRegs[] = { 0, 2, 4, 6, 0xc0, 0xc4, 0xc8, 0xcc };
static BYTE CountRegs[] = { 1, 3, 5, 7, 0xc2, 0xc6, 0xca, 0xce };
static WORD AddrReg;
static WORD CountReg;
static WORD ModeReg;
static WORD DisableReg;
static WORD ClearReg;
static struct CodecRateStruct CodecRates[]=
{
{ 5512,0x01},
{ 6620,0x0F},
{ 8000,0x00},
{ 9600,0x0E},
{11025,0x03},
{16000,0x02},
{18900,0x05},
{22050,0x07},
{27420,0x04},
{32000,0x06},
{33075,0x0D},
{37800,0x09},
{44100,0x0B},
{48000,0x0C},
{ 0,0x00} // End marker
};
static struct Gf1RateStruct Gf1Rates[]=
{
{19293,32},
{19916,31},
{20580,30},
{21289,29},
{22050,28},
{22866,27},
{23746,26},
{24696,25},
{25725,24},
{26843,23},
{28063,22},
{29400,21},
{30870,20},
{32494,19},
{34300,18},
{36317,17},
{38587,16},
{41160,15},
{44100,14},
{0,0}
};
//=============================================================================
// Basic GF1 functions
//=============================================================================
void SetGf18(BYTE reg,BYTE data)
{
dos_outportb(Gf1RegisterSelect,reg);
dos_outportb(Gf1DataHigh,data);
}
void SetGf116(BYTE reg,WORD data)
{
dos_outportb(Gf1RegisterSelect,reg);
dos_outportw(Gf1DataLow,data);
}
BYTE GetGf18(BYTE reg)
{
dos_outportb(Gf1RegisterSelect,reg);
return(dos_inportb(Gf1DataHigh));
}
WORD GetGf116(BYTE reg)
{
dos_outportb(Gf1RegisterSelect,reg);
return(dos_inportw(Gf1DataLow));
}
void Gf1Delay(void)
{
int i;
for (i=0;i<27;i++)
dos_inportb(Gf1TimerControl);
}
DWORD ConvertTo16(DWORD Address)
{
return( ((Address>>1) & 0x0001FFFF) | (Address & 0x000C0000L) );
}
void ClearGf1Ints(void)
{
int i;
SetGf18(DMA_CONTROL,0x00);
SetGf18(ADLIB_CONTROL,0x00);
SetGf18(RECORD_CONTROL,0x00);
GetGf18(DMA_CONTROL);
GetGf18(RECORD_CONTROL);
for (i=0;i<32;i++);
GetGf18(GET_IRQV);
}
//=============================================================================
// Get Interwave (UltraSound PnP) configuration if any
//=============================================================================
static qboolean GUS_GetIWData(void)
{
char *Interwave,s[INI_STRING_SIZE];
FILE *IwFile;
int CodecBase,CodecDma,i;
Interwave=getenv("INTERWAVE");
if (Interwave==NULL)
return(false);
// Open IW.INI
IwFile=ini_fopen(Interwave,"rt");
if (IwFile==NULL)
return(false);
// Read codec base and codec DMA
ini_fgets(IwFile,"setup 0","CodecBase",s);
sscanf(s,"%X",&CodecBase);
ini_fgets(IwFile,"setup 0","DMA2",s);
sscanf(s,"%i",&CodecDma);
ini_fclose(IwFile);
// Make sure numbers OK
if (CodecBase==0 || CodecDma==0)
return(false);
CodecRegisterSelect=CodecBase;
CodecData=CodecBase+1;
CodecStatus=CodecBase+2;
DmaChannel=CodecDma;
// Make sure there is a CODEC at the CODEC base
// Clear any pending IRQs
dos_inportb(CodecStatus);
dos_outportb(CodecStatus,0);
// Wait for 'INIT' bit to clear
for (i=0;i<0xFFFF;i++)
if ((dos_inportb(CodecRegisterSelect) & 0x80) == 0)
break;
if (i==0xFFFF)
return(false);
// Get chip revision - can not be zero
dos_outportb(CodecRegisterSelect,CODEC_MODE_AND_ID);
if ((dos_inportb(CodecRegisterSelect) & 0x7F) != CODEC_MODE_AND_ID)
return(false);
if ((dos_inportb(CodecData) & 0x0F) == 0)
return(false);
HaveCodec=1;
Con_Printf("Sound Card is UltraSound PnP\n");
return(true);
}
//=============================================================================
// Get UltraSound MAX configuration if any
//=============================================================================
static qboolean GUS_GetMAXData(void)
{
char *Ultrasnd,*Ultra16;
int i;
int GusBase,Dma1,Dma2,Irq1,Irq2;
int CodecBase,CodecDma,CodecIrq,CodecType;
BYTE MaxVal;
Ultrasnd=getenv("ULTRASND");
Ultra16=getenv("ULTRA16");
if (Ultrasnd==NULL || Ultra16==NULL)
return(false);
sscanf(Ultrasnd,"%x,%i,%i,%i,%i",&GusBase,&Dma1,&Dma2,&Irq1,&Irq2);
sscanf(Ultra16,"%x,%i,%i,%i",&CodecBase,&CodecDma,&CodecIrq,&CodecType);
if (CodecType==0 && CodecDma!=0)
DmaChannel=CodecDma & 0x07;
else
DmaChannel=Dma2 & 0x07;
// Make sure there is a GUS at GUS base
dos_outportb(GusBase+0x08,0x55);
if (dos_inportb(GusBase+0x0A)!=0x55)
return(false);
dos_outportb(GusBase+0x08,0xAA);
if (dos_inportb(GusBase+0x0A)!=0xAA)
return(false);
// Program CODEC control register
MaxVal=((CodecBase & 0xF0)>>4) | 0x40;
if (Dma1 > 3)
MaxVal|=0x10;
if (Dma2 > 3)
MaxVal|=0x20;
dos_outportb(GusBase+0x106,MaxVal);
CodecRegisterSelect=CodecBase;
CodecData=CodecBase+1;
CodecStatus=CodecBase+2;
// Make sure there is a CODEC at the CODEC base
// Clear any pending IRQs
dos_inportb(CodecStatus);
dos_outportb(CodecStatus,0);
// Wait for 'INIT' bit to clear
for (i=0;i<0xFFFF;i++)
if ((dos_inportb(CodecRegisterSelect) & 0x80) == 0)
break;
if (i==0xFFFF)
return(false);
// Get chip revision - can not be zero
dos_outportb(CodecRegisterSelect,CODEC_MODE_AND_ID);
if ((dos_inportb(CodecRegisterSelect) & 0x7F) != CODEC_MODE_AND_ID)
return(false);
if ((dos_inportb(CodecData) & 0x0F) == 0)
return(false);
HaveCodec=1;
Con_Printf("Sound Card is UltraSound MAX\n");
return(true);
}
//=============================================================================
// Get regular UltraSound configuration if any
//=============================================================================
static qboolean GUS_GetGUSData(void)
{
char *Ultrasnd;
int GusBase,Dma1,Dma2,Irq1,Irq2,i;
Ultrasnd=getenv("ULTRASND");
if (Ultrasnd==NULL)
return(false);
sscanf(Ultrasnd,"%x,%i,%i,%i,%i",&GusBase,&Dma1,&Dma2,&Irq1,&Irq2);
DmaChannel=Dma1 & 0x07;
// Make sure there is a GUS at GUS base
dos_outportb(GusBase+0x08,0x55);
if (dos_inportb(GusBase+0x0A)!=0x55)
return(false);
dos_outportb(GusBase+0x08,0xAA);
if (dos_inportb(GusBase+0x0A)!=0xAA)
return(false);
Gf1TimerControl = GusBase+0x008;
Gf1PageRegister = GusBase+0x102;
Gf1RegisterSelect = GusBase+0x103;
Gf1DataLow = GusBase+0x104;
Gf1DataHigh = GusBase+0x105;
// Reset the GUS
SetGf18(MASTER_RESET,0x00);
Gf1Delay();
Gf1Delay();
SetGf18(MASTER_RESET,0x01);
Gf1Delay();
Gf1Delay();
// Set to max (32) voices
SetGf18(SET_VOICES,0xDF);
// Clear any pending IRQ's
ClearGf1Ints();
// Set all registers to known values
for (i=0;i<32;i++)
{
dos_outportb(Gf1PageRegister,i);
SetGf18(SET_CONTROL,0x03);
SetGf18(SET_VOLUME_CONTROL,0x03);
Gf1Delay();
SetGf18(SET_CONTROL,0x03);
SetGf18(SET_VOLUME_CONTROL,0x03);
SetGf116(SET_START_HIGH,0);
SetGf116(SET_START_LOW,0);
SetGf116(SET_END_HIGH,0);
SetGf116(SET_END_LOW,0);
SetGf116(SET_ACC_HIGH,0);
SetGf116(SET_ACC_LOW,0);
SetGf18(SET_VOLUME_RATE,63);
SetGf18(SET_VOLUME_START,5);
SetGf18(SET_VOLUME_END,251);
SetGf116(SET_VOLUME,5<<8);
}
// Clear any pending IRQ's
ClearGf1Ints();
// Enable DAC etc.
SetGf18(MASTER_RESET,0x07);
// Enable line output so we can hear something
dos_outportb(GusBase,0x08);
HaveCodec=0;
Con_Printf("Sound Card is UltraSound\n");
return(true);
}
//=============================================================================
// Programs the DMA controller to start DMAing in Auto-init mode
//=============================================================================
static void GUS_StartDMA(BYTE DmaChannel,short *dma_buffer,int count)
{
int mode;
int RealAddr;
RealAddr = ptr2real(dma_buffer);
if (DmaChannel <= 3)
{
ModeReg = 0x0B;
DisableReg = 0x0A;
ClearReg = 0x0E;
}
else
{
ModeReg = 0xD6;
DisableReg = 0xD4;
ClearReg = 0xDC;
}
CountReg=CountRegs[DmaChannel];
AddrReg=AddrRegs[DmaChannel];
dos_outportb(DisableReg, DmaChannel | 4); // disable channel
// set mode- see "undocumented pc", p.876
mode = (1<<6) // single-cycle
+(0<<5) // address increment
+(1<<4) // auto-init dma
+(2<<2) // read
+(DmaChannel & 0x03); // channel #
dos_outportb(ModeReg, mode);
// set page
dos_outportb(PageRegs[DmaChannel], RealAddr >> 16);
if (DmaChannel <= 3)
{ // address is in bytes
dos_outportb(0x0C, 0); // prepare to send 16-bit value
dos_outportb(AddrReg, RealAddr & 0xff);
dos_outportb(AddrReg, (RealAddr>>8) & 0xff);
dos_outportb(0x0C, 0); // prepare to send 16-bit value
dos_outportb(CountReg, (count-1) & 0xff);
dos_outportb(CountReg, (count-1) >> 8);
}
else
{ // address is in words
dos_outportb(0xD8, 0); // prepare to send 16-bit value
dos_outportb(AddrReg, (RealAddr>>1) & 0xff);
dos_outportb(AddrReg, (RealAddr>>9) & 0xff);
dos_outportb(0xD8, 0); // prepare to send 16-bit value
dos_outportb(CountReg, ((count>>1)-1) & 0xff);
dos_outportb(CountReg, ((count>>1)-1) >> 8);
}
dos_outportb(ClearReg, 0); // clear write mask
dos_outportb(DisableReg, DmaChannel & ~4);
}
//=============================================================================
// Starts the CODEC playing
//=============================================================================
static void GUS_StartCODEC(int count,BYTE FSVal)
{
int i,j;
// Clear any pending IRQs
dos_inportb(CodecStatus);
dos_outportb(CodecStatus,0);
// Set mode to 2
dos_outportb(CodecRegisterSelect,CODEC_MODE_AND_ID);
dos_outportb(CodecData,0xC0);
// Stop any playback or capture which may be happening
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG);
dos_outportb(CodecData,dos_inportb(CodecData) & 0xFC);
// Set FS
dos_outportb(CodecRegisterSelect,CODEC_FS_FORMAT | 0x40);
dos_outportb(CodecData,FSVal | 0x50); // Or in stereo and 16 bit bits
// Wait a bit
for (i=0;i<10;i++)
dos_inportb(CodecData);
// Routine 1 to counter CODEC bug - wait for init bit to clear and then a
// bit longer (i=min loop count, j=timeout
for (i=0,j=0;i<1000 && j<0x7FFFF;j++)
if ((dos_inportb(CodecRegisterSelect) & 0x80)==0)
i++;
// Routine 2 to counter CODEC bug - this is from Forte's code. For me it
// does not seem to cure the problem, but is added security
// Waits till we can modify index register
for (j=0;j<0x7FFFF;j++)
{
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG | 0x40);
if (dos_inportb(CodecRegisterSelect)==(CODEC_INTERFACE_CONFIG | 0x40))
break;
}
// Perform ACAL
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG | 0x40);
dos_outportb(CodecData,0x08);
// Clear MCE bit - this makes ACAL happen
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG);
// Wait for ACAL to finish
for (j=0;j<0x7FFFF;j++)
{
if ((dos_inportb(CodecRegisterSelect) & 0x80) != 0)
continue;
dos_outportb(CodecRegisterSelect,CODEC_ERROR_STATUS_AND_INIT);
if ((dos_inportb(CodecData) & 0x20) == 0)
break;
}
// Clear ACAL bit
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG | 0x40);
dos_outportb(CodecData,0x00);
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG);
// Set some other junk
dos_outportb(CodecRegisterSelect,CODEC_LOOPBACK_CONTROL);
dos_outportb(CodecData,0x00);
dos_outportb(CodecRegisterSelect,CODEC_PIN_CONTROL);
dos_outportb(CodecData,0x08); // IRQ is disabled in PIN control
// Set count (it doesn't really matter what value we stuff in here
dos_outportb(CodecRegisterSelect,CODEC_PLAYBACK_LOWER_BASE_COUNT);
dos_outportb(CodecData,count & 0xFF);
dos_outportb(CodecRegisterSelect,CODEC_PLAYBACK_UPPER_BASE_COUNT);
dos_outportb(CodecData,count >> 8);
// Start playback
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG);
dos_outportb(CodecData,0x01);
}
//=============================================================================
// Starts the GF1 playing
//=============================================================================
static void GUS_StartGf1(int count,BYTE Voices)
{
DWORD StartAddressL,EndAddressL,StartAddressR,EndAddressR;
// Set number of voices to give us the sampling rate we want
SetGf18(SET_VOICES,0xC0 | (Voices-1));
// Figure out addresses
StartAddressL=ConvertTo16(0);
EndAddressL=ConvertTo16(count-2-2);
StartAddressR=ConvertTo16(2);
EndAddressR=ConvertTo16(count-2);
// Set left voice addresses
dos_outportb(Gf1PageRegister,0);
SetGf116(SET_START_LOW,StartAddressL<<9);
SetGf116(SET_START_HIGH,StartAddressL>>7);
SetGf116(SET_ACC_LOW,StartAddressL<<9);
SetGf116(SET_ACC_HIGH,StartAddressL>>7);
SetGf116(SET_END_LOW,EndAddressL<<9);
SetGf116(SET_END_HIGH,EndAddressL>>7);
// Set balance to full left
SetGf18(SET_BALANCE,0);
// Set volume to full
SetGf116(SET_VOLUME,0xFFF0);
// Set FC to 2 (so we play every second sample)
SetGf116(SET_FREQUENCY,0x0800);
// Set right voice addresses
dos_outportb(Gf1PageRegister,1);
SetGf116(SET_START_LOW,StartAddressR<<9);
SetGf116(SET_START_HIGH,StartAddressR>>7);
SetGf116(SET_ACC_LOW,StartAddressR<<9);
SetGf116(SET_ACC_HIGH,StartAddressR>>7);
SetGf116(SET_END_LOW,EndAddressR<<9);
SetGf116(SET_END_HIGH,EndAddressR>>7);
// Set balance to full right
SetGf18(SET_BALANCE,15);
// Set volume to full
SetGf116(SET_VOLUME,0xFFF0);
// Set FC to 2 (so we play every second sample)
SetGf116(SET_FREQUENCY,0x0800);
// Start voices
dos_outportb(Gf1PageRegister,0);
SetGf18(SET_CONTROL,0x0C);
dos_outportb(Gf1PageRegister,1);
SetGf18(SET_CONTROL,0x0C);
Gf1Delay();
dos_outportb(Gf1PageRegister,0);
SetGf18(SET_CONTROL,0x0C);
dos_outportb(Gf1PageRegister,1);
SetGf18(SET_CONTROL,0x0C);
}
//=============================================================================
// Figures out what kind of UltraSound we have, if any, and starts it playing
//=============================================================================
qboolean GUS_Init(void)
{
int rc;
int RealAddr;
BYTE FSVal,Voices;
struct CodecRateStruct *CodecRate;
struct Gf1RateStruct *Gf1Rate;
// See what kind of UltraSound we have, if any
if (GUS_GetIWData()==false)
if (GUS_GetMAXData()==false)
if (GUS_GetGUSData()==false)
return(false);
shm = &sn;
if (HaveCodec)
{
// do 11khz sampling rate unless command line parameter wants different
shm->speed = 11025;
FSVal = 0x03;
rc = COM_CheckParm("-sspeed");
if (rc)
{
shm->speed = Q_atoi(com_argv[rc+1]);
// Make sure rate not too high
if (shm->speed>48000)
shm->speed=48000;
// Adjust speed to match one of the possible CODEC rates
for (CodecRate=CodecRates;CodecRate->Rate!=0;CodecRate++)
{
if (shm->speed <= CodecRate->Rate)
{
shm->speed=CodecRate->Rate;
FSVal=CodecRate->FSVal;
break;
}
}
}
// Always do 16 bit stereo
shm->channels = 2;
shm->samplebits = 16;
// allocate buffer twice the size we need so we can get aligned buffer
dma_buffer = dos_getmemory(BUFFER_SIZE*2);
if (dma_buffer==NULL)
{
Con_Printf("Couldn't allocate sound dma buffer");
return false;
}
RealAddr = ptr2real(dma_buffer);
RealAddr = (RealAddr + BUFFER_SIZE) & ~(BUFFER_SIZE-1);
dma_buffer = (short *) real2ptr(RealAddr);
// Zero off DMA buffer
memset(dma_buffer, 0, BUFFER_SIZE);
shm->soundalive = true;
shm->splitbuffer = false;
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = (unsigned char *) dma_buffer;
shm->samples = BUFFER_SIZE/(shm->samplebits/8);
GUS_StartDMA(DmaChannel,dma_buffer,BUFFER_SIZE);
GUS_StartCODEC(BUFFER_SIZE,FSVal);
}
else
{
// do 19khz sampling rate unless command line parameter wants different
shm->speed = 19293;
Voices=32;
rc = COM_CheckParm("-sspeed");
if (rc)
{
shm->speed = Q_atoi(com_argv[rc+1]);
// Make sure rate not too high
if (shm->speed>44100)
shm->speed=44100;
// Adjust speed to match one of the possible GF1 rates
for (Gf1Rate=Gf1Rates;Gf1Rate->Rate!=0;Gf1Rate++)
{
if (shm->speed <= Gf1Rate->Rate)
{
shm->speed=Gf1Rate->Rate;
Voices=Gf1Rate->Voices;
break;
}
}
}
// Always do 16 bit stereo
shm->channels = 2;
shm->samplebits = 16;
// allocate buffer twice the size we need so we can get aligned buffer
dma_buffer = dos_getmemory(BUFFER_SIZE*2);
if (dma_buffer==NULL)
{
Con_Printf("Couldn't allocate sound dma buffer");
return false;
}
RealAddr = ptr2real(dma_buffer);
RealAddr = (RealAddr + BUFFER_SIZE) & ~(BUFFER_SIZE-1);
dma_buffer = (short *) real2ptr(RealAddr);
// Zero off DMA buffer
memset(dma_buffer, 0, BUFFER_SIZE);
shm->soundalive = true;
shm->splitbuffer = false;
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = (unsigned char *) dma_buffer;
shm->samples = BUFFER_SIZE/(shm->samplebits/8);
GUS_StartDMA(DmaChannel,dma_buffer,BUFFER_SIZE);
SetGf116(SET_DMA_ADDRESS,0x0000);
if (DmaChannel<=3)
SetGf18(DMA_CONTROL,0x41);
else
SetGf18(DMA_CONTROL,0x45);
GUS_StartGf1(BUFFER_SIZE,Voices);
}
return(true);
}
//=============================================================================
// Returns the current playback position
//=============================================================================
int GUS_GetDMAPos(void)
{
int count;
if (HaveCodec)
{
// clear 16-bit reg flip-flop
// load the current dma count register
if (DmaChannel < 4)
{
dos_outportb(0x0C, 0);
count = dos_inportb(CountReg);
count += dos_inportb(CountReg) << 8;
if (shm->samplebits == 16)
count /= 2;
count = shm->samples - (count+1);
}
else
{
dos_outportb(0xD8, 0);
count = dos_inportb(CountReg);
count += dos_inportb(CountReg) << 8;
if (shm->samplebits == 8)
count *= 2;
count = shm->samples - (count+1);
}
}
else
{
// Read current position from GF1
dos_outportb(Gf1PageRegister,0);
count=(GetGf116(GET_ACC_HIGH)<<7) & 0xFFFF;
// See which half of buffer we are in. Note that since this is 16 bit
// data we are playing, position is in 16 bit samples
if (GetGf18(DMA_CONTROL) & 0x40)
{
GUS_StartDMA(DmaChannel,dma_buffer,BUFFER_SIZE);
SetGf116(SET_DMA_ADDRESS,0x0000);
if (DmaChannel<=3)
SetGf18(DMA_CONTROL,0x41);
else
SetGf18(DMA_CONTROL,0x45);
}
}
shm->samplepos = count & (shm->samples-1);
return(shm->samplepos);
}
//=============================================================================
// Stops the UltraSound playback
//=============================================================================
void GUS_Shutdown (void)
{
if (HaveCodec)
{
// Stop CODEC
dos_outportb(CodecRegisterSelect,CODEC_INTERFACE_CONFIG);
dos_outportb(CodecData,0x01);
}
else
{
// Stop Voices
dos_outportb(Gf1PageRegister,0);
SetGf18(SET_CONTROL,0x03);
dos_outportb(Gf1PageRegister,1);
SetGf18(SET_CONTROL,0x03);
Gf1Delay();
dos_outportb(Gf1PageRegister,0);
SetGf18(SET_CONTROL,0x03);
dos_outportb(Gf1PageRegister,1);
SetGf18(SET_CONTROL,0x03);
// Stop any DMA
SetGf18(DMA_CONTROL,0x00);
GetGf18(DMA_CONTROL);
}
dos_outportb(DisableReg, DmaChannel | 4); // disable dma channel
}