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); } }