static WRITE8_HANDLER(elwro800jr_fdc_control_w)
{
device_t *fdc = space->machine().device("upd765");
floppy_mon_w(floppy_get_device(space->machine(), 0), !BIT(data, 0));
floppy_mon_w(floppy_get_device(space->machine(), 1), !BIT(data, 1));
floppy_drive_set_ready_state(floppy_get_device(space->machine(), 0), 1,1);
floppy_drive_set_ready_state(floppy_get_device(space->machine(), 1), 1,1);
upd765_tc_w(fdc, data & 0x04);
upd765_reset_w(fdc, !(data & 0x08));
}
void hec2hrp_state::hector_minidisc_init()
{
fd1793_device *fdc = machine().device<fd1793_device>("wd179x");
//set density
fdc->dden_w(1);// density select => always 1 (0 ?a plante !)
/* FDC Motor Control - Bit 0/1 defines the state of the FDD 0/1 motor */
floppy_get_device(machine(), 0)->floppy_mon_w( 0); // Moteur floppy A:
//floppy_get_device(machine(), 1)->floppy_mon_w(BIT(data, 7)); // Moteur floppy B:, not implanted on the real machine
//Set the drive ready !
floppy_get_device(machine(), 0)->floppy_drive_set_ready_state(FLOPPY_DRIVE_READY, 0);// Disc 0 ready !
}
void vtech1_state::vtech1_put_track()
{
/* drive selected and image file ok? */
if (m_drive >= 0 && floppy_get_device(machine(),m_drive) != NULL)
{
int size, offs;
device_image_interface *image = dynamic_cast<device_image_interface *>(floppy_get_device(machine(),m_drive));
offs = TRKSIZE_VZ * m_fdc_track_x2[m_drive]/2;
image->fseek(offs + m_fdc_start, SEEK_SET);
size = image->fwrite(&m_fdc_data[m_fdc_start], m_fdc_write);
if (LOG_VTECH1_FDC)
logerror("put track @$%05X+$%X $%04X/$%04X bytes\n", offs, m_fdc_start, size, m_fdc_write);
}
}
void thomson_state::to7_qdd_reset()
{
int i;
LOG(( "to7_qdd_reset: CQ 90-028 controller\n" ));
for ( i = 0; i < floppy_get_count( machine() ); i++ )
{
legacy_floppy_image_device * img = floppy_get_device( machine(), i );
if (img) {
img->floppy_drive_set_ready_state( FLOPPY_DRIVE_READY, 0 );
motor_on = CLEAR_LINE;
img->floppy_mon_w( motor_on);
/* pulse each time the whole-disk spiraling track ends */
/* at 90us per byte read, the disk can be read in 6s */
img->floppy_drive_set_rpm( 60. / 6. );
}
}
to7qdd->ctrl1 |= QDD_C1_TRESET | QDD_C1_RRESET; /* reset */
to7qdd->ctrl2 &= 0x7c; /* clear EIE, PC2-PC1 */
to7qdd->ctrl3 &= 0xfe; /* internal sync */
to7qdd->drive = 0;
to7_qdd_stat_update();
}
void thomson_state::thmfc_floppy_reset()
{
int i;
LOG(( "thmfc_floppy_reset: THMFC1 controller\n" ));
for ( i = 0; i < floppy_get_count( machine() ); i++ )
{
legacy_floppy_image_device * img = floppy_get_device( machine(), i );
if (img) {
img->floppy_drive_set_ready_state( FLOPPY_DRIVE_READY, 0 );
img->floppy_drive_seek( - img->floppy_drive_get_current_track() );
}
}
thmfc1->op = THMFC1_OP_RESET;
thmfc1->track = 0;
thmfc1->sector = 0;
thmfc1->side = 0;
thmfc1->drive = 0;
thmfc1->sector_size = 256;
thmfc1->formatting = 0;
thmfc1->stat0 = 0;
thmfc1->data_idx = 0;
thmfc1->data_size = 0;
thmfc1->data_raw_idx = 0;
thmfc1->data_raw_size = 0;
thmfc1->data_crc = 0;
thmfc1->wsync = 0;
thmfc_floppy_cmd->adjust(attotime::never);
}
static void vtech1_put_track(running_machine &machine)
{
vtech1_state *vtech1 = machine.driver_data<vtech1_state>();
/* drive selected and image file ok? */
if (vtech1->m_drive >= 0 && floppy_get_device(machine,vtech1->m_drive) != NULL)
{
int size, offs;
device_image_interface *image = dynamic_cast<device_image_interface *>(floppy_get_device(machine,vtech1->m_drive));
offs = TRKSIZE_VZ * vtech1->m_fdc_track_x2[vtech1->m_drive]/2;
image->fseek(offs + vtech1->m_fdc_start, SEEK_SET);
size = image->fwrite(&vtech1->m_fdc_data[vtech1->m_fdc_start], vtech1->m_fdc_write);
if (LOG_VTECH1_FDC)
logerror("put track @$%05X+$%X $%04X/$%04X bytes\n", offs, vtech1->m_fdc_start, size, vtech1->m_fdc_write);
}
}
DRIVER_INIT_MEMBER(vtech1_state,vtech1)
{
address_space &prg = m_maincpu->space(AS_PROGRAM);
int id;
/* ram */
m_ram_pointer = m_ram->pointer();
m_ram_size = m_ram->size();
/* setup memory banking */
membank("bank1")->set_base(m_ram_pointer);
/* 16k memory expansion? */
if (m_ram_size == 18*1024 || m_ram_size == 22*1024 || m_ram_size == 32*1024)
{
offs_t base = 0x7800 + (m_ram_size - 0x4000);
prg.install_readwrite_bank(base, base + 0x3fff, "bank2");
membank("bank2")->set_base(m_ram_pointer + base - 0x7800);
}
/* 64k expansion? */
if (m_ram_size >= 66*1024)
{
/* install fixed first bank */
prg.install_readwrite_bank(0x8000, 0xbfff, "bank2");
membank("bank2")->set_base(m_ram_pointer + 0x800);
/* install the others, dynamically banked in */
prg.install_readwrite_bank(0xc000, 0xffff, "bank3");
membank("bank3")->configure_entries(0, (m_ram_size - 0x4800) / 0x4000, m_ram_pointer + 0x4800, 0x4000);
membank("bank3")->set_entry(0);
}
/* initialize floppy */
m_drive = -1;
m_fdc_track_x2[0] = 80;
m_fdc_track_x2[1] = 80;
m_fdc_wrprot[0] = 0x80;
m_fdc_wrprot[1] = 0x80;
m_fdc_status = 0;
m_fdc_edge = 0;
m_fdc_bits = 8;
m_fdc_start = 0;
m_fdc_write = 0;
m_fdc_offs = 0;
m_fdc_latch = 0;
for(id=0; id<2; id++)
{
floppy_install_load_proc(floppy_get_device(machine(), id), vtech1_load_proc);
}
}
int floppy_get_drive_by_type(device_t *image,int ftype)
{
int i,drive =0;
for (i=0;i<4;i++) {
device_t *disk = floppy_get_device(image->machine(),i);
if (floppy_get_drive_type(disk)==ftype) {
if (image==disk) {
return drive;
}
drive++;
}
}
return drive;
}
int floppy_get_drive_by_type(legacy_floppy_image_device *image,int ftype)
{
int i,drive =0;
for (i=0;i<4;i++) {
legacy_floppy_image_device *disk = floppy_get_device(image->machine(),i);
if (disk->floppy_get_drive_type()==ftype) {
if (image==disk) {
return drive;
}
drive++;
}
}
return drive;
}
void thomson_state::to7_5p14sd_reset()
{
int i;
LOG(( "to7_5p14sd_reset: CD 90-015 controller\n" ));
for ( i = 0; i < floppy_get_count( machine() ); i++ )
{
legacy_floppy_image_device * img = floppy_get_device( machine(), i );
if (img) {
img->floppy_drive_set_ready_state( FLOPPY_DRIVE_READY, 0 );
img->floppy_drive_set_rpm( 300. );
img->floppy_drive_seek( - img->floppy_drive_get_current_track() );
}
}
}
device_t *floppy_get_device_by_type(running_machine &machine,int ftype,int drive)
{
int i;
int cnt = 0;
for (i=0;i<4;i++) {
device_t *disk = floppy_get_device(machine,i);
if (floppy_get_drive_type(disk)==ftype) {
if (cnt==drive) {
return disk;
}
cnt++;
}
}
return NULL;
}
legacy_floppy_image_device *floppy_get_device_by_type(running_machine &machine,int ftype,int drive)
{
int i;
int cnt = 0;
for (i=0;i<4;i++) {
legacy_floppy_image_device *disk = floppy_get_device(machine,i);
if (disk->floppy_get_drive_type()==ftype) {
if (cnt==drive) {
return disk;
}
cnt++;
}
}
return nullptr;
}
void vtech1_state::vtech1_get_track()
{
device_image_interface *image = dynamic_cast<device_image_interface *>(floppy_get_device(machine(),m_drive));
/* drive selected or and image file ok? */
if (m_drive >= 0 && image->exists())
{
int size, offs;
size = TRKSIZE_VZ;
offs = TRKSIZE_VZ * m_fdc_track_x2[m_drive]/2;
image->fseek(offs, SEEK_SET);
size = image->fread(m_fdc_data, size);
if (LOG_VTECH1_FDC)
logerror("get track @$%05x $%04x bytes\n", offs, size);
}
m_fdc_offs = 0;
m_fdc_write = 0;
}
static void vtech1_get_track(running_machine &machine)
{
vtech1_state *vtech1 = machine.driver_data<vtech1_state>();
device_image_interface *image = dynamic_cast<device_image_interface *>(floppy_get_device(machine,vtech1->m_drive));
/* drive selected or and image file ok? */
if (vtech1->m_drive >= 0 && image->exists())
{
int size, offs;
size = TRKSIZE_VZ;
offs = TRKSIZE_VZ * vtech1->m_fdc_track_x2[vtech1->m_drive]/2;
image->fseek(offs, SEEK_SET);
size = image->fread(vtech1->m_fdc_data, size);
if (LOG_VTECH1_FDC)
logerror("get track @$%05x $%04x bytes\n", offs, size);
}
vtech1->m_fdc_offs = 0;
vtech1->m_fdc_write = 0;
}
void osborne1_state::machine_reset()
{
int drive;
address_space& space = m_maincpu->space(AS_PROGRAM);
/* Initialize memory configuration */
osborne1_bankswitch_w( space, 0x00, 0 );
m_pia_0_irq_state = FALSE;
m_pia_1_irq_state = FALSE;
m_in_irq_handler = 0;
m_p_chargen = memregion( "chargen" )->base();
memset( m_ram->pointer() + 0x10000, 0xFF, 0x1000 );
for(drive=0;drive<2;drive++)
floppy_install_load_proc(floppy_get_device(machine(), drive), osborne1_load_proc);
space.set_direct_update_handler(direct_update_delegate(FUNC(osborne1_state::osborne1_opbase), this));
}
legacy_floppy_image_device* mc6843_device::floppy_image( UINT8 drive )
{
legacy_floppy_image_device *img = floppy_get_device( machine(), drive );
if (!img && owner()) {
// For slot devices, drives are typically attached to the slot rather than the machine
const char *floppy_name = nullptr;
switch (drive) {
case 0:
floppy_name = FLOPPY_0;
break;
case 1:
floppy_name = FLOPPY_1;
break;
case 2:
floppy_name = FLOPPY_2;
break;
case 3:
floppy_name = FLOPPY_3;
break;
}
img = owner()->subdevice<legacy_floppy_image_device>(floppy_name);
}
return img;
}
void fd800_machine_init(running_machine &machine, void (*interrupt_callback)(running_machine &machine, int state))
{
int i;
fd800.machine = &machine;
fd800.interrupt_callback = interrupt_callback;
fd800.stat_reg = 0;
fd800.interrupt_f_f = 1;
fd800.buf_pos = 0;
fd800.buf_mode = bm_off;
for (i=0; i<MAX_FLOPPIES; i++)
{
fd800.drv[i].img = dynamic_cast<device_image_interface *>(floppy_get_device(machine, i));
fd800.drv[i].phys_cylinder = -1;
fd800.drv[i].log_cylinder[0] = fd800.drv[i].log_cylinder[1] = -1;
fd800.drv[i].seclen = 64;
floppy_install_unload_proc(&fd800.drv[i].img->device(), fd800_unload_proc);
}
fd800_field_interrupt();
}
legacy_floppy_image_device * thomson_state::to7_qdd_image()
{
return floppy_get_device( machine(), 0 );
}
DEVCB_NULL,
DEVCB_HANDLER(b2m_8255_portb_r),
DEVCB_NULL,
DEVCB_HANDLER(b2m_8255_porta_w),
DEVCB_HANDLER(b2m_8255_portb_w),
DEVCB_HANDLER(b2m_8255_portc_w)
};
static WRITE8_DEVICE_HANDLER (b2m_ext_8255_portc_w )
{
UINT8 drive = ((data >> 1) & 1) ^ 1;
UINT8 side = (data & 1) ^ 1;
b2m_state *state = device->machine().driver_data<b2m_state>();
floppy_mon_w(floppy_get_device(device->machine(), 0), 1);
floppy_mon_w(floppy_get_device(device->machine(), 1), 1);
if (state->m_b2m_drive!=drive) {
wd17xx_set_drive(state->m_fdc,drive);
floppy_mon_w(floppy_get_device(device->machine(), 0), 0);
floppy_drive_set_ready_state(floppy_get_device(device->machine(), 0), 1, 1);
state->m_b2m_drive = drive;
}
if (state->m_b2m_side!=side) {
wd17xx_set_side(state->m_fdc,side);
floppy_mon_w(floppy_get_device(device->machine(), 1), 0);
floppy_drive_set_ready_state(floppy_get_device(device->machine(), 1), 1, 1);
state->m_b2m_side = side;
}
wd17xx_dden_w(state->m_fdc, 0);
legacy_floppy_image_device * thomson_state::thmfc_floppy_image()
{
return floppy_get_device( machine(), thmfc1->drive );
}
static device_t* mc6843_floppy_image ( device_t *device )
{
mc6843_t* mc6843 = get_safe_token( device );
return floppy_get_device( device->machine(), mc6843->drive );
}
