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