int pegasus_state::load_cart(device_image_interface &image, generic_slot_device *slot, const char *reg_tag) { UINT32 size = slot->common_get_size(reg_tag); bool any_socket = false; if (size > 0x1000) { image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size"); return IMAGE_INIT_FAIL; } if (image.software_entry() != NULL && size == 0) { // we might be loading a cart compatible with all sockets! // so try to get region "rom" size = slot->common_get_size("rom"); any_socket = true; if (size == 0) { astring errmsg; errmsg.printf("Attempted to load a file that does not work in this socket.\nPlease check \"Usage\" field in the software list for the correct socket(s) to use."); image.seterror(IMAGE_ERROR_UNSPECIFIED, errmsg.cstr()); return IMAGE_INIT_FAIL; } } slot->rom_alloc(0x1000, GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE); // we alloc 0x1000 also for smaller roms! slot->common_load_rom(slot->get_rom_base(), size, any_socket ? "rom" : reg_tag); // raw images have to be decrypted (in particular the ones from softlist) pegasus_decrypt_rom(slot->get_rom_base(), image.software_entry() != NULL); return IMAGE_INIT_PASS; }
INPUT_PORTS_END /*************************************************************************** MACHINE DRIVERS ***************************************************************************/ int aim65_state::load_cart(device_image_interface &image, generic_slot_device *slot, const char *slot_tag) { UINT32 size = slot->common_get_size(slot_tag); if (size > 0x1000) { image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size"); return IMAGE_INIT_FAIL; } if (image.software_entry() != NULL && image.get_software_region(slot_tag) == NULL) { astring errmsg; errmsg.printf("Attempted to load file with wrong extension\nSocket '%s' only accepts files with '.%s' extension", slot_tag, slot_tag); image.seterror(IMAGE_ERROR_UNSPECIFIED, errmsg.c_str()); return IMAGE_INIT_FAIL; } slot->rom_alloc(size, GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE); slot->common_load_rom(slot->get_rom_base(), size, slot_tag); return IMAGE_INIT_PASS; }
image_init_result nascom2_state::load_cart(device_image_interface &image, generic_slot_device *slot, int slot_id) { // loading directly from file if (image.software_entry() == nullptr) { if (slot->length() > 0x1000) { image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported file size"); return image_init_result::FAIL; } slot->rom_alloc(slot->length(), GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE); slot->fread(slot->get_rom_base(), slot->length()); // we just assume that socket1 should be loaded to 0xc000 and socket2 to 0xd000 switch (slot_id) { case 1: m_maincpu->space(AS_PROGRAM).install_rom(0xc000, 0xc000 + slot->length() - 1, slot->get_rom_base()); break; case 2: m_maincpu->space(AS_PROGRAM).install_rom(0xd000, 0xd000 + slot->length() - 1, slot->get_rom_base()); break; } } // loading from software list. this supports multiple regions to load to else { UINT8 *region_b000 = image.get_software_region("b000"); UINT8 *region_c000 = image.get_software_region("c000"); UINT8 *region_d000 = image.get_software_region("d000"); if (region_b000 != nullptr) { UINT32 size = image.get_software_region_length("b000"); m_maincpu->space(AS_PROGRAM).install_rom(0xb000, 0xb000 + size - 1, region_b000); } if (region_c000 != nullptr) { UINT32 size = image.get_software_region_length("c000"); m_maincpu->space(AS_PROGRAM).install_rom(0xc000, 0xc000 + size - 1, region_c000); } if (region_d000 != nullptr) { UINT32 size = image.get_software_region_length("d000"); m_maincpu->space(AS_PROGRAM).install_rom(0xd000, 0xd000 + size - 1, region_d000); } } return image_init_result::PASS; }
int pcjr_state::load_cart(device_image_interface &image, generic_slot_device *slot) { UINT32 size = slot->common_get_size("rom"); bool imagic_hack = false; if (image.software_entry() == nullptr) { int header_size = 0; // Check for supported header sizes switch (size & 0x3ff) { case 0x80: header_size = 0x80; break; case 0x200: header_size = 0x200; break; default: image.seterror(IMAGE_ERROR_UNSUPPORTED, "Invalid header size" ); return IMAGE_INIT_FAIL; } if (size - header_size == 0xa000) { // alloc 64K for the imagic carts, so to handle the necessary mirroring size += 0x6000; imagic_hack = true; } size -= header_size; image.fseek(header_size, SEEK_SET); } slot->rom_alloc(size, GENERIC_ROM8_WIDTH, ENDIANNESS_LITTLE); slot->common_load_rom(slot->get_rom_base(), size, "rom"); if (imagic_hack) { // in this case the image consists of 2x8K chunks // the first chunk is unique, the second is repeated 4 times up to 0xa000 size // mirroring UINT8 *ROM = slot->get_rom_base(); memcpy(ROM + 0xe000, ROM + 0x2000, 0x2000); memcpy(ROM + 0xc000, ROM + 0x2000, 0x2000); memcpy(ROM + 0xa000, ROM + 0x2000, 0x2000); memcpy(ROM + 0x8000, ROM + 0x2000, 0x2000); memcpy(ROM + 0x6000, ROM, 0x2000); memcpy(ROM + 0x4000, ROM, 0x2000); memcpy(ROM + 0x2000, ROM, 0x2000); } return IMAGE_INIT_PASS; }
static void atari_load_proc(device_image_interface &image) { atari_fdc_t *fdc = get_safe_token(image.device().owner()); int id = floppy_get_drive(image); int size, i; const char *ext; fdc->drv[id].image = auto_alloc_array(image.device().machine(),UINT8,MAXSIZE); if (!fdc->drv[id].image) return; /* tell whether the image is writable */ fdc->drv[id].mode = !image.is_readonly(); /* set up image if it has been created */ if (image.has_been_created()) { int sector; char buff[256]; memset(buff, 0, sizeof(buff)); /* default to 720 sectors */ for( sector = 0; sector < 720; sector++ ) image.fwrite(buff, 256); image.fseek(0, SEEK_SET); } size = image.fread(fdc->drv[id].image, MAXSIZE); if( size <= 0 ) { fdc->drv[id].image = NULL; return; } /* re allocate the buffer; we don't want to be too lazy ;) */ //fdc->drv[id].image = (UINT8*)image.image_realloc(fdc->drv[id].image, size); ext = image.filetype(); // hack alert, this means we can only load ATR via the softlist at the moment, image.filetype reutrns NULL :/ if (image.software_entry() != NULL) ext="ATR"; /* no extension: assume XFD format (no header) */ if (!ext) { fdc->drv[id].type = FORMAT_XFD; fdc->drv[id].header_skip = 0; } else /* XFD extension */ if( toupper(ext[0])=='X' && toupper(ext[1])=='F' && toupper(ext[2])=='D' ) { fdc->drv[id].type = FORMAT_XFD; fdc->drv[id].header_skip = 0; } else /* ATR extension */ if( toupper(ext[0])=='A' && toupper(ext[1])=='T' && toupper(ext[2])=='R' ) { fdc->drv[id].type = FORMAT_ATR; fdc->drv[id].header_skip = 16; } else /* DSK extension */ if( toupper(ext[0])=='D' && toupper(ext[1])=='S' && toupper(ext[2])=='K' ) { fdc->drv[id].type = FORMAT_DSK; fdc->drv[id].header_skip = sizeof(dsk_format); } else { fdc->drv[id].type = FORMAT_XFD; fdc->drv[id].header_skip = 0; } if( fdc->drv[id].type == FORMAT_ATR && (fdc->drv[id].image[0] != 0x96 || fdc->drv[id].image[1] != 0x02) ) { fdc->drv[id].type = FORMAT_XFD; fdc->drv[id].header_skip = 0; } switch (fdc->drv[id].type) { /* XFD or unknown format: find a matching size from the table */ case FORMAT_XFD: for( i = 0; xfd_formats[i].size; i++ ) { if( size == xfd_formats[i].size ) { fdc->drv[id].density = xfd_formats[i].dsk.density; fdc->drv[id].tracks = xfd_formats[i].dsk.tracks; fdc->drv[id].spt = xfd_formats[i].dsk.spt; fdc->drv[id].heads = (xfd_formats[i].dsk.doublesided) ? 2 : 1; fdc->drv[id].bseclen = 128; fdc->drv[id].seclen = 256 * xfd_formats[i].dsk.seclen_hi + xfd_formats[i].dsk.seclen_lo; fdc->drv[id].sectors = fdc->drv[id].tracks * fdc->drv[id].heads * fdc->drv[id].spt; break; } } break; /* ATR format: find a size including the 16 bytes header */ case FORMAT_ATR: { int s; fdc->drv[id].bseclen = 128; /* get sectors from ATR header */ s = (size - 16) / 128; /* 3 + odd number of sectors ? */ if ( fdc->drv[id].image[4] == 128 || (s % 18) == 0 || (s % 26) == 0 || ((s - 3) % 1) != 0 ) { fdc->drv[id].sectors = s; fdc->drv[id].seclen = 128; /* sector size 128 or count not evenly dividable by 26 ? */ if( fdc->drv[id].seclen == 128 || (s % 26) != 0 ) { /* yup! single density */ fdc->drv[id].density = 0; fdc->drv[id].spt = 18; fdc->drv[id].heads = 1; fdc->drv[id].tracks = s / 18; if( s % 18 != 0 ) fdc->drv[id].tracks += 1; if( fdc->drv[id].tracks % 2 == 0 && fdc->drv[id].tracks > 80 ) { fdc->drv[id].heads = 2; fdc->drv[id].tracks /= 2; } } else { /* yes: medium density */ fdc->drv[id].density = 0; fdc->drv[id].spt = 26; fdc->drv[id].heads = 1; fdc->drv[id].tracks = s / 26; if( s % 26 != 0 ) fdc->drv[id].tracks += 1; if( fdc->drv[id].tracks % 2 == 0 && fdc->drv[id].tracks > 80 ) { fdc->drv[id].heads = 2; fdc->drv[id].tracks /= 2; } } } else { /* it's double density */ s = (s - 3) / 2 + 3; fdc->drv[id].sectors = s; fdc->drv[id].density = 2; fdc->drv[id].seclen = 256; fdc->drv[id].spt = 18; fdc->drv[id].heads = 1; fdc->drv[id].tracks = s / 18; if( s % 18 != 0 ) fdc->drv[id].tracks += 1; if( fdc->drv[id].tracks % 2 == 0 && fdc->drv[id].tracks > 80 ) { fdc->drv[id].heads = 2; fdc->drv[id].tracks /= 2; } } } break; /* DSK format: it's all in the header */ case FORMAT_DSK: { dsk_format *dsk = (dsk_format *) fdc->drv[id].image; fdc->drv[id].tracks = dsk->tracks; fdc->drv[id].spt = dsk->spt; fdc->drv[id].heads = (dsk->doublesided) ? 2 : 1; fdc->drv[id].seclen = 256 * dsk->seclen_hi + dsk->seclen_lo; fdc->drv[id].bseclen = fdc->drv[id].seclen; fdc->drv[id].sectors = fdc->drv[id].tracks * fdc->drv[id].heads * fdc->drv[id].spt; } break; } logerror("atari opened floppy '%s', %d sectors (%d %s%s) %d bytes/sector\n", image.filename(), fdc->drv[id].sectors, fdc->drv[id].tracks, (fdc->drv[id].heads == 1) ? "SS" : "DS", (fdc->drv[id].density == 0) ? "SD" : (fdc->drv[id].density == 1) ? "MD" : "DD", fdc->drv[id].seclen); return; }
void atari_fdc_device::atari_load_proc(device_image_interface &image, bool is_created) { int id = floppy_get_drive(image); int size, i; m_drv[id].image = std::make_unique<uint8_t[]>(MAXSIZE); if (!m_drv[id].image) return; /* tell whether the image is writable */ m_drv[id].mode = !image.is_readonly(); /* set up image if it has been created */ if (is_created) { int sector; char buff[256]; memset(buff, 0, sizeof(buff)); /* default to 720 sectors */ for( sector = 0; sector < 720; sector++ ) image.fwrite(buff, 256); image.fseek(0, SEEK_SET); } size = image.fread(m_drv[id].image.get(), MAXSIZE); if( size <= 0 ) { m_drv[id].image = nullptr; return; } /* re allocate the buffer; we don't want to be too lazy ;) */ //m_drv[id].image = (uint8_t*)image.image_realloc(m_drv[id].image, size); // hack alert, this means we can only load ATR via the softlist at the moment, image.filetype returns "" :/ bool is_softlist_entry = image.software_entry() != nullptr; /* no extension: assume XFD format (no header) */ if (image.is_filetype("") && !is_softlist_entry) { m_drv[id].type = FORMAT_XFD; m_drv[id].header_skip = 0; } else /* XFD extension */ if( image.is_filetype("xfd") ) { m_drv[id].type = FORMAT_XFD; m_drv[id].header_skip = 0; } else /* ATR extension */ if( image.is_filetype("atr") || is_softlist_entry) { m_drv[id].type = FORMAT_ATR; m_drv[id].header_skip = 16; } else /* DSK extension */ if( image.is_filetype("dsk") ) { m_drv[id].type = FORMAT_DSK; m_drv[id].header_skip = sizeof(atari_dsk_format); } else { m_drv[id].type = FORMAT_XFD; m_drv[id].header_skip = 0; } if( m_drv[id].type == FORMAT_ATR && (m_drv[id].image[0] != 0x96 || m_drv[id].image[1] != 0x02) ) { m_drv[id].type = FORMAT_XFD; m_drv[id].header_skip = 0; } switch (m_drv[id].type) { /* XFD or unknown format: find a matching size from the table */ case FORMAT_XFD: for( i = 0; xfd_formats[i].size; i++ ) { if( size == xfd_formats[i].size ) { m_drv[id].density = xfd_formats[i].dsk.density; m_drv[id].tracks = xfd_formats[i].dsk.tracks; m_drv[id].spt = xfd_formats[i].dsk.spt; m_drv[id].heads = (xfd_formats[i].dsk.doublesided) ? 2 : 1; m_drv[id].bseclen = 128; m_drv[id].seclen = 256 * xfd_formats[i].dsk.seclen_hi + xfd_formats[i].dsk.seclen_lo; m_drv[id].sectors = m_drv[id].tracks * m_drv[id].heads * m_drv[id].spt; break; } } break; /* ATR format: find a size including the 16 bytes header */ case FORMAT_ATR: { int s; m_drv[id].bseclen = 128; /* get sectors from ATR header */ s = (size - 16) / 128; /* 3 + odd number of sectors ? */ if ( m_drv[id].image[4] == 128 || (s % 18) == 0 || (s % 26) == 0 || ((s - 3) % 1) != 0 ) { m_drv[id].sectors = s; m_drv[id].seclen = 128; /* sector size 128 or count not evenly dividable by 26 ? */ if( m_drv[id].seclen == 128 || (s % 26) != 0 ) { /* yup! single density */ m_drv[id].density = 0; m_drv[id].spt = 18; m_drv[id].heads = 1; m_drv[id].tracks = s / 18; if( s % 18 != 0 ) m_drv[id].tracks += 1; if( m_drv[id].tracks % 2 == 0 && m_drv[id].tracks > 80 ) { m_drv[id].heads = 2; m_drv[id].tracks /= 2; } } else { /* yes: medium density */ m_drv[id].density = 0; m_drv[id].spt = 26; m_drv[id].heads = 1; m_drv[id].tracks = s / 26; if( s % 26 != 0 ) m_drv[id].tracks += 1; if( m_drv[id].tracks % 2 == 0 && m_drv[id].tracks > 80 ) { m_drv[id].heads = 2; m_drv[id].tracks /= 2; } } } else { /* it's double density */ s = (s - 3) / 2 + 3; m_drv[id].sectors = s; m_drv[id].density = 2; m_drv[id].seclen = 256; m_drv[id].spt = 18; m_drv[id].heads = 1; m_drv[id].tracks = s / 18; if( s % 18 != 0 ) m_drv[id].tracks += 1; if( m_drv[id].tracks % 2 == 0 && m_drv[id].tracks > 80 ) { m_drv[id].heads = 2; m_drv[id].tracks /= 2; } } } break; /* DSK format: it's all in the header */ case FORMAT_DSK: { atari_dsk_format *dsk = (atari_dsk_format *) m_drv[id].image.get(); m_drv[id].tracks = dsk->tracks; m_drv[id].spt = dsk->spt; m_drv[id].heads = (dsk->doublesided) ? 2 : 1; m_drv[id].seclen = 256 * dsk->seclen_hi + dsk->seclen_lo; m_drv[id].bseclen = m_drv[id].seclen; m_drv[id].sectors = m_drv[id].tracks * m_drv[id].heads * m_drv[id].spt; } break; } logerror("atari opened floppy '%s', %d sectors (%d %s%s) %d bytes/sector\n", image.filename(), m_drv[id].sectors, m_drv[id].tracks, (m_drv[id].heads == 1) ? "SS" : "DS", (m_drv[id].density == 0) ? "SD" : (m_drv[id].density == 1) ? "MD" : "DD", m_drv[id].seclen); return; }