static int
MINTSTFA_Init(SDL_AudioDriverImpl * impl)
{
/* Cookie _MCH present ? if not, assume ST machine */
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
cookie_mch = MCH_ST;
}
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
/* Cookie STFA present ? */
if (Getcookie(C_STFA, (long *) &cookie_stfa) != C_FOUND) {
SDL_SetError(DEBUG_NAME "no STFA audio");
return (0);
}
SDL_MintAudio_stfa = cookie_stfa;
DEBUG_PRINT((DEBUG_NAME "STFA audio available!\n"));
/* Set the function pointers */
impl->OpenDevice = MINTSTFA_OpenDevice;
impl->CloseDevice = MINTSTFA_CloseDevice;
impl->LockDevice = MINTSTFA_LockDevice;
impl->UnlockDevice = MINTSTFA_UnlockDevice;
impl->OnlyHasDefaultOutputDevice = 1;
impl->ProvidesOwnCallbackThread = 1;
impl->SkipMixerLock = 1;
return 2; /* 2 == definitely has an audio device. */
}
static int Audio_Available(void)
{
long dummy;
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
/* Check if user asked a different audio driver */
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return(0);
}
/* Cookie _MCH present ? if not, assume ST machine */
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
cookie_mch = MCH_ST;
}
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
/* Cookie STFA present ? */
if (Getcookie(C_STFA, &dummy) != C_FOUND) {
DEBUG_PRINT((DEBUG_NAME "no STFA audio\n"));
return(0);
}
cookie_stfa = (cookie_stfa_t *) dummy;
DEBUG_PRINT((DEBUG_NAME "STFA audio available!\n"));
return(1);
}
long scsidrv_init(void)
{
if (Getcookie(C_SCSI, (unsigned long *)&cookie_scsi) != C_FOUND) {
return -ENOSYS;
}
return 0;
}
void atari_test_cpu060_present(void)
{
unsigned long cookie_cpu;
atari_cpu060_avail=0;
/* Cookie _CPU present ? */
if (Getcookie(C__CPU, &cookie_cpu) == C_FOUND) {
atari_cpu060_avail = (cookie_cpu == 60);
}
}
static int Audio_Available(void)
{
const char *envr = getenv("SDL_AUDIODRIVER");
/* Check if user asked a different audio driver */
if ((envr) && (strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return(0);
}
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
/* Check if we have 16 bits audio */
if ((cookie_snd & SND_16BIT)==0) {
DEBUG_PRINT((DEBUG_NAME "no 16 bits sound\n"));
return(0);
}
/* Cookie GSXB present ? */
cookie_gsxb = (Getcookie(C_GSXB, &cookie_gsxb) == C_FOUND);
/* Is it GSXB ? */
if (((cookie_snd & SND_GSXB)==0) || (cookie_gsxb==0)) {
DEBUG_PRINT((DEBUG_NAME "no GSXB audio\n"));
return(0);
}
/* Check if audio is lockable */
if (Locksnd()!=1) {
DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
return(0);
}
Unlocksnd();
DEBUG_PRINT((DEBUG_NAME "GSXB audio available!\n"));
return(1);
}
static int Audio_Available(void)
{
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return(0);
}
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
if ((cookie_snd & SND_16BIT)==0) {
DEBUG_PRINT((DEBUG_NAME "no 16 bits sound\n"));
return(0);
}
cookie_gsxb = (Getcookie(C_GSXB, &cookie_gsxb) == C_FOUND);
if (((cookie_snd & SND_GSXB)==0) || (cookie_gsxb==0)) {
DEBUG_PRINT((DEBUG_NAME "no GSXB audio\n"));
return(0);
}
if (Locksnd()!=1) {
DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
return(0);
}
Unlocksnd();
DEBUG_PRINT((DEBUG_NAME "GSXB audio available!\n"));
return(1);
}
static int Audio_Available(void)
{
unsigned long dummy;
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
/*SDL_MintAudio_mint_present = (Getcookie(C_MiNT, &dummy) == C_FOUND);*/
SDL_MintAudio_mint_present = SDL_FALSE;
/* We can't use XBIOS in interrupt with Magic, don't know about thread */
if (Getcookie(C_MagX, &dummy) == C_FOUND) {
return(0);
}
/* Check if user asked a different audio driver */
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return(0);
}
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
/* Check if we have 16 bits audio */
if ((cookie_snd & SND_16BIT)==0) {
DEBUG_PRINT((DEBUG_NAME "no 16 bits sound\n"));
return(0);
}
/* Check if audio is lockable */
if (Locksnd()!=1) {
DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
return(0);
}
Unlocksnd();
DEBUG_PRINT((DEBUG_NAME "XBIOS audio available!\n"));
return(1);
}
static void Atari_InitializeEvents(_THIS)
{
const char *envr;
unsigned long cookie_mch;
/* Test if we are on an Atari machine or not */
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
cookie_mch = 0;
}
cookie_mch >>= 16;
/* Default is Ikbd, the faster except for clones */
switch(cookie_mch) {
case MCH_ST:
case MCH_STE:
case MCH_TT:
case MCH_F30:
case MCH_ARANYM:
this->InitOSKeymap=AtariIkbd_InitOSKeymap;
this->PumpEvents=AtariIkbd_PumpEvents;
Atari_ShutdownEvents=AtariIkbd_ShutdownEvents;
break;
default:
this->InitOSKeymap=AtariGemdos_InitOSKeymap;
this->PumpEvents=AtariGemdos_PumpEvents;
Atari_ShutdownEvents=AtariGemdos_ShutdownEvents;
break;
}
envr = SDL_getenv("SDL_ATARI_EVENTSDRIVER");
if (!envr) {
return;
}
if (SDL_strcmp(envr, "ikbd") == 0) {
this->InitOSKeymap=AtariIkbd_InitOSKeymap;
this->PumpEvents=AtariIkbd_PumpEvents;
Atari_ShutdownEvents=AtariIkbd_ShutdownEvents;
}
if (SDL_strcmp(envr, "gemdos") == 0) {
this->InitOSKeymap=AtariGemdos_InitOSKeymap;
this->PumpEvents=AtariGemdos_PumpEvents;
Atari_ShutdownEvents=AtariGemdos_ShutdownEvents;
}
if (SDL_strcmp(envr, "bios") == 0) {
this->InitOSKeymap=AtariBios_InitOSKeymap;
this->PumpEvents=AtariBios_PumpEvents;
Atari_ShutdownEvents=AtariBios_ShutdownEvents;
}
}
static int Audio_Available(void)
{
const char *envr = SDL_getenv("SDL_AUDIODRIVER");
/* Check if user asked a different audio driver */
if ((envr) && (SDL_strcmp(envr, MINT_AUDIO_DRIVER_NAME)!=0)) {
DEBUG_PRINT((DEBUG_NAME "user asked a different audio driver\n"));
return 0;
}
/* Cookie _MCH present ? if not, assume ST machine */
if (Getcookie(C__MCH, &cookie_mch) == C_NOTFOUND) {
cookie_mch = MCH_ST;
}
/* Cookie _SND present ? if not, assume ST machine */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
cookie_snd = SND_PSG;
}
/* Check if we have 8 bits audio */
if ((cookie_snd & SND_8BIT)==0) {
DEBUG_PRINT((DEBUG_NAME "no 8 bits sound\n"));
return(0);
}
/* Check if audio is lockable */
if (cookie_snd & SND_16BIT) {
if (Locksnd()!=1) {
DEBUG_PRINT((DEBUG_NAME "audio locked by other application\n"));
return(0);
}
Unlocksnd();
}
DEBUG_PRINT((DEBUG_NAME "8 bits audio available!\n"));
return(1);
}
void SDL_StartTicks(void)
{
void *old_stack;
unsigned long dummy;
/* Set first ticks value */
old_stack = (void *)Super(0);
start = *((volatile long *)_hz_200);
Super(old_stack);
start *= 5; /* One _hz_200 tic is 5ms */
mint_present = (Getcookie(C_MiNT, &dummy) == C_FOUND);
}
void AtariGemdos_InitOSKeymap(_THIS)
{
int i, vectors_mask;
unsigned long dummy;
SDL_memset(gemdos_currentkeyboard, 0, sizeof(gemdos_currentkeyboard));
SDL_memset(gemdos_previouskeyboard, 0, sizeof(gemdos_previouskeyboard));
/* Initialize keymap */
for ( i=0; i<sizeof(keymap); i++ )
keymap[i] = SDLK_UNKNOWN;
/* Functions keys */
for ( i = 0; i<10; i++ )
keymap[SCANCODE_F1 + i] = SDLK_F1+i;
/* Cursor keypad */
keymap[SCANCODE_HELP] = SDLK_HELP;
keymap[SCANCODE_UNDO] = SDLK_UNDO;
keymap[SCANCODE_INSERT] = SDLK_INSERT;
keymap[SCANCODE_CLRHOME] = SDLK_HOME;
keymap[SCANCODE_UP] = SDLK_UP;
keymap[SCANCODE_DOWN] = SDLK_DOWN;
keymap[SCANCODE_RIGHT] = SDLK_RIGHT;
keymap[SCANCODE_LEFT] = SDLK_LEFT;
/* Special keys */
keymap[SCANCODE_ESCAPE] = SDLK_ESCAPE;
keymap[SCANCODE_BACKSPACE] = SDLK_BACKSPACE;
keymap[SCANCODE_TAB] = SDLK_TAB;
keymap[SCANCODE_ENTER] = SDLK_RETURN;
keymap[SCANCODE_DELETE] = SDLK_DELETE;
keymap[SCANCODE_LEFTCONTROL] = SDLK_LCTRL;
keymap[SCANCODE_LEFTSHIFT] = SDLK_LSHIFT;
keymap[SCANCODE_RIGHTSHIFT] = SDLK_RSHIFT;
keymap[SCANCODE_LEFTALT] = SDLK_LALT;
keymap[SCANCODE_CAPSLOCK] = SDLK_CAPSLOCK;
use_dev_mouse = (SDL_AtariDevMouse_Open()!=0) ? SDL_TRUE : SDL_FALSE;
vectors_mask = ATARI_XBIOS_JOYSTICKEVENTS; /* XBIOS joystick events */
if (!use_dev_mouse) {
vectors_mask |= ATARI_XBIOS_MOUSEEVENTS; /* XBIOS mouse events */
}
if (Getcookie(C_MiNT, &dummy)==C_FOUND) {
vectors_mask = 0;
}
SDL_AtariXbios_InstallVectors(vectors_mask);
}
static void listModes(_THIS, int actually_add)
{
long cookie_scpn;
scpn_screeninfo_t *scrinfo;
xbiosmode_t modeinfo;
if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
scrinfo = ((scpn_cookie_t *) cookie_scpn)->screen_info;
if (actually_add) {
scrinfo->h_pos = scrinfo->v_pos = 0;
}
modeinfo.number = -1;
modeinfo.width = scrinfo->virtual_width;
modeinfo.height = scrinfo->virtual_height;
modeinfo.depth = 1<<(SDL_XBIOS_scpn_planes_device[scrinfo->device]);
modeinfo.flags = (modeinfo.depth == 8 ? XBIOSMODE_C2P : 0);
SDL_XBIOS_AddMode(this, actually_add, &modeinfo);
}
}
/* exported interface documented in atari/osspec.h */
int tos_getcookie(long tag, long * value)
{
COOKIE * cptr;
if( atari_sysinfo.gemdos_version > TOS4VER ) {
return( Getcookie(tag, value) );
}
cptr = (COOKIE*)Setexc(0x0168, -1L);
if(cptr != NULL) {
do {
if( cptr->c == tag ) {
if(cptr->v != 0 ) {
if( value != NULL ) {
*value = cptr->v;
}
return( C_FOUND );
}
}
} while( (cptr++)->c != 0L );
}
return( C_NOTFOUND );
}
static void Detect_Machine(void)
{
long machine_type;
/* Get machine type with '_MCH' cookie */
if(Getcookie(C__MCH, &machine_type) == C_FOUND) {
switch(machine_type >> 16) {
case 0:
s_machine_type = MCH_ST;
break;
case 1:
s_machine_type = MCH_STE;
break;
case 2:
s_machine_type = MCH_TT;
break;
case 3:
s_machine_type = MCH_FALCON;
break;
default:
s_machine_type = MCH_OTHER;
}
Debug("_MCH cookie value : %08lx\n", machine_type);
} else {
static void Mint_CheckExternalClock(_THIS)
{
#define SIZE_BUF_CLOCK_MEASURE (44100/10)
unsigned long cookie_snd;
char *buffer;
int i, j;
/* DSP present with its GPIO port ? */
if (Getcookie(C__SND, &cookie_snd) == C_NOTFOUND) {
return;
}
if ((cookie_snd & SND_DSP)==0) {
return;
}
buffer = Atari_SysMalloc(SIZE_BUF_CLOCK_MEASURE, MX_STRAM);
if (buffer==NULL) {
DEBUG_PRINT((DEBUG_NAME "Not enough memory for the measure\n"));
return;
}
SDL_memset(buffer, 0, SIZE_BUF_CLOCK_MEASURE);
Buffoper(0);
Settracks(0,0);
Setmontracks(0);
Setmode(MONO8);
Jdisint(MFP_TIMERA);
for (i=0; i<2; i++) {
Gpio(GPIO_SET,7); /* DSP port gpio outputs */
Gpio(GPIO_WRITE,2+i); /* 22.5792/24.576 MHz for 44.1/48KHz */
Devconnect2(DMAPLAY, DAC, CLKEXT, CLK50K); /* Matrix and clock source */
Setbuffer(0, buffer, buffer + SIZE_BUF_CLOCK_MEASURE); /* Set buffer */
Xbtimer(XB_TIMERA, 5, 38, SDL_MintAudio_XbiosInterruptMeasureClock); /* delay mode timer A, prediv /64, 1KHz */
Jenabint(MFP_TIMERA);
SDL_MintAudio_clocktics = 0;
Buffoper(SB_PLA_ENA);
usleep(110000);
if((Buffoper(-1) & 1)==0) {
if (SDL_MintAudio_clocktics) {
unsigned long khz;
khz = ((SIZE_BUF_CLOCK_MEASURE/SDL_MintAudio_clocktics) +1) & 0xFFFFFFFE;
DEBUG_PRINT((DEBUG_NAME "measure %d: freq=%lu KHz\n", i+1, khz));
if(khz==44) {
for (j=1; j<4; j++) {
SDL_MintAudio_AddFrequency(this, MASTERCLOCK_44K/(MASTERPREDIV_FALCON*(1<<j)), MASTERCLOCK_44K, (1<<j)-1, 2+i);
}
} else if (khz==48) {
for (j=1; j<4; j++) {
SDL_MintAudio_AddFrequency(this, MASTERCLOCK_48K/(MASTERPREDIV_FALCON*(1<<j)), MASTERCLOCK_48K, (1<<j)-1, 2+i);
}
}
} else {
DEBUG_PRINT((DEBUG_NAME "No measure\n"));
}
} else {
DEBUG_PRINT((DEBUG_NAME "No SDMA clock\n"));
}
Buffoper(0); /* stop */
Jdisint(MFP_TIMERA); /* Uninstall interrupt */
}
Mfree(buffer);
}
static void VDI_ReadExtInfo(_THIS, short *work_out)
{
unsigned long EdDI_version;
long cookie_EdDI;
Uint16 clut_type;
if (Getcookie(C_EdDI, &cookie_EdDI) == C_NOTFOUND) {
return;
}
EdDI_version = Atari_get_EdDI_version( (void *)cookie_EdDI);
vq_scrninfo(VDI_handle, work_out);
VDI_format = work_out[0];
clut_type = work_out[1];
if (EdDI_version >= EDDI_11) {
VDI_pitch = work_out[5];
VDI_screen = (void *) *((unsigned long *) &work_out[6]);
}
switch(clut_type) {
case VDI_CLUT_HARDWARE:
{
int i;
Uint16 *tmp_p;
tmp_p = (Uint16 *)&work_out[16];
for (i=0;i<256;i++) {
vdi_index[*tmp_p++] = i;
}
}
break;
case VDI_CLUT_SOFTWARE:
{
int component;
int num_bit;
unsigned short *tmp_p;
tmp_p = (unsigned short *) &work_out[16];
for (component=0;component<5;component++) {
for (num_bit=0;num_bit<16;num_bit++) {
unsigned short valeur;
valeur = *tmp_p++;
if (valeur == 0xffff) {
continue;
}
switch(component) {
case 0:
VDI_redmask |= 1<< valeur;
break;
case 1:
VDI_greenmask |= 1<< valeur;
break;
case 2:
VDI_bluemask |= 1<< valeur;
break;
case 3:
VDI_alphamask |= 1<< valeur;
break;
}
}
}
}
if ((VDI_greenmask == ((7<<13)|3)) || (VDI_greenmask == ((7<<13)|7))) {
VDI_greenmask &= ~(7<<13);
}
break;
case VDI_CLUT_NONE:
break;
}
}
static void VDI_ReadExtInfo(_THIS, short *work_out)
{
unsigned long EdDI_version;
unsigned long cookie_EdDI;
Uint32 num_colours;
Uint16 clut_type, num_bits;
/* Read EdDI informations */
if (Getcookie(C_EdDI, &cookie_EdDI) == C_NOTFOUND) {
return;
}
EdDI_version = Atari_get_EdDI_version( (void *)cookie_EdDI);
vq_scrninfo(VDI_handle, work_out);
VDI_format = work_out[0];
clut_type = work_out[1];
num_bits = work_out[2];
num_colours = *((Uint32 *) &work_out[3]);
/* With EdDI>=1.1, we can have screen pitch, address and format
* so we can directly write to screen without using vro_cpyfm
*/
if (EdDI_version >= EDDI_11) {
VDI_pitch = work_out[5];
VDI_screen = (void *) *((unsigned long *) &work_out[6]);
switch(num_colours) {
case 32768UL:
if (work_out[14] & (1<<7)) {
/* Little endian */
if (work_out[14] & (1<<1)) {
/* Falcon */
VDI_alphamask = 1 << 13;
VDI_redmask = 31 << 3;
VDI_greenmask = (3 << 14) | 7;
VDI_bluemask = 31 << 8;
} else {
/* Others */
VDI_alphamask = 1 << 7;
VDI_redmask = 31 << 2;
VDI_greenmask = (7 << 13) | 3;
VDI_bluemask = 31 << 8;
}
} else {
/* Big endian */
if (work_out[14] & (1<<1)) {
/* Falcon */
VDI_alphamask = 1 << 5;
VDI_redmask = 31 << 11;
VDI_greenmask = 31 << 6;
VDI_bluemask = 31;
} else {
/* Others */
VDI_alphamask = 1 << 15;
VDI_redmask = 31 << 10;
VDI_greenmask = 31 << 5;
VDI_bluemask = 31;
}
}
break;
case 65536UL:
if (work_out[14] & (1<<7)) {
/* Little endian */
VDI_alphamask = 0;
VDI_redmask = 31 << 3;
VDI_greenmask = (7 << 13) | 7;
VDI_bluemask = 31 << 8;
} else {
/* Big endian */
VDI_alphamask = 0;
VDI_redmask = 31 << 11;
VDI_greenmask = 63 << 5;
VDI_bluemask = 31;
}
break;
case 16777216UL:
if (work_out[14] & (1<<7)) {
/* Little endian */
switch(num_bits) {
case 24:
VDI_alphamask = 0;
VDI_redmask = 255;
VDI_greenmask = 255 << 8;
VDI_bluemask = 255 << 16;
break;
case 32:
VDI_alphamask = 255;
VDI_redmask = 255 << 8;
VDI_greenmask = 255 << 16;
VDI_bluemask = 255 << 24;
break;
}
} else {
/* Big endian */
switch(num_bits) {
case 24:
VDI_alphamask = 0;
VDI_redmask = 255 << 16;
VDI_greenmask = 255 << 8;
VDI_bluemask = 255;
break;
case 32:
VDI_alphamask = 255 << 24;
VDI_redmask = 255 << 16;
VDI_greenmask = 255 << 8;
VDI_bluemask = 255;
break;
}
}
break;
}
}
switch(clut_type) {
case VDI_CLUT_HARDWARE:
{
int i;
Uint16 *tmp_p;
tmp_p = (Uint16 *)&work_out[16];
for (i=0; i<256; i++) {
vdi_index[*tmp_p++] = i;
}
}
break;
case VDI_CLUT_SOFTWARE:
if (EdDI_version < EDDI_11) {
int component; /* red, green, blue, alpha, overlay */
int num_bit;
unsigned short *tmp_p;
/* We can build masks with info here */
tmp_p = (unsigned short *) &work_out[16];
for (component=0; component<5; component++) {
for (num_bit=0; num_bit<16; num_bit++) {
unsigned short valeur;
valeur = *tmp_p++;
if (valeur == 0xffff) {
continue;
}
switch(component) {
case 0:
VDI_redmask |= 1<< valeur;
break;
case 1:
VDI_greenmask |= 1<< valeur;
break;
case 2:
VDI_bluemask |= 1<< valeur;
break;
case 3:
VDI_alphamask |= 1<< valeur;
break;
}
}
}
}
/* Remove lower green bits for Intel endian screen */
if ((VDI_greenmask == ((7<<13)|3)) || (VDI_greenmask == ((7<<13)|7))) {
VDI_greenmask &= ~(7<<13);
}
break;
case VDI_CLUT_NONE:
break;
}
}
int SDL_XBIOS_TveillePresent(_THIS)
{
return (Getcookie(C_VeiL, (unsigned long *)&cookie_veil) == C_FOUND);
}
