static void nvram_handler_at28c16( int chip, mame_file *file, int read_or_write )
{
struct at28c16_chip *c;
if( chip >= MAX_AT28C16_CHIPS )
{
logerror( "at28c16_nvram_handler: invalid chip %d\n", chip );
return;
}
c = &at28c16[ chip ];
if( read_or_write )
{
mame_fwrite( file, c->data, DATA_SIZE );
mame_fwrite( file, c->id, ID_SIZE );
}
else
{
at28c16_init( chip );
if( file )
{
mame_fread( file, c->data, DATA_SIZE );
mame_fread( file, c->id, ID_SIZE );
}
}
}
ROM_END
/* System Configuration */
DEVICE_LOAD( studio2_cart ) {
UINT8 *ptr = NULL;
UINT8 header[ST2_HEADER_SIZE];
int filesize;
filesize = image_length( image );
if ( filesize <= ST2_HEADER_SIZE ) {
logerror( "Error loading cartridge: Invalid ROM file: %s.\n", image_filename( image ) );
return INIT_FAIL;
}
/* read ST2 header */
if ( mame_fread( file, header, ST2_HEADER_SIZE ) != ST2_HEADER_SIZE ) {
logerror( "Error loading cartridge: Unable to read header from file: %s.\n", image_filename( image ) );
return INIT_FAIL;
}
filesize -= ST2_HEADER_SIZE;
/* Read ST2 cartridge contents */
ptr = ((UINT8 *)memory_region( REGION_CPU1 ) ) + 0x0400;
if ( mame_fread( file, ptr, filesize ) != filesize ) {
logerror( "Error loading cartridge: Unable to read contents from file: %s.\n", image_filename( image ) );
return INIT_FAIL;
}
return INIT_PASS;
}
ROM_END
int device_load_fnvision_cart(mess_image *image, mame_file *file)
{
/*
Cartridge Image format
======================
- The first 16K is read into 8000 - BFFF. If the cart file is less than 16k
then the cartridge is read into 8000, then replicated to fill up the 16k
(eg. a 4k cartridge file is written to 8000 - 8FFF, then replicated at
9000-9FFF, A000-AFFF and B000-BFFF).
- The next 16k is read into 4000 - 7FFF. If this extra bit is less than 16k,
then the data is replicated throughout 4000 - 7FFF.
For example, an 18k cartridge dump has its first 16k read and written into
memory at 8000-BFFF. The remaining 2K is written into 4000-47FF, then
replicated 8 times to appear at 4800, 5000, 5800, 6000, 6800, 7000 and 7800.
*/
if (file)
{
int size = mame_fread(file, memory_region(REGION_CPU1) + 0x8000, 0x4000);
switch (size)
{
case 0x1000:
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0x8fff, 0, 0x3000, MRA8_ROM);
break;
case 0x2000:
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x8000, 0x9fff, 0, 0x2000, MRA8_ROM);
break;
case 0x4000:
size = mame_fread(file, memory_region(REGION_CPU1) + 0x4000, 0x4000);
switch (size)
{
case 0x0800:
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x4000, 0x47ff, 0, 0x3800, MRA8_ROM);
break;
case 0x1000:
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x4000, 0x4fff, 0, 0x3000, MRA8_ROM);
break;
case 0x2000:
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x4000, 0x5fff, 0, 0x2000, MRA8_ROM);
break;
}
break;
}
}
return 0;
}
static NVRAM_HANDLER( namcosna1 )
{
if( read_or_write )
{
mame_fwrite( file, namcona1_nvmem, NA1_NVRAM_SIZE );
}
else
{
if (file)
{
mame_fread( file, namcona1_nvmem, NA1_NVRAM_SIZE );
}
else
{
memset( namcona1_nvmem, 0x00, NA1_NVRAM_SIZE );
switch( namcona1_gametype )
{
case NAMCO_EXBANIA:
memcpy( namcona1_nvmem, ExvaniaDefaultNvMem, sizeof(ExvaniaDefaultNvMem) );
break;
case NAMCO_QUIZTOU:
memcpy( namcona1_nvmem, QuiztouDefaultNvMem, sizeof(QuiztouDefaultNvMem) );
break;
}
}
}
} /* namcosna1_nvram_handler */
void nvram_handler_intelflash(int chip,mame_file *file,int read_or_write)
{
struct flash_chip *c;
if( chip >= FLASH_CHIPS_MAX )
{
logerror( "intelflash_nvram: invalid chip %d\n", chip );
return;
}
c = &chips[ chip ];
switch( c->bits )
{
case 8:
if (read_or_write)
{
mame_fwrite( file, c->flash_memory, c->size );
}
else if (file)
{
mame_fread( file, c->flash_memory, c->size );
}
break;
case 16:
if (read_or_write)
{
mame_fwrite_lsbfirst( file, c->flash_memory, c->size );
}
else if (file)
{
mame_fread_lsbfirst( file, c->flash_memory, c->size );
}
break;
}
}
static DEVICE_NVRAM(x2212)
{
x2212_state *c = get_safe_token(device);
if( read_or_write )
{
mame_fwrite( file, c->sram, SIZE_DATA );
}
else
{
if( file )
{
mame_fread( file, c->e2prom, SIZE_DATA );
}
else
{
if( c->default_data != NULL )
{
memcpy( c->e2prom, c->default_data, SIZE_DATA );
}
else
{
memset( c->e2prom, 0xff, SIZE_DATA );
}
}
memcpy( c->sram, c->e2prom, SIZE_DATA );
}
}
static NVRAM_HANDLER( bmcbowl )
{
int i;
if (read_or_write)
mame_fwrite(file, stats_ram, stats_ram_size);
else
#ifdef NVRAM_HACK
for (i = 0; i < stats_ram_size; i++)
stats_ram[i] = 0xff;
init_stats(bmc_nv1,ARRAY_LENGTH(bmc_nv1),0);
init_stats(bmc_nv2,ARRAY_LENGTH(bmc_nv2),0x3b0);
init_stats(bmc_nv3,ARRAY_LENGTH(bmc_nv3),0xfe2);
#else
if (file)
mame_fread(file, stats_ram, stats_ram_size);
else
for (i = 0; i < stats_ram_size; i++)
stats_ram[i] = 0xff;
#endif
}
static NVRAM_HANDLER( hyperspt )
{
if (read_or_write)
mame_fwrite(file,nvram,nvram_size);
else if (file)
mame_fread(file,nvram,nvram_size);
}
void mc10_init_machine(void)
{
mc10_keyboard_strobe = 0xff;
/* NPW: Taken from Juergen's MC-10 attempt that I just noticed... */
if( readinputport(7) & 0x80 )
{
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MRA8_RAM);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MWA8_RAM);
}
else
{
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MRA8_NOP);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MWA8_NOP);
}
/* Install DOS ROM ? */
if( readinputport(7) & 0x40 )
{
mame_file_error filerr;
mame_file *rom;
filerr = mame_fopen(SEARCHPATH_IMAGE, "mc10ext.rom", OPEN_FLAG_READ, &rom);
if( rom )
{
mame_fread(rom, memory_region(REGION_CPU1) + 0xc000, 0x2000);
mame_fclose(rom);
}
}
else
{
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0xc000, 0xdfff, 0, 0, MRA8_NOP);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0xc000, 0xdfff, 0, 0, MWA8_NOP);
}
}
static int ti99_hsgpl_file_load(mame_file *file)
{
UINT8 version;
/* version flag */
if (mame_fread(file, & version, 1) != 1)
return 1;
if (version != 0)
return 1;
/* read DSR */
at29c040a_init_data_ptr(feeprom_dsr, memory_region(region_hsgpl) + offset_hsgpl_dsr);
if (at29c040a_file_load(feeprom_dsr, file))
return 1;
/* read GROM 0 */
at29c040a_init_data_ptr(feeprom_grom0, memory_region(region_hsgpl) + offset_hsgpl_grom);
if (at29c040a_file_load(feeprom_grom0, file))
return 1;
/* read GROM 1 */
at29c040a_init_data_ptr(feeprom_grom1, memory_region(region_hsgpl) + offset_hsgpl_grom + 0x80000);
if (at29c040a_file_load(feeprom_grom1, file))
return 1;
/* read ROM6 */
at29c040a_init_data_ptr(feeprom_rom6, memory_region(region_hsgpl) + offset_hsgpl_rom6);
if (at29c040a_file_load(feeprom_rom6, file))
return 1;
return 0;
}
static DEVICE_NVRAM(timekeeper)
{
timekeeper_state *c = get_safe_token(device);
if( read_or_write )
{
mame_fwrite( file, c->data, c->size );
}
else
{
if( file )
{
mame_fread( file, c->data, c->size );
}
else
{
if( c->default_data != NULL )
{
memcpy( c->data, c->default_data, c->size );
}
else
{
memset( c->data, 0xff, c->size );
}
}
counters_to_ram( c );
}
}
/* load battery backed nvram from a driver subdir. in the nvram dir. */
int image_battery_load(mess_image *img, void *buffer, int length)
{
mame_file *f;
int bytes_read = 0;
int result = FALSE;
char *nvram_filename;
/* some sanity checking */
if( buffer != NULL && length > 0 )
{
nvram_filename = battery_nvramfilename(img);
if (nvram_filename)
{
f = mame_fopen(Machine->gamedrv->name, nvram_filename, FILETYPE_NVRAM, 0);
if (f)
{
bytes_read = mame_fread(f, buffer, length);
mame_fclose(f);
result = TRUE;
}
free(nvram_filename);
}
/* fill remaining bytes (if necessary) */
memset(((char *) buffer) + bytes_read, '\0', length - bytes_read);
}
return result;
}
static NVRAM_HANDLER( bmc_nvram )
{
int i;
if (read_or_write)
mame_fwrite(file, stats_ram, stats_ram_size);
else
#ifdef NVRAM_HACK
for (i = 0; i < stats_ram_size; i++)
{
stats_ram[i] = 0xff;
init_stats(bmc_nv1,0);
init_stats(bmc_nv2,0x3b0);
init_stats(bmc_nv3,0xfe2);
}
#else
if (file)
mame_fread(file, stats_ram, stats_ram_size);
else
for (i = 0; i < stats_ram_size; i++)
stats_ram[i] = 0xff;
#endif
}
static int run_hash(mame_file *file,
void (*partialhash)(char *, const unsigned char *, unsigned long, unsigned int),
char *dest, unsigned int hash_functions)
{
UINT32 size;
UINT8 *buf = NULL;
*dest = '\0';
size = (UINT32) mame_fsize(file);
buf = (UINT8 *) malloc(size);
if (!buf)
return FALSE;
/* read the file */
mame_fseek(file, 0, SEEK_SET);
mame_fread(file, buf, size);
if (partialhash)
partialhash(dest, buf, size, hash_functions);
else
hash_compute(dest, buf, size, hash_functions);
/* cleanup */
if (buf)
free(buf);
mame_fseek(file, 0, SEEK_SET);
return TRUE;
}
/* load image */
static int kc_load(mame_file *file, unsigned char **ptr)
{
if (file)
{
int datasize;
unsigned char *data;
/* get file size */
datasize = mame_fsize(file);
if (datasize!=0)
{
/* malloc memory for this data */
data = malloc(datasize);
if (data!=NULL)
{
/* read whole file */
mame_fread(file, data, datasize);
*ptr = data;
logerror("File loaded!\r\n");
/* ok! */
return 1;
}
}
}
return 0;
}
static void vc20_prg_open(mess_image *img, mame_file *fp)
{
const char *name;
int i;
prg.length = mame_fsize (fp);
if ((prg.prg = (UINT8 *) malloc (prg.length)) == NULL)
{
logerror("tape %s could not be loaded\n", image_filename(img));
return;
}
mame_fread (fp, prg.prg, prg.length);
logerror("tape %s loaded\n", image_filename(img));
name = image_filename(img);
for (i = 0; name[i] != 0; i++)
prg.name[i] = toupper (name[i]);
for (; i < 16; i++)
prg.name[i] = ' ';
prg.img = img;
prg.stateblock = 0;
prg.stateheader = 0;
prg.statebyte = 0;
prg.statebit = 0;
tape.type = TAPE_PRG;
tape.on = 1;
prg.state = 2;
prg.pos = 0;
prg.timer = prg.prg_timer;
}
static void hs_load (void)
{
mame_file *f = mame_fopen (Machine->gamedrv->name, 0, FILETYPE_HIGHSCORE, 0);
state.hiscores_have_been_loaded = 1;
LOG(("hs_load\n"));
if (f)
{
struct mem_range *mem_range = state.mem_range;
LOG(("loading...\n"));
while (mem_range)
{
UINT8 *data = osd_malloc (mem_range->num_bytes);
if (data)
{
/* this buffer will almost certainly be small
enough to be dynamically allocated, but let's
avoid memory trashing just in case
*/
mame_fread (f, data, mem_range->num_bytes);
copy_to_memory (mem_range->cpu, mem_range->addr, data, mem_range->num_bytes);
free (data);
}
mem_range = mem_range->next;
}
mame_fclose (f);
}
}
static void jchan_mcu_run(running_machine *machine)
{
UINT16 mcu_command = mcu_ram[0x0010/2]; /* command nb */
UINT16 mcu_offset = mcu_ram[0x0012/2] / 2; /* offset in shared RAM where MCU will write */
UINT16 mcu_subcmd = mcu_ram[0x0014/2]; /* sub-command parameter, happens only for command #4 */
logerror("%s : MCU executed command: %04X %04X %04X ",cpuexec_describe_context(machine),mcu_command,mcu_offset*2,mcu_subcmd);
/*
the only MCU commands found in program code are:
- 0x04: protection: provide data (see below) and code
- 0x03: read DSW
- 0x02: load game settings \ stored in ATMEL AT93C46 chip,
- 0x42: save game settings / 128 bytes serial EEPROM
*/
switch (mcu_command >> 8)
{
case 0x04: /* Protection: during self-test for mcu_subcmd = 0x3d, 0x3e, 0x3f */
{
toxboy_handle_04_subcommand(machine,mcu_subcmd,mcu_ram);
}
break;
case 0x03: // DSW
{
mcu_ram[mcu_offset] = input_port_read(machine, "DSW");
logerror("%s : MCU executed command: %04X %04X (read DSW)\n",cpuexec_describe_context(machine),mcu_command,mcu_offset*2);
}
break;
case 0x02: /* load game settings from 93C46 EEPROM ($1090-$10dc) */
{
mame_file *f;
if ((f = nvram_fopen(machine, OPEN_FLAG_READ)) != 0)
{
mame_fread(f,&mcu_ram[mcu_offset], 128);
mame_fclose(f);
}
logerror("(load NVRAM settings)\n");
}
break;
case 0x42: /* save game settings to 93C46 EEPROM ($50d4) */
{
mame_file *f;
if ((f = nvram_fopen(machine, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS)) != 0)
{
mame_fwrite(f,&mcu_ram[mcu_offset], 128);
mame_fclose(f);
}
logerror("(save NVRAM settings)\n");
}
break;
default:
logerror("- UNKNOWN COMMAND!!!\n");
}
}
static QUICKLOAD_LOAD( jaguar )
{
offs_t quickload_begin = 0x4000;
quickload_size = MIN(quickload_size, 0x200000 - quickload_begin);
mame_fread(fp, &memory_region(REGION_CPU1)[quickload_begin], quickload_size);
cpunum_set_reg(0, REG_PC, quickload_begin);
return INIT_PASS;
}
void intelfsh_device::nvram_read(mame_file &file)
{
UINT8 *buffer = global_alloc_array(UINT8, m_config.m_size);
mame_fread(&file, buffer, m_config.m_size);
for (int byte = 0; byte < m_config.m_size; byte++)
m_addrspace[0]->write_byte(byte, buffer[byte]);
global_free(buffer);
}
static void coco_vhd_readwrite(UINT8 data)
{
mame_file *vhdfile;
int result;
int phyOffset;
long nBA = bufferAddress;
vhdfile = image_fp(vhd_image());
if (!vhdfile)
{
vhdStatus = 2; /* No VHD attached */
return;
}
result = mame_fseek(vhdfile, ((logicalRecordNumber)) * 256, SEEK_SET);
if (result < 0)
{
vhdStatus = 5; /* access denied */
return;
}
phyOffset = coco3_mmu_translate( (nBA >> 12 ) / 2, nBA % 8192 );
switch(data) {
case 0: /* Read sector */
result = mame_fread(vhdfile, &(mess_ram[phyOffset]), 256);
if( result != 256 )
{
vhdStatus = 5; /* access denied */
return;
}
vhdStatus = 0; /* Aok */
break;
case 1: /* Write Sector */
result = mame_fwrite(vhdfile, &(mess_ram[phyOffset]), 256);
if (result != 256)
{
vhdStatus = 5; /* access denied */
return;
}
vhdStatus = 0; /* Aok */
break;
case 2: /* Flush file cache */
vhdStatus = 0; /* Aok */
break;
default:
vhdStatus = 0xfe; /* -2, Unknown command */
break;
}
}
state_save_error state_save_read_file(running_machine *machine, mame_file *file)
{
state_private *global = machine->state_data;
UINT32 signature = get_signature(machine);
UINT8 header[HEADER_SIZE];
state_callback *func;
state_entry *entry;
int flip;
/* if we have illegal registrations, return an error */
if (global->illegal_regs > 0)
return STATERR_ILLEGAL_REGISTRATIONS;
/* read the header and turn on compression for the rest of the file */
mame_fcompress(file, FCOMPRESS_NONE);
mame_fseek(file, 0, SEEK_SET);
if (mame_fread(file, header, sizeof(header)) != sizeof(header))
return STATERR_READ_ERROR;
mame_fcompress(file, FCOMPRESS_MEDIUM);
/* verify the header and report an error if it doesn't match */
if (validate_header(header, machine->gamedrv->name, signature, popmessage, _("Error: ")) != STATERR_NONE)
return STATERR_INVALID_HEADER;
/* determine whether or not to flip the data when done */
flip = NATIVE_ENDIAN_VALUE_LE_BE((header[9] & SS_MSB_FIRST) != 0, (header[9] & SS_MSB_FIRST) == 0);
/* read all the data, flipping if necessary */
for (entry = global->entrylist; entry != NULL; entry = entry->next)
{
UINT32 totalsize = entry->typesize * entry->typecount;
if (mame_fread(file, entry->data, totalsize) != totalsize)
return STATERR_READ_ERROR;
/* handle flipping */
if (flip)
flip_data(entry);
}
/* call the post-load functions */
for (func = global->postfunclist; func != NULL; func = func->next)
(*func->func.postload)(machine, func->param);
return STATERR_NONE;
}
static void d88image_read_sector_data_into_buffer(mess_image *img, int side, int index1, char *ptr, int length)
{
d88image *w = get_d88image(img);
if (d88image_seek(w, w->track, side, index1))
{
mame_fread(w->image_file, ptr, length);
}
}
void nvram_handler_generic_0fill(mame_file *file, int read_or_write)
{
if (read_or_write)
mame_fwrite(file, nvram_select(), generic_nvram_size);
else if (file)
mame_fread(file, nvram_select(), generic_nvram_size);
else
memset(nvram_select(), 0, generic_nvram_size);
}
static NVRAM_HANDLER (quaquiz2)
{
if (read_or_write)
mame_fwrite(file, generic_nvram, generic_nvram_size);
else if (file)
mame_fread(file, generic_nvram, generic_nvram_size);
else
memcpy ( generic_nvram, quaquiz2_default_eeprom, 0x100 );
}
void nvram_handler_generic_1fill(mame_file *file, int read_or_write)
{
if (read_or_write)
mame_fwrite(file, generic_nvram, generic_nvram_size);
else if (file)
mame_fread(file, generic_nvram, generic_nvram_size);
else
memset(generic_nvram, 0xff, generic_nvram_size);
}
static NVRAM_HANDLER(tomcat)
{
if (read_or_write)
mame_fwrite(file, tomcat_nvram, 0x800);
else
if (file)
mame_fread(file, tomcat_nvram, 0x800);
else
memset(tomcat_nvram, 0x00, 0x800);
}
void eeprom_device::nvram_read(mame_file &file)
{
UINT32 eeprom_length = 1 << m_config.m_address_bits;
UINT32 eeprom_bytes = eeprom_length * m_config.m_data_bits / 8;
UINT8 *buffer = auto_alloc_array(&m_machine, UINT8, eeprom_bytes);
mame_fread(&file, buffer, eeprom_bytes);
for (offs_t offs = 0; offs < eeprom_bytes; offs++)
m_addrspace[0]->write_byte(offs, buffer[offs]);
auto_free(&m_machine, buffer);
}
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 NVRAM_HANDLER( goldstar )
{
if (read_or_write)
mame_fwrite(file,nvram,nvram_size);
else
{
if (file)
mame_fread(file,nvram,nvram_size);
else
memset(nvram,0xff,nvram_size);
}
}
