/*
imghd_open()
Open stream as a MAME HD image
*/
imgtoolerr_t imghd_open(imgtool::stream &stream, struct mess_hard_disk_file *hard_disk)
{
chd_error chderr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
hard_disk->hard_disk = nullptr;
hard_disk->chd = nullptr;
chderr = hard_disk->chd->open(*stream.core_file(), stream.is_read_only());
if (chderr)
{
err = map_chd_error(chderr);
goto done;
}
hard_disk->hard_disk = hard_disk_open(hard_disk->chd);
if (!hard_disk->hard_disk)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
hard_disk->stream = &stream;
done:
if (err)
imghd_close(hard_disk);
return err;
}
/*
imghd_open()
Open stream as a MAME HD image
*/
imgtoolerr_t imghd_open(imgtool_stream *stream, struct mess_hard_disk_file *hard_disk)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
char encoded_image_ref[encoded_image_ref_max_len];
chd_interface interface_save;
hard_disk->hard_disk = NULL;
hard_disk->chd = NULL;
encode_image_ref(stream, encoded_image_ref);
/* use our CHD interface */
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
hard_disk->chd = chd_open(encoded_image_ref, !stream_isreadonly(stream), NULL);
if (!hard_disk->chd)
{
err = imghd_chd_getlasterror();
goto done;
}
hard_disk->hard_disk = hard_disk_open(hard_disk->chd);
if (!hard_disk->hard_disk)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
hard_disk->stream = stream;
done:
if (err)
imghd_close(hard_disk);
chd_set_interface(&interface_save);
return err;
}
/*
imghd_open()
Open stream as a MAME HD image
*/
imgtoolerr_t imghd_open(imgtool_stream *stream, struct mess_hard_disk_file *hard_disk)
{
chd_error chderr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
hard_disk->hard_disk = NULL;
hard_disk->chd = NULL;
chderr = hard_disk->chd->open(*stream_core_file(stream), stream_isreadonly(stream));
if (chderr)
{
err = map_chd_error(chderr);
goto done;
}
hard_disk->hard_disk = hard_disk_open(hard_disk->chd);
if (!hard_disk->hard_disk)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
hard_disk->stream = stream;
done:
if (err)
imghd_close(hard_disk);
return err;
}
static int internal_load_mess_hd(mess_image *image, const char *metadata)
{
int err = 0;
struct mess_hd *hd;
chd_file *chd;
int is_writeable;
int id = image_index_in_device(image);
hd = get_drive(image);
/* open the CHD file */
do
{
is_writeable = image_is_writable(image);
chd = chd_open_ref(image, is_writeable, NULL);
if (!chd)
{
err = chd_get_last_error();
/* special case; if we get CHDERR_FILE_NOT_WRITEABLE, make the
* image read only and repeat */
if (err == CHDERR_FILE_NOT_WRITEABLE)
image_make_readonly(image);
}
}
while(!chd && is_writeable && (err == CHDERR_FILE_NOT_WRITEABLE));
if (!chd)
goto error;
/* if we created the image and hence, have metadata to set, set the metadata */
if (metadata)
{
err = chd_set_metadata(chd, HARD_DISK_STANDARD_METADATA, 0, metadata, strlen(metadata) + 1);
if (err != CHDERR_NONE)
goto error;
}
/* open the hard disk file */
hd->hard_disk_handle = hard_disk_open(chd);
if (!hd->hard_disk_handle)
goto error;
drive_handles[id] = hd->hard_disk_handle;
return INIT_PASS;
error:
if (chd)
chd_close(chd);
err = chd_get_last_error();
if (err)
image_seterror(image, IMAGE_ERROR_UNSPECIFIED, chd_get_error_string(err));
return INIT_FAIL;
}
int harddisk_image_device::internal_load_hd()
{
astring tempstring;
chd_error err = CHDERR_NONE;
m_chd = NULL;
if (m_hard_disk_handle)
hard_disk_close(m_hard_disk_handle);
/* open the CHD file */
if (software_entry() != NULL)
{
m_chd = get_disk_handle(device().machine(), device().subtag(tempstring,"harddriv"));
}
else
{
err = m_origchd.open(*image_core_file(), true);
if (err == CHDERR_NONE)
{
m_chd = &m_origchd;
}
else if (err == CHDERR_FILE_NOT_WRITEABLE)
{
err = m_origchd.open(*image_core_file(), false);
if (err == CHDERR_NONE)
{
err = open_disk_diff(device().machine().options(), basename_noext(), m_origchd, m_diffchd);
if (err == CHDERR_NONE)
{
m_chd = &m_diffchd;
}
}
}
}
if (m_chd != NULL)
{
/* open the hard disk file */
m_hard_disk_handle = hard_disk_open(m_chd);
if (m_hard_disk_handle != NULL)
return IMAGE_INIT_PASS;
}
/* if we had an error, close out the CHD */
m_origchd.close();
m_diffchd.close();
m_chd = NULL;
seterror(IMAGE_ERROR_UNSPECIFIED, chd_file::error_string(err));
return IMAGE_INIT_FAIL;
}
image_init_result harddisk_image_device::internal_load_hd()
{
chd_error err = CHDERR_NONE;
m_chd = nullptr;
if (m_hard_disk_handle)
hard_disk_close(m_hard_disk_handle);
/* open the CHD file */
if (software_entry() != nullptr)
{
m_chd = machine().rom_load().get_disk_handle(device().subtag("harddriv").c_str());
}
else
{
err = m_origchd.open(image_core_file(), true);
if (err == CHDERR_NONE)
{
m_chd = &m_origchd;
}
else if (err == CHDERR_FILE_NOT_WRITEABLE)
{
err = m_origchd.open(image_core_file(), false);
if (err == CHDERR_NONE)
{
err = open_disk_diff(device().machine().options(), basename_noext(), m_origchd, m_diffchd);
if (err == CHDERR_NONE)
{
m_chd = &m_diffchd;
}
}
}
}
if (m_chd != nullptr)
{
/* open the hard disk file */
m_hard_disk_handle = hard_disk_open(m_chd);
if (m_hard_disk_handle != nullptr)
return image_init_result::PASS;
}
/* if we had an error, close out the CHD */
m_origchd.close();
m_diffchd.close();
m_chd = nullptr;
seterror(IMAGE_ERROR_UNSPECIFIED, chd_file::error_string(err));
return image_init_result::FAIL;
}
void harddisk_image_device::device_start()
{
m_chd = nullptr;
// try to locate the CHD from a DISK_REGION
chd_file *handle = machine().rom_load().get_disk_handle(tag());
if (handle != nullptr)
{
m_hard_disk_handle = hard_disk_open(handle);
}
else
{
m_hard_disk_handle = nullptr;
}
}
void harddisk_image_device::device_start()
{
m_chd = NULL;
// try to locate the CHD from a DISK_REGION
chd_file *handle = get_disk_handle(machine(), tag());
if (handle != NULL)
{
m_hard_disk_handle = hard_disk_open(handle);
}
else
{
m_hard_disk_handle = NULL;
}
}
int harddisk_image_device::internal_load_hd(const char *metadata)
{
chd_error err = (chd_error)0;
int is_writeable;
/* open the CHD file */
do
{
is_writeable = !is_readonly();
m_chd = NULL;
err = chd_open_file(image_core_file(), is_writeable ? CHD_OPEN_READWRITE : CHD_OPEN_READ, NULL, &m_chd);
/* special case; if we get CHDERR_FILE_NOT_WRITEABLE, make the
* image read only and repeat */
if (err == CHDERR_FILE_NOT_WRITEABLE)
make_readonly();
}
while(!m_chd && is_writeable && (err == CHDERR_FILE_NOT_WRITEABLE));
if (!m_chd)
goto done;
/* if we created the image and hence, have metadata to set, set the metadata */
if (metadata)
{
err = chd_set_metadata(m_chd, HARD_DISK_METADATA_TAG, 0, metadata, strlen(metadata) + 1, 0);
if (err != CHDERR_NONE)
goto done;
}
/* open the hard disk file */
m_hard_disk_handle = hard_disk_open(m_chd);
if (!m_hard_disk_handle)
goto done;
done:
if (err)
{
/* if we had an error, close out the CHD */
if (m_chd != NULL)
{
chd_close(m_chd);
m_chd = NULL;
}
seterror(IMAGE_ERROR_UNSPECIFIED, chd_get_error_string(err));
}
return err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
void am53cf96_init( struct AM53CF96interface *interface )
{
const struct hard_disk_info *hdinfo;
// save interface pointer for later
intf = interface;
memset(scsi_regs, 0, sizeof(scsi_regs));
// try to open the disk
if (interface->device == AM53CF96_DEVICE_HDD)
{
disk = hard_disk_open(get_disk_handle(0));
if (!disk)
{
logerror("53cf96: no disk found!\n");
}
else
{
hdinfo = hard_disk_get_info(disk);
if (hdinfo->sectorbytes != 512)
{
logerror("53cf96: Error! invalid sector size %d\n", hdinfo->sectorbytes);
}
}
}
else if (interface->device == AM53CF96_DEVICE_CDROM)
{
logerror("53cf96: CDROM not yet supported!\n");
}
else
{
logerror("53cf96: unknown device type!\n");
}
state_save_register_UINT8("53cf96", 0, "registers", scsi_regs, 32);
state_save_register_UINT8("53cf96", 0, "fifo", fifo, 16);
state_save_register_UINT8("53cf96", 0, "fifo pointer", &fptr, 1);
state_save_register_UINT8("53cf96", 0, "last scsi-2 command", &last_cmd, 1);
state_save_register_UINT8("53cf96", 0, "transfer state", &xfer_state, 1);
state_save_register_int("53cf96", 0, "current lba", &lba);
state_save_register_int("53cf96", 0, "blocks to read", &blocks);
}
/*
imghd_open()
Open stream as a MAME HD image
*/
imgtoolerr_t imghd_open(imgtool_stream *stream, struct mess_hard_disk_file *hard_disk)
{
chd_error chderr;
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
char encoded_image_ref[encoded_image_ref_max_len];
chd_interface interface_save;
hard_disk->hard_disk = NULL;
hard_disk->chd = NULL;
encode_image_ref(stream, encoded_image_ref);
/* use our CHD interface */
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
chderr = chd_open(encoded_image_ref, stream_isreadonly(stream) ? CHD_OPEN_READ : CHD_OPEN_READWRITE, NULL, &hard_disk->chd);
if (chderr)
{
err = map_chd_error(chderr);
goto done;
}
hard_disk->hard_disk = hard_disk_open(hard_disk->chd);
if (!hard_disk->hard_disk)
{
err = IMGTOOLERR_UNEXPECTED;
goto done;
}
hard_disk->stream = stream;
done:
if (err)
imghd_close(hard_disk);
chd_set_interface(&interface_save);
return err;
}
int ide_controller_init_custom(int which, struct ide_interface *intf, struct chd_file *diskhandle)
{
struct ide_state *ide = &idestate[which];
const struct hard_disk_info *hdinfo;
/* NULL interface is immediate failure */
if (!intf)
return 1;
/* reset the IDE state */
memset(ide, 0, sizeof(*ide));
ide->intf = intf;
/* set MAME harddisk handle */
ide->disk = hard_disk_open(diskhandle);
/* get and copy the geometry */
if (ide->disk)
{
hdinfo = hard_disk_get_info(ide->disk);
ide->num_cylinders = hdinfo->cylinders;
ide->num_sectors = hdinfo->sectors;
ide->num_heads = hdinfo->heads;
if (hdinfo->sectorbytes != IDE_DISK_SECTOR_SIZE)
/* wrong sector len */
return 1;
#if PRINTF_IDE_COMMANDS
printf("CHS: %d %d %d\n", ide->num_cylinders, ide->num_heads, ide->num_sectors);
#endif
}
/* build the features page */
ide_build_features(ide);
/* create a timer for timing status */
ide->last_status_timer = timer_alloc(NULL);
ide->reset_timer = timer_alloc(reset_callback);
/* register ide status */
state_save_register_UINT8 ("ide", which, "adapter_control", &ide->adapter_control, 1);
state_save_register_UINT8 ("ide", which, "status", &ide->status, 1);
state_save_register_UINT8 ("ide", which, "error", &ide->error, 1);
state_save_register_UINT8 ("ide", which, "command", &ide->command, 1);
state_save_register_UINT8 ("ide", which, "interrupt_pending", &ide->interrupt_pending, 1);
state_save_register_UINT8 ("ide", which, "precomp_offset", &ide->precomp_offset, 1);
state_save_register_UINT8 ("ide", which, "buffer", ide->buffer, IDE_DISK_SECTOR_SIZE);
state_save_register_UINT8 ("ide", which, "features", ide->features, IDE_DISK_SECTOR_SIZE);
state_save_register_UINT16("ide", which, "buffer_offset", &ide->buffer_offset, 1);
state_save_register_UINT16("ide", which, "sector_count", &ide->sector_count, 1);
state_save_register_UINT16("ide", which, "block_count", &ide->block_count, 1);
state_save_register_UINT16("ide", which, "sectors_until_int", &ide->sectors_until_int, 1);
state_save_register_UINT8 ("ide", which, "dma_active", &ide->dma_active, 1);
state_save_register_UINT8 ("ide", which, "dma_cpu", &ide->dma_cpu, 1);
state_save_register_UINT8 ("ide", which, "dma_address_xor", &ide->dma_address_xor, 1);
state_save_register_UINT8 ("ide", which, "dma_last_buffer", &ide->dma_last_buffer, 1);
state_save_register_UINT32("ide", which, "dma_address", &ide->dma_address, 1);
state_save_register_UINT32("ide", which, "dma_descriptor", &ide->dma_descriptor, 1);
state_save_register_UINT32("ide", which, "dma_bytes_left", &ide->dma_bytes_left, 1);
state_save_register_UINT8 ("ide", which, "bus_master_command", &ide->bus_master_command, 1);
state_save_register_UINT8 ("ide", which, "bus_master_status", &ide->bus_master_status, 1);
state_save_register_UINT32("ide", which, "bus_master_descriptor", &ide->bus_master_descriptor, 1);
state_save_register_UINT16("ide", which, "cur_cylinder", &ide->cur_cylinder, 1);
state_save_register_UINT8 ("ide", which, "cur_sector", &ide->cur_sector, 1);
state_save_register_UINT8 ("ide", which, "cur_head", &ide->cur_head, 1);
state_save_register_UINT8 ("ide", which, "cur_head_reg", &ide->cur_head_reg, 1);
state_save_register_UINT32("ide", which, "cur_lba", &ide->cur_lba, 1);
state_save_register_UINT16("ide", which, "num_cylinders", &ide->num_cylinders, 1);
state_save_register_UINT8 ("ide", which, "num_sectors", &ide->num_sectors, 1);
state_save_register_UINT8 ("ide", which, "num_heads", &ide->num_heads, 1);
state_save_register_UINT8 ("ide", which, "config_unknown", &ide->config_unknown, 1);
state_save_register_UINT8 ("ide", which, "config_register", ide->config_register, IDE_CONFIG_REGISTERS);
state_save_register_UINT8 ("ide", which, "config_register_num", &ide->config_register_num, 1);
state_save_register_int ("ide", which, "master_password_enable", &ide->master_password_enable);
state_save_register_int ("ide", which, "user_password_enable", &ide->user_password_enable);
return 0;
}
