//
// Corvus_HDC_File
//
// Returns a hard_disk_file object for a given virtual hard drive device in the concept
//
// Pass:
// drv: Corvus drive id (1..15)
//
// Returns:
// hard_disk_file object
//
hard_disk_file *corvus_hdc_t::corvus_hdc_file(int drv) {
static const char *const tags[] = {
"harddisk1", "harddisk2", "harddisk3", "harddisk4"
};
// we only support 4 drives, as per the tags[] table, so prevent a crash
// Corvus drive id numbers are 1-based so we check 1..4 instead of 0..3
if (drv < 1 || drv > 4)
{
return nullptr;
}
harddisk_image_device *img = siblingdevice<harddisk_image_device>(tags[drv - 1]);
if ( !img )
return nullptr;
if (!img->exists())
return nullptr;
// Pick up the Head/Cylinder/Sector info
hard_disk_file *file = img->get_hard_disk_file();
hard_disk_info *info = hard_disk_get_info(file);
m_sectors_per_track = info->sectors;
m_tracks_per_cylinder = info->heads;
m_cylinders_per_drive = info->cylinders;
LOG(("corvus_hdc_file: Attached to drive %u image: H:%d, C:%d, S:%d\n", drv, info->heads, info->cylinders, info->sectors));
return file;
}
/*
imghd_get_header()
Return pointer to the header of MAME HD image
*/
const hard_disk_info *imghd_get_header(struct mess_hard_disk_file *disk)
{
chd_interface interface_save;
const hard_disk_info *reply;
chd_save_interface(&interface_save);
chd_set_interface(&imgtool_chd_interface);
reply = hard_disk_get_info(disk->hard_disk);
chd_set_interface(&interface_save);
return reply;
}
void altos8600_state::machine_reset()
{
m_mode = (m_mode & 0x10) | 2;
m_cpuif = false;
m_user = false;
m_nmiinh = true;
m_nmistat = false;
m_cylhi = m_sechi = false;
m_stat = 0;
if(m_hdd->get_hard_disk_file())
m_geom = hard_disk_get_info(m_hdd->get_hard_disk_file());
else
m_geom = nullptr;
}
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);
}
void omti5100_device::WriteData( UINT8 *data, int dataLength )
{
switch( command[ 0 ] )
{
case OMTI_ASSIGN_DISK_PARAM:
{
int drive = ((command[1] >> 5) & 1);
hard_disk_file *image = (drive ? m_image1 : m_image0)->get_hard_disk_file();
m_param[drive].heads = data[3] + 1;
m_param[drive].cylinders = ((data[4] << 8) | data[5]) + 1;
if(!data[8] && image)
{
switch(hard_disk_get_info(image)->sectorbytes)
{
case 128:
m_param[drive].sectors = 53;
break;
case 256:
m_param[drive].sectors = 32;
break;
case 512:
m_param[drive].sectors = 18; // XXX: check this!
break;
case 1024:
m_param[drive].sectors = 9;
break;
}
}
else
m_param[drive].sectors = data[8] + 1;
break;
}
default:
scsihd_device::WriteData( data, dataLength );
break;
}
}
/*
imghd_get_header()
Return pointer to the header of MAME HD image
*/
const hard_disk_info *imghd_get_header(struct mess_hard_disk_file *disk)
{
const hard_disk_info *reply;
reply = hard_disk_get_info(disk->hard_disk);
return reply;
}
void omti5100_device::ExecCommand()
{
int drive = (command[1] >> 5) & 1;
hard_disk_file *image = (drive ? m_image1 : m_image0)->get_hard_disk_file();
if(!image)
{
if(command[0] == T10SPC_CMD_REQUEST_SENSE)
return scsihd_device::ExecCommand();
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
m_sense_asc = OMTI_STATUS_NOT_READY;
m_transfer_length = 0;
return;
}
hard_disk_info *info = hard_disk_get_info(image);
switch(command[0])
{
case OMTI_READ_DATA_BUFFER:
m_phase = SCSI_PHASE_DATAIN;
m_status_code = SCSI_STATUS_CODE_GOOD;
m_transfer_length = 512;
break;
case OMTI_ASSIGN_DISK_PARAM:
m_phase = SCSI_PHASE_DATAOUT;
m_status_code = SCSI_STATUS_CODE_GOOD;
m_transfer_length = 10;
break;
case OMTI_CHECK_TRACK_FORMAT:
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_GOOD;
m_transfer_length = 0;
break;
case T10SBC_CMD_READ_6:
{
int track = ((command[1]&0x1f)<<16 | command[2]<<8 | command[3]) / (m_param[drive].sectors ? m_param[drive].sectors : 1);
int heads = m_param[drive].heads ? m_param[drive].heads : 1;
if(((track % heads) > info->heads) || (track >= (info->cylinders * heads)))
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
m_sense_asc = OMTI_STATUS_SEEK_FAIL;
m_transfer_length = 0;
}
else
{
SetDevice(image);
scsihd_device::ExecCommand();
}
break;
}
case OMTI_FORMAT_TRACK:
{
int track = ((command[1]&0x1f)<<16 | command[2]<<8 | command[3]) / m_param[drive].sectors;
if(((track % m_param[drive].heads) <= info->heads) && (track < (info->cylinders * m_param[drive].heads)))
{
dynamic_buffer sector(info->sectorbytes);
memset(§or[0], 0xe5, info->sectorbytes);
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_GOOD;
m_transfer_length = 0;
for(int i = 0; i < info->sectors; i++)
hard_disk_write(image, track * info->sectors + i, §or[0]);
}
else
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
m_sense_asc = OMTI_STATUS_SEEK_FAIL;
m_transfer_length = 0;
}
break;
}
default:
SetDevice(image);
scsihd_device::ExecCommand();
break;
}
}
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;
}
