static void
speccyboot_reset( int hard_reset GCC_UNUSED )
{
static int tap_opened = 0;
speccyboot_rom_active = 0;
if( !periph_is_active( PERIPH_TYPE_SPECCYBOOT ) )
return;
if( machine_load_rom_bank( speccyboot_memory_map_romcs, 0,
settings_current.rom_speccyboot,
settings_default.rom_speccyboot, 0x2000 ) )
return;
out_register_state = 0xff; /* force transitions to low */
speccyboot_register_write( 0, 0 );
/*
* Open TAP. If this fails, SpeccyBoot emulation won't work.
*
* This is done here rather than in speccyboot_init() to ensure any
* error messages are only displayed if SpeccyBoot emulation is
* actually requested.
*/
if( !tap_opened ) {
nic_enc28j60_init( nic );
tap_opened = 1;
}
}
static void
opus_reset( int hard_reset )
{
int i;
opus_active = 0;
opus_available = 0;
if( !periph_is_active( PERIPH_TYPE_OPUS ) ) {
return;
}
if( machine_load_rom_bank( opus_memory_map_romcs_rom, 0,
settings_current.rom_opus,
settings_default.rom_opus, 0x2000 ) ) {
settings_current.opus = 0;
periph_activate_type( PERIPH_TYPE_OPUS, 0 );
return;
}
for( i = 0; i < MEMORY_PAGES_IN_2K; i++ ) {
struct memory_page *page =
&opus_memory_map_romcs_ram[ i ];
page->page = opus_ram + i * MEMORY_PAGE_SIZE;
page->offset = i * MEMORY_PAGE_SIZE;
}
machine_current->ram.romcs = 0;
for( i = 0; i < MEMORY_PAGES_IN_2K; i++ )
opus_memory_map_romcs_ram[ i ].writable = 1;
data_reg_a = 0;
data_dir_a = 0;
control_a = 0;
data_reg_b = 0;
data_dir_b = 0;
control_b = 0;
opus_available = 1;
if( hard_reset )
memset( opus_ram, 0, sizeof( opus_ram ) );
wd_fdc_master_reset( opus_fdc );
for( i = 0; i < OPUS_NUM_DRIVES; i++ ) {
ui_media_drive_update_menus( &opus_ui_drives[ i ],
UI_MEDIA_DRIVE_UPDATE_ALL );
}
opus_fdc->current_drive = &opus_drives[ 0 ];
fdd_select( &opus_drives[ 0 ], 1 );
machine_current->memory_map();
ui_statusbar_update( UI_STATUSBAR_ITEM_DISK, UI_STATUSBAR_STATE_INACTIVE );
}
/*
* sound_specdrum_write - very simple routine
* as the output is already a digitized waveform
*/
void
sound_specdrum_write( libspectrum_word port GCC_UNUSED, libspectrum_byte val )
{
if( periph_is_active( PERIPH_TYPE_SPECDRUM ) ) {
blip_synth_update( left_specdrum_synth, tstates, ( val - 128) * 128);
if( right_specdrum_synth ) {
blip_synth_update( right_specdrum_synth, tstates, ( val - 128) * 128);
}
machine_current->specdrum.specdrum_dac = val - 128;
}
}
static void
didaktik_reset( int hard_reset )
{
int i;
didaktik80_active = 0;
didaktik80_available = 0;
ui_menu_activate( UI_MENU_ITEM_MACHINE_DIDAKTIK80_SNAP, 0 );
if( !periph_is_active( PERIPH_TYPE_DIDAKTIK80 ) ) {
return;
}
if( machine_load_rom_bank( didaktik_memory_map_romcs_rom, 0,
settings_current.rom_didaktik80,
settings_default.rom_didaktik80, ROM_SIZE ) ) {
settings_current.didaktik80 = 0;
periph_activate_type( PERIPH_TYPE_DIDAKTIK80, 0 );
return;
}
ui_menu_activate( UI_MENU_ITEM_MACHINE_DIDAKTIK80_SNAP, 1 );
for( i = 0; i < MEMORY_PAGES_IN_2K; i++ ) {
struct memory_page *page =
&didaktik_memory_map_romcs_ram[ i ];
page->page = ram + i * MEMORY_PAGE_SIZE;
page->offset = i * MEMORY_PAGE_SIZE;
page->writable = 1;
}
machine_current->ram.romcs = 0;
aux_register = 0;
didaktik80_available = 1;
if( hard_reset )
memset( ram, 0, sizeof( ram ) );
wd_fdc_master_reset( didaktik_fdc );
for( i = 0; i < DIDAKTIK80_NUM_DRIVES; i++ ) {
ui_media_drive_update_menus( &didaktik_ui_drives[ i ],
UI_MEDIA_DRIVE_UPDATE_ALL );
}
didaktik_fdc->current_drive = &didaktik_drives[ 0 ];
fdd_select( &didaktik_drives[ 0 ], 1 );
fdd_select( &didaktik_drives[ 1 ], 0 );
machine_current->memory_map();
}
static void
plusd_reset( int hard_reset )
{
int i;
plusd_active = 0;
plusd_available = 0;
if( !periph_is_active( PERIPH_TYPE_PLUSD ) ) {
return;
}
if( machine_load_rom_bank( plusd_memory_map_romcs_rom, 0,
settings_current.rom_plusd,
settings_default.rom_plusd, 0x2000 ) ) {
settings_current.plusd = 0;
periph_activate_type( PERIPH_TYPE_PLUSD, 0 );
return;
}
machine_current->ram.romcs = 0;
for( i = 0; i < MEMORY_PAGES_IN_8K; i++ ) {
plusd_memory_map_romcs_ram[ i ].page = &plusd_ram[ i * MEMORY_PAGE_SIZE ];
plusd_memory_map_romcs_ram[ i ].writable = 1;
}
plusd_available = 1;
plusd_active = 1;
if( hard_reset )
memset( plusd_ram, 0, 0x2000 );
wd_fdc_master_reset( plusd_fdc );
for( i = 0; i < PLUSD_NUM_DRIVES; i++ ) {
ui_media_drive_update_menus( &plusd_ui_drives[ i ],
UI_MEDIA_DRIVE_UPDATE_ALL );
}
plusd_fdc->current_drive = &plusd_drives[ 0 ];
fdd_select( &plusd_drives[ 0 ], 1 );
machine_current->memory_map();
ui_statusbar_update( UI_STATUSBAR_ITEM_DISK, UI_STATUSBAR_STATE_INACTIVE );
}
static void
didaktik_to_snapshot( libspectrum_snap *snap )
{
libspectrum_byte *buffer;
int drive_count = 0;
int i;
size_t memory_length;
if( !periph_is_active( PERIPH_TYPE_DIDAKTIK80 ) ) return;
libspectrum_snap_set_didaktik80_active( snap, 1 );
memory_length = ROM_SIZE;
libspectrum_snap_set_didaktik80_custom_rom( snap, 1 );
libspectrum_snap_set_didaktik80_rom_length( snap, 0, memory_length );
buffer = libspectrum_new( libspectrum_byte, memory_length );
for( i = 0; i < MEMORY_PAGES_IN_14K; i++ )
memcpy( buffer + i * MEMORY_PAGE_SIZE,
didaktik_memory_map_romcs_rom[ i ].page, MEMORY_PAGE_SIZE );
libspectrum_snap_set_didaktik80_rom( snap, 0, buffer );
memory_length = RAM_SIZE;
buffer = libspectrum_new( libspectrum_byte, memory_length );
for( i = 0; i < MEMORY_PAGES_IN_2K; i++ )
memcpy( buffer + i * MEMORY_PAGE_SIZE,
didaktik_memory_map_romcs_ram[ i ].page, MEMORY_PAGE_SIZE );
libspectrum_snap_set_didaktik80_ram( snap, 0, buffer );
drive_count++; /* Drive 1 is not removable */
if( option_enumerate_diskoptions_drive_didaktik80b_type() > 0 ) drive_count++;
libspectrum_snap_set_didaktik80_drive_count( snap, drive_count );
libspectrum_snap_set_didaktik80_paged ( snap, didaktik80_active );
libspectrum_snap_set_didaktik80_direction( snap, didaktik_fdc->direction );
libspectrum_snap_set_didaktik80_status( snap, didaktik_fdc->status_register );
libspectrum_snap_set_didaktik80_track ( snap, didaktik_fdc->track_register );
libspectrum_snap_set_didaktik80_sector( snap, didaktik_fdc->sector_register );
libspectrum_snap_set_didaktik80_data ( snap, didaktik_fdc->data_register );
libspectrum_snap_set_didaktik80_aux ( snap, aux_register );
}
static void
spectranet_to_snapshot( libspectrum_snap *snap )
{
libspectrum_byte *snap_buffer, *src;
int active = periph_is_active( PERIPH_TYPE_SPECTRANET );
libspectrum_snap_set_spectranet_active( snap, active );
if( !active )
return;
libspectrum_snap_set_spectranet_paged( snap, spectranet_paged );
libspectrum_snap_set_spectranet_paged_via_io( snap, spectranet_paged_via_io );
libspectrum_snap_set_spectranet_programmable_trap( snap,
spectranet_programmable_trap );
libspectrum_snap_set_spectranet_programmable_trap_active( snap,
spectranet_programmable_trap_active );
libspectrum_snap_set_spectranet_programmable_trap_msb( snap, trap_write_msb );
libspectrum_snap_set_spectranet_deny_downstream_a15( snap, 0 );
libspectrum_snap_set_spectranet_nmi_flipflop( snap, nmi_flipflop );
libspectrum_snap_set_spectranet_all_traps_disabled( snap,
settings_current.spectranet_disable );
libspectrum_snap_set_spectranet_rst8_trap_disabled( snap, 0 );
libspectrum_snap_set_spectranet_page_a(
snap, spectranet_current_map[1 * MEMORY_PAGES_IN_4K].page_num );
libspectrum_snap_set_spectranet_page_b(
snap, spectranet_current_map[2 * MEMORY_PAGES_IN_4K].page_num );
libspectrum_snap_set_spectranet_w5100( snap, 0,
nic_w5100_to_snapshot( w5100 ) );
snap_buffer = libspectrum_new( libspectrum_byte, SPECTRANET_ROM_LENGTH );
src = spectranet_full_map[SPECTRANET_ROM_BASE * MEMORY_PAGES_IN_4K].page;
memcpy( snap_buffer, src, SPECTRANET_ROM_LENGTH );
libspectrum_snap_set_spectranet_flash( snap, 0, snap_buffer );
snap_buffer = libspectrum_new( libspectrum_byte, SPECTRANET_RAM_LENGTH );
src = spectranet_full_map[SPECTRANET_RAM_BASE * MEMORY_PAGES_IN_4K].page;
memcpy( snap_buffer, src, SPECTRANET_RAM_LENGTH );
libspectrum_snap_set_spectranet_ram( snap, 0, snap_buffer );
}
static void
spectranet_from_snapshot( libspectrum_snap *snap )
{
if( !libspectrum_snap_spectranet_active( snap ) )
return;
if( periph_is_active( PERIPH_TYPE_SPECTRANET ) ) {
spectranet_programmable_trap =
libspectrum_snap_spectranet_programmable_trap( snap );
spectranet_programmable_trap_active =
libspectrum_snap_spectranet_programmable_trap_active( snap );
trap_write_msb =
libspectrum_snap_spectranet_programmable_trap_msb( snap );
settings_current.spectranet_disable =
libspectrum_snap_spectranet_all_traps_disabled( snap );
spectranet_map_page( 1, libspectrum_snap_spectranet_page_a( snap ) );
spectranet_map_page( 2, libspectrum_snap_spectranet_page_b( snap ) );
nmi_flipflop = libspectrum_snap_spectranet_nmi_flipflop( snap );
if( libspectrum_snap_spectranet_paged( snap ) ) {
spectranet_page( libspectrum_snap_spectranet_paged_via_io( snap ) );
memory_map_romcs_full( spectranet_current_map );
}
else
spectranet_unpage();
nic_w5100_from_snapshot( w5100,
libspectrum_snap_spectranet_w5100( snap, 0 ) );
memcpy(
spectranet_full_map[SPECTRANET_ROM_BASE * MEMORY_PAGES_IN_4K].page,
libspectrum_snap_spectranet_flash( snap, 0 ), SPECTRANET_ROM_LENGTH );
memcpy(
spectranet_full_map[SPECTRANET_RAM_BASE * MEMORY_PAGES_IN_4K].page,
libspectrum_snap_spectranet_ram( snap, 0 ), SPECTRANET_RAM_LENGTH );
}
}
static void
usource_reset( int hard_reset GCC_UNUSED )
{
usource_active = 0;
usource_available = 0;
if( !periph_is_active( PERIPH_TYPE_USOURCE ) )
return;
if( machine_load_rom_bank( usource_memory_map_romcs, 0,
settings_current.rom_usource,
settings_default.rom_usource, 0x2000 ) ) {
settings_current.usource = 0;
periph_activate_type( PERIPH_TYPE_USOURCE, 0 );
return;
}
machine_current->ram.romcs = 0;
usource_available = 1;
}
static void
spectranet_reset( int hard_reset )
{
if( !periph_is_active( PERIPH_TYPE_SPECTRANET ) ) {
spectranet_available = 0;
spectranet_paged = 0;
return;
}
spectranet_available = 1;
spectranet_paged = !settings_current.spectranet_disable;
if( hard_reset )
spectranet_hard_reset();
if( spectranet_paged ) {
machine_current->ram.romcs = 1;
machine_current->memory_map();
}
nic_w5100_reset( w5100 );
}
static void
sound_ay_overlay( void )
{
static int rng = 1;
static int noise_toggle = 0;
static int env_first = 1, env_rev = 0, env_counter = 15;
int tone_level[3];
int mixer, envshape;
int g, level;
libspectrum_dword f;
struct ay_change_tag *change_ptr = ay_change;
int changes_left = ay_change_count;
int reg, r;
int chan1, chan2, chan3;
int last_chan1 = 0, last_chan2 = 0, last_chan3 = 0;
unsigned int tone_count, noise_count;
/* If no AY chip, don't produce any AY sound (!) */
if( !( periph_is_active( PERIPH_TYPE_FULLER) ||
periph_is_active( PERIPH_TYPE_MELODIK ) ||
machine_current->capabilities & LIBSPECTRUM_MACHINE_CAPABILITY_AY ) )
return;
for( f = 0; f < machine_current->timings.tstates_per_frame;
f+= AY_CLOCK_DIVISOR * AY_CLOCK_RATIO ) {
/* update ay registers. */
while( changes_left && f >= change_ptr->tstates ) {
sound_ay_registers[ reg = change_ptr->reg ] = change_ptr->val;
change_ptr++;
changes_left--;
/* fix things as needed for some register changes */
switch ( reg ) {
case 0: case 1: case 2: case 3: case 4: case 5:
r = reg >> 1;
/* a zero-len period is the same as 1 */
ay_tone_period[r] = ( sound_ay_registers[ reg & ~1 ] |
( sound_ay_registers[ reg | 1 ] & 15 ) << 8 );
if( !ay_tone_period[r] )
ay_tone_period[r]++;
/* important to get this right, otherwise e.g. Ghouls 'n' Ghosts
* has really scratchy, horrible-sounding vibrato.
*/
if( ay_tone_tick[r] >= ay_tone_period[r] * 2 )
ay_tone_tick[r] %= ay_tone_period[r] * 2;
break;
case 6:
ay_noise_tick = 0;
ay_noise_period = ( sound_ay_registers[ reg ] & 31 );
break;
case 11: case 12:
ay_env_period =
sound_ay_registers[11] | ( sound_ay_registers[12] << 8 );
break;
case 13:
ay_env_internal_tick = ay_env_tick = ay_env_cycles = 0;
env_first = 1;
env_rev = 0;
env_counter = ( sound_ay_registers[13] & AY_ENV_ATTACK ) ? 0 : 15;
break;
}
}
/* the tone level if no enveloping is being used */
for( g = 0; g < 3; g++ )
tone_level[g] = ay_tone_levels[ sound_ay_registers[ 8 + g ] & 15 ];
/* envelope */
envshape = sound_ay_registers[13];
level = ay_tone_levels[ env_counter ];
for( g = 0; g < 3; g++ )
if( sound_ay_registers[ 8 + g ] & 16 )
tone_level[g] = level;
/* envelope output counter gets incr'd every 16 AY cycles. */
ay_env_cycles += AY_CLOCK_DIVISOR;
noise_count = 0;
while( ay_env_cycles >= 16 ) {
ay_env_cycles -= 16;
noise_count++;
ay_env_tick++;
while( ay_env_tick >= ay_env_period ) {
ay_env_tick -= ay_env_period;
/* do a 1/16th-of-period incr/decr if needed */
if( env_first ||
( ( envshape & AY_ENV_CONT ) && !( envshape & AY_ENV_HOLD ) ) ) {
if( env_rev )
env_counter -= ( envshape & AY_ENV_ATTACK ) ? 1 : -1;
else
env_counter += ( envshape & AY_ENV_ATTACK ) ? 1 : -1;
if( env_counter < 0 )
env_counter = 0;
if( env_counter > 15 )
env_counter = 15;
}
ay_env_internal_tick++;
while( ay_env_internal_tick >= 16 ) {
ay_env_internal_tick -= 16;
/* end of cycle */
if( !( envshape & AY_ENV_CONT ) )
env_counter = 0;
else {
if( envshape & AY_ENV_HOLD ) {
if( env_first && ( envshape & AY_ENV_ALT ) )
env_counter = ( env_counter ? 0 : 15 );
} else {
/* non-hold */
if( envshape & AY_ENV_ALT )
env_rev = !env_rev;
else
env_counter = ( envshape & AY_ENV_ATTACK ) ? 0 : 15;
}
}
env_first = 0;
}
/* don't keep trying if period is zero */
if( !ay_env_period )
break;
}
}
/* generate tone+noise... or neither.
* (if no tone/noise is selected, the chip just shoves the
* level out unmodified. This is used by some sample-playing
* stuff.)
*/
chan1 = tone_level[0];
chan2 = tone_level[1];
chan3 = tone_level[2];
mixer = sound_ay_registers[7];
ay_tone_cycles += AY_CLOCK_DIVISOR;
tone_count = ay_tone_cycles >> 3;
ay_tone_cycles &= 7;
if( ( mixer & 1 ) == 0 ) {
level = chan1;
ay_do_tone( level, tone_count, &chan1, 0 );
}
if( ( mixer & 0x08 ) == 0 && noise_toggle )
chan1 = 0;
if( ( mixer & 2 ) == 0 ) {
level = chan2;
ay_do_tone( level, tone_count, &chan2, 1 );
}
if( ( mixer & 0x10 ) == 0 && noise_toggle )
chan2 = 0;
if( ( mixer & 4 ) == 0 ) {
level = chan3;
ay_do_tone( level, tone_count, &chan3, 2 );
}
if( ( mixer & 0x20 ) == 0 && noise_toggle )
chan3 = 0;
if( last_chan1 != chan1 ) {
blip_synth_update( ay_a_synth, f, chan1 );
if( ay_a_synth_r ) blip_synth_update( ay_a_synth_r, f, chan1 );
last_chan1 = chan1;
}
if( last_chan2 != chan2 ) {
blip_synth_update( ay_b_synth, f, chan2 );
if( ay_b_synth_r ) blip_synth_update( ay_b_synth_r, f, chan2 );
last_chan2 = chan2;
}
if( last_chan3 != chan3 ) {
blip_synth_update( ay_c_synth, f, chan3 );
if( ay_c_synth_r ) blip_synth_update( ay_c_synth_r, f, chan3 );
last_chan3 = chan3;
}
/* update noise RNG/filter */
ay_noise_tick += noise_count;
while( ay_noise_tick >= ay_noise_period ) {
ay_noise_tick -= ay_noise_period;
if( ( rng & 1 ) ^ ( ( rng & 2 ) ? 1 : 0 ) )
noise_toggle = !noise_toggle;
/* rng is 17-bit shift reg, bit 0 is output.
* input is bit 0 xor bit 3.
*/
if( rng & 1 ) {
rng ^= 0x24000;
}
rng >>= 1;
/* don't keep trying if period is zero */
if( !ay_noise_period )
break;
}
}
}
/* Open `filename' and do something sensible with it; autoload tapes
if `autoload' is true and return the type of file found in `type' */
int
utils_open_file( const char *filename, int autoload,
libspectrum_id_t *type_ptr)
{
utils_file file;
libspectrum_id_t type;
libspectrum_class_t class;
int error;
error = 0;
if( rzx_recording ) error = rzx_stop_recording();
if( rzx_playback ) error = rzx_stop_playback( 1 );
if( error ) return error;
/* Read the file into a buffer */
if( utils_read_file( filename, &file ) ) return 1;
/* See if we can work out what it is */
if( libspectrum_identify_file_with_class( &type, &class, filename,
file.buffer, file.length ) ) {
utils_close_file( &file );
return 1;
}
switch( class ) {
case LIBSPECTRUM_CLASS_UNKNOWN:
ui_error( UI_ERROR_ERROR, "utils_open_file: couldn't identify `%s'",
filename );
utils_close_file( &file );
return 1;
case LIBSPECTRUM_CLASS_RECORDING:
error = rzx_start_playback_from_buffer( file.buffer, file.length );
break;
case LIBSPECTRUM_CLASS_SNAPSHOT:
error = snapshot_read_buffer( file.buffer, file.length, type );
pokemem_find_pokfile( filename );
break;
case LIBSPECTRUM_CLASS_TAPE:
error = tape_read_buffer( file.buffer, file.length, type, filename,
autoload );
pokemem_find_pokfile( filename );
break;
case LIBSPECTRUM_CLASS_DISK_PLUS3:
if( !( machine_current->capabilities &
LIBSPECTRUM_MACHINE_CAPABILITY_PLUS3_DISK ) ) {
error = machine_select( LIBSPECTRUM_MACHINE_PLUS3 ); if( error ) break;
}
error = specplus3_disk_insert( SPECPLUS3_DRIVE_A, filename, autoload );
break;
case LIBSPECTRUM_CLASS_DISK_DIDAKTIK:
error = didaktik80_disk_insert( DIDAKTIK80_DRIVE_A, filename, autoload );
break;
case LIBSPECTRUM_CLASS_DISK_PLUSD:
if( periph_is_active( PERIPH_TYPE_DISCIPLE ) )
error = disciple_disk_insert( DISCIPLE_DRIVE_1, filename, autoload );
else
error = plusd_disk_insert( PLUSD_DRIVE_1, filename, autoload );
break;
case LIBSPECTRUM_CLASS_DISK_OPUS:
error = opus_disk_insert( OPUS_DRIVE_1, filename, autoload );
break;
case LIBSPECTRUM_CLASS_DISK_TRDOS:
if( !( machine_current->capabilities &
LIBSPECTRUM_MACHINE_CAPABILITY_TRDOS_DISK ) &&
!periph_is_active( PERIPH_TYPE_BETA128 ) ) {
error = machine_select( LIBSPECTRUM_MACHINE_PENT ); if( error ) break;
}
/* Check that we actually got a Beta capable machine to insert the disk */
if( ( machine_current->capabilities &
LIBSPECTRUM_MACHINE_CAPABILITY_TRDOS_DISK ) ||
periph_is_active( PERIPH_TYPE_BETA128 ) ) {
error = beta_disk_insert( BETA_DRIVE_A, filename, autoload );
}
break;
case LIBSPECTRUM_CLASS_DISK_GENERIC:
if( machine_current->machine == LIBSPECTRUM_MACHINE_PLUS3 ||
machine_current->machine == LIBSPECTRUM_MACHINE_PLUS2A )
error = specplus3_disk_insert( SPECPLUS3_DRIVE_A, filename, autoload );
else if( machine_current->machine == LIBSPECTRUM_MACHINE_PENT ||
machine_current->machine == LIBSPECTRUM_MACHINE_PENT512 ||
machine_current->machine == LIBSPECTRUM_MACHINE_PENT1024 ||
machine_current->machine == LIBSPECTRUM_MACHINE_SCORP )
error = beta_disk_insert( BETA_DRIVE_A, filename, autoload );
else
if( periph_is_active( PERIPH_TYPE_BETA128 ) )
error = beta_disk_insert( BETA_DRIVE_A, filename, autoload );
else if( periph_is_active( PERIPH_TYPE_DISCIPLE ) )
error = disciple_disk_insert( DISCIPLE_DRIVE_1, filename, autoload );
else if( periph_is_active( PERIPH_TYPE_PLUSD ) )
error = plusd_disk_insert( PLUSD_DRIVE_1, filename, autoload );
break;
case LIBSPECTRUM_CLASS_CARTRIDGE_IF2:
error = if2_insert( filename );
break;
case LIBSPECTRUM_CLASS_MICRODRIVE:
error = if1_mdr_insert( -1, filename );
break;
case LIBSPECTRUM_CLASS_CARTRIDGE_TIMEX:
if( !( machine_current->capabilities &
LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_DOCK ) ) {
error = machine_select( LIBSPECTRUM_MACHINE_TC2068 ); if( error ) break;
}
/* Check that we actually got a Dock capable machine to insert the cart */
if( machine_current->capabilities &
LIBSPECTRUM_MACHINE_CAPABILITY_TIMEX_DOCK ) {
error = dck_insert( filename );
}
break;
case LIBSPECTRUM_CLASS_HARDDISK:
if( !settings_current.simpleide_active &&
!settings_current.zxatasp_active &&
!settings_current.divide_enabled &&
!settings_current.zxcf_active ) {
settings_current.zxcf_active = 1;
periph_update();
}
if( settings_current.zxcf_active ) {
error = zxcf_insert( filename );
} else if( settings_current.zxatasp_active ) {
error = zxatasp_insert( filename, LIBSPECTRUM_IDE_MASTER );
} else if( settings_current.simpleide_active ) {
error = simpleide_insert( filename, LIBSPECTRUM_IDE_MASTER );
} else {
error = divide_insert( filename, LIBSPECTRUM_IDE_MASTER );
}
if( error ) return error;
break;
case LIBSPECTRUM_CLASS_AUXILIARY:
if( type == LIBSPECTRUM_ID_AUX_POK ) {
ui_pokemem_selector( filename );
}
break;
default:
ui_error( UI_ERROR_ERROR, "utils_open_file: unknown class %d", type );
error = 1;
break;
}
if( error ) { utils_close_file( &file ); return error; }
utils_close_file( &file );
if( type_ptr ) *type_ptr = type;
return 0;
}
