static int load_psxexe( device_t *cpu, unsigned char *p_n_file, int n_len )
{
psx_state *state = cpu->machine().driver_data<psx_state>();
struct PSXEXE_HEADER
{
UINT8 id[ 8 ];
UINT32 text; /* SCE only */
UINT32 data; /* SCE only */
UINT32 pc0;
UINT32 gp0; /* SCE only */
UINT32 t_addr;
UINT32 t_size;
UINT32 d_addr; /* SCE only */
UINT32 d_size; /* SCE only */
UINT32 b_addr; /* SCE only */
UINT32 b_size; /* SCE only */
UINT32 s_addr;
UINT32 s_size;
UINT32 SavedSP;
UINT32 SavedFP;
UINT32 SavedGP;
UINT32 SavedRA;
UINT32 SavedS0;
UINT8 dummy[ 0x800 - 76 ];
};
struct PSXEXE_HEADER *psxexe_header = (struct PSXEXE_HEADER *)p_n_file;
if( n_len >= sizeof( struct PSXEXE_HEADER ) &&
memcmp( psxexe_header->id, "PS-X EXE", 8 ) == 0 )
{
UINT8 *p_ram;
UINT8 *p_psxexe;
UINT32 n_stack;
UINT32 n_ram;
UINT32 n_address;
UINT32 n_size;
psxexe_conv32( &psxexe_header->text );
psxexe_conv32( &psxexe_header->data );
psxexe_conv32( &psxexe_header->pc0 );
psxexe_conv32( &psxexe_header->gp0 );
psxexe_conv32( &psxexe_header->t_addr );
psxexe_conv32( &psxexe_header->t_size );
psxexe_conv32( &psxexe_header->d_addr );
psxexe_conv32( &psxexe_header->d_size );
psxexe_conv32( &psxexe_header->b_addr );
psxexe_conv32( &psxexe_header->b_size );
psxexe_conv32( &psxexe_header->s_addr );
psxexe_conv32( &psxexe_header->s_size );
psxexe_conv32( &psxexe_header->SavedSP );
psxexe_conv32( &psxexe_header->SavedFP );
psxexe_conv32( &psxexe_header->SavedGP );
psxexe_conv32( &psxexe_header->SavedRA );
psxexe_conv32( &psxexe_header->SavedS0 );
/* todo: check size.. */
logerror( "psx_exe_load: pc %08x\n", psxexe_header->pc0 );
logerror( "psx_exe_load: org %08x\n", psxexe_header->t_addr );
logerror( "psx_exe_load: len %08x\n", psxexe_header->t_size );
logerror( "psx_exe_load: sp %08x\n", psxexe_header->s_addr );
logerror( "psx_exe_load: len %08x\n", psxexe_header->s_size );
p_ram = (UINT8 *)state->m_p_n_psxram;
n_ram = state->m_n_psxramsize;
p_psxexe = p_n_file + sizeof( struct PSXEXE_HEADER );
n_address = psxexe_header->t_addr;
n_size = psxexe_header->t_size;
while( n_size != 0 )
{
p_ram[ BYTE4_XOR_LE( n_address ) % n_ram ] = *( p_psxexe );
n_address++;
p_psxexe++;
n_size--;
}
cpu_set_reg( cpu, PSXCPU_PC, psxexe_header->pc0 );
cpu_set_reg( cpu, PSXCPU_R28, psxexe_header->gp0 );
n_stack = psxexe_header->s_addr + psxexe_header->s_size;
if( n_stack != 0 )
{
cpu_set_reg( cpu, PSXCPU_R29, n_stack );
cpu_set_reg( cpu, PSXCPU_R30, n_stack );
}
return 1;
}
return 0;
}
static QUICKLOAD_LOAD( psx_exe_load )
{
if( mame_fread( fp, &m_psxexe_header, sizeof( m_psxexe_header ) ) != sizeof( m_psxexe_header ) )
{
logerror( "psx_exe_load: invalid exe\n" );
return INIT_FAIL;
}
if( memcmp( m_psxexe_header.id, "PS-X EXE", 8 ) != 0 )
{
logerror( "psx_exe_load: invalid header id\n" );
return INIT_FAIL;
}
psxexe_conv32( &m_psxexe_header.text );
psxexe_conv32( &m_psxexe_header.data );
psxexe_conv32( &m_psxexe_header.pc0 );
psxexe_conv32( &m_psxexe_header.gp0 );
psxexe_conv32( &m_psxexe_header.t_addr );
psxexe_conv32( &m_psxexe_header.t_size );
psxexe_conv32( &m_psxexe_header.d_addr );
psxexe_conv32( &m_psxexe_header.d_size );
psxexe_conv32( &m_psxexe_header.b_addr );
psxexe_conv32( &m_psxexe_header.b_size );
psxexe_conv32( &m_psxexe_header.s_addr );
psxexe_conv32( &m_psxexe_header.s_size );
psxexe_conv32( &m_psxexe_header.SavedSP );
psxexe_conv32( &m_psxexe_header.SavedFP );
psxexe_conv32( &m_psxexe_header.SavedGP );
psxexe_conv32( &m_psxexe_header.SavedRA );
psxexe_conv32( &m_psxexe_header.SavedS0 );
m_p_psxexe = malloc( m_psxexe_header.t_size );
if( m_p_psxexe == NULL )
{
logerror( "psx_exe_load: out of memory\n" );
return INIT_FAIL;
}
mame_fread( fp, m_p_psxexe, m_psxexe_header.t_size );
memory_set_opbase_handler( 0, psx_setopbase );
return INIT_PASS;
}
static int load_psf( device_t *cpu, unsigned char *p_n_file, int n_len )
{
int n_return;
unsigned long n_crc;
unsigned long n_compressed;
unsigned char *p_n_compressed;
unsigned long n_uncompressed;
unsigned char *p_n_uncompressed;
struct PSF_HEADER
{
unsigned char id[ 4 ];
UINT32 reserved_size;
UINT32 exe_size;
UINT32 exe_crc;
};
struct PSF_HEADER *psf_header = (struct PSF_HEADER *)p_n_file;
n_return = 0;
if( n_len >= sizeof( struct PSF_HEADER ) &&
memcmp( p_n_file, "PSF", 3 ) == 0 )
{
psxexe_conv32( &psf_header->reserved_size );
psxexe_conv32( &psf_header->exe_size );
psxexe_conv32( &psf_header->exe_crc );
logerror( "psx_exe_load: reserved_size %08x\n", psf_header->reserved_size );
logerror( "psx_exe_load: exe_size %08x\n", psf_header->exe_size );
logerror( "psx_exe_load: exe_crc %08x\n", psf_header->exe_crc );
n_compressed = psf_header->exe_size;
p_n_compressed = p_n_file + sizeof( struct PSF_HEADER ) + psf_header->reserved_size;
n_crc = crc32( crc32( 0L, Z_NULL, 0 ), p_n_compressed, n_compressed );
if( n_crc != psf_header->exe_crc )
{
logerror( "psx_exe_load: psf invalid crc\n" );
return 0;
}
n_uncompressed = 0x200000;
p_n_uncompressed = (unsigned char *)malloc( n_uncompressed );
if( uncompress( p_n_uncompressed, &n_uncompressed, p_n_compressed, n_compressed ) != Z_OK )
{
logerror( "psx_exe_load: psf uncompress failed\n" );
}
else if( !load_psxexe( cpu, p_n_uncompressed, n_uncompressed ) )
{
logerror( "psx_exe_load: psf load failed\n" );
}
else
{
n_return = 1;
}
free( p_n_uncompressed );
}
return n_return;
}
