262 lines
6.4 KiB
C
262 lines
6.4 KiB
C
/*
|
|
* VARCem Virtual Archaelogical Computer EMulator.
|
|
* An emulator of (mostly) x86-based PC systems and devices,
|
|
* using the ISA,EISA,VLB,MCA and PCI system buses, roughly
|
|
* spanning the era between 1981 and 1995.
|
|
*
|
|
* This file is part of the VARCem Project.
|
|
*
|
|
* Handling of the SCSI controllers.
|
|
*
|
|
* Version: @(#)scsi.c 1.0.1 2018/02/14
|
|
*
|
|
* Authors: Fred N. van Kempen, <decwiz@yahoo.com>
|
|
* Miran Grca, <mgrca8@gmail.com>
|
|
* TheCollector1995, <mariogplayer@gmail.com>
|
|
*
|
|
* Copyright 2017,2018 Fred N. van Kempen.
|
|
* Copyright 2016-2018 Miran Grca.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the:
|
|
*
|
|
* Free Software Foundation, Inc.
|
|
* 59 Temple Place - Suite 330
|
|
* Boston, MA 02111-1307
|
|
* USA.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <wchar.h>
|
|
#include "../emu.h"
|
|
#include "../mem.h"
|
|
#include "../rom.h"
|
|
#include "../timer.h"
|
|
#include "../device.h"
|
|
#include "../cdrom/cdrom.h"
|
|
#include "../zip.h"
|
|
#include "../disk/hdc.h"
|
|
#include "../plat.h"
|
|
#include "scsi.h"
|
|
#include "scsi_aha154x.h"
|
|
#include "scsi_buslogic.h"
|
|
#include "scsi_ncr5380.h"
|
|
#include "scsi_ncr53c810.h"
|
|
#ifdef WALTJE
|
|
# include "scsi_wd33c93.h"
|
|
#endif
|
|
#include "scsi_x54x.h"
|
|
|
|
|
|
scsi_device_t SCSIDevices[SCSI_ID_MAX][SCSI_LUN_MAX];
|
|
#if 0
|
|
uint8_t SCSIPhase = 0xff;
|
|
uint8_t SCSIStatus = SCSI_STATUS_OK;
|
|
#endif
|
|
char scsi_fn[SCSI_NUM][512];
|
|
uint16_t scsi_hd_location[SCSI_NUM];
|
|
|
|
int scsi_card_current = 0;
|
|
int scsi_card_last = 0;
|
|
|
|
uint32_t SCSI_BufferLength;
|
|
static volatile
|
|
mutex_t *scsiMutex;
|
|
|
|
|
|
typedef struct {
|
|
const char *name;
|
|
const char *internal_name;
|
|
device_t *device;
|
|
void (*reset)(void *p);
|
|
} SCSI_CARD;
|
|
|
|
|
|
static SCSI_CARD scsi_cards[] = {
|
|
{ "None", "none", NULL, NULL },
|
|
{ "[ISA] Adaptec AHA-1540B","aha1540b", &aha1540b_device, x54x_device_reset },
|
|
{ "[ISA] Adaptec AHA-1542C","aha1542c", &aha1542c_device, x54x_device_reset },
|
|
{ "[ISA] Adaptec AHA-1542CF","aha1542cf", &aha1542cf_device, x54x_device_reset },
|
|
{ "[ISA] BusLogic BT-542BH","bt542bh", &buslogic_device, BuslogicDeviceReset },
|
|
{ "[ISA] BusLogic BT-545S", "bt545s", &buslogic_545s_device,BuslogicDeviceReset },
|
|
{ "[ISA] Longshine LCS-6821N","lcs6821n", &scsi_lcs6821n_device,NULL },
|
|
{ "[ISA] Ranco RT1000B", "rt1000b", &scsi_rt1000b_device, NULL },
|
|
{ "[ISA] Trantor T130B", "t130b", &scsi_t130b_device, NULL },
|
|
{ "[ISA] Sumo SCSI-AT", "scsiat", &scsi_scsiat_device, NULL },
|
|
#ifdef WALTJE_SCSI
|
|
{ "[ISA] Generic WDC33C93", "wd33c93", &scsi_wd33c93_device, NULL },
|
|
#endif
|
|
{ "[MCA] Adaptec AHA-1640", "aha1640", &aha1640_device, x54x_device_reset },
|
|
{ "[MCA] BusLogic BT-640A", "bt640a", &buslogic_640a_device,BuslogicDeviceReset },
|
|
{ "[PCI] BusLogic BT-958D", "bt958d", &buslogic_pci_device, BuslogicDeviceReset },
|
|
{ "[PCI] NCR 53C810", "ncr53c810", &ncr53c810_pci_device,NULL },
|
|
{ "[VLB] BusLogic BT-445S", "bt445s", &buslogic_445s_device,BuslogicDeviceReset },
|
|
{ "", "", NULL, NULL },
|
|
};
|
|
|
|
|
|
int
|
|
scsi_card_available(int card)
|
|
{
|
|
if (scsi_cards[card].device)
|
|
return(device_available(scsi_cards[card].device));
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
char *
|
|
scsi_card_getname(int card)
|
|
{
|
|
return((char *)scsi_cards[card].name);
|
|
}
|
|
|
|
|
|
device_t *
|
|
scsi_card_getdevice(int card)
|
|
{
|
|
return(scsi_cards[card].device);
|
|
}
|
|
|
|
|
|
int
|
|
scsi_card_has_config(int card)
|
|
{
|
|
if (! scsi_cards[card].device) return(0);
|
|
|
|
return(scsi_cards[card].device->config ? 1 : 0);
|
|
}
|
|
|
|
|
|
char *
|
|
scsi_card_get_internal_name(int card)
|
|
{
|
|
return((char *)scsi_cards[card].internal_name);
|
|
}
|
|
|
|
|
|
int
|
|
scsi_card_get_from_internal_name(char *s)
|
|
{
|
|
int c = 0;
|
|
|
|
while (strlen((char *)scsi_cards[c].internal_name)) {
|
|
if (! strcmp((char *)scsi_cards[c].internal_name, s))
|
|
return(c);
|
|
c++;
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
void
|
|
scsi_mutex(uint8_t start)
|
|
{
|
|
if (start)
|
|
scsiMutex = thread_create_mutex(L"VARCem.SCSIMutex");
|
|
else
|
|
thread_close_mutex((mutex_t *) scsiMutex);
|
|
}
|
|
|
|
|
|
void
|
|
scsi_card_init(void)
|
|
{
|
|
int i, j;
|
|
|
|
pclog("Building SCSI hard disk map...\n");
|
|
build_scsi_hd_map();
|
|
pclog("Building SCSI CD-ROM map...\n");
|
|
build_scsi_cdrom_map();
|
|
pclog("Building SCSI ZIP map...\n");
|
|
build_scsi_zip_map();
|
|
|
|
for (i=0; i<SCSI_ID_MAX; i++) {
|
|
for (j=0; j<SCSI_LUN_MAX; j++) {
|
|
if (scsi_hard_disks[i][j] != 0xff) {
|
|
SCSIDevices[i][j].LunType = SCSI_DISK;
|
|
} else if (scsi_cdrom_drives[i][j] != 0xff) {
|
|
SCSIDevices[i][j].LunType = SCSI_CDROM;
|
|
} else if (scsi_zip_drives[i][j] != 0xff) {
|
|
SCSIDevices[i][j].LunType = SCSI_ZIP;
|
|
} else {
|
|
SCSIDevices[i][j].LunType = SCSI_NONE;
|
|
}
|
|
SCSIDevices[i][j].CmdBuffer = NULL;
|
|
}
|
|
}
|
|
|
|
if (scsi_cards[scsi_card_current].device)
|
|
device_add(scsi_cards[scsi_card_current].device);
|
|
|
|
scsi_card_last = scsi_card_current;
|
|
}
|
|
|
|
|
|
void
|
|
scsi_card_reset(void)
|
|
{
|
|
void *p = NULL;
|
|
|
|
if (scsi_cards[scsi_card_current].device) {
|
|
p = device_get_priv(scsi_cards[scsi_card_current].device);
|
|
if (p != NULL) {
|
|
if (scsi_cards[scsi_card_current].reset)
|
|
scsi_cards[scsi_card_current].reset(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Initialization function for the SCSI layer */
|
|
void
|
|
SCSIReset(uint8_t id, uint8_t lun)
|
|
{
|
|
uint8_t cdrom_id = scsi_cdrom_drives[id][lun];
|
|
uint8_t zip_id = scsi_zip_drives[id][lun];
|
|
uint8_t hdd_id = scsi_hard_disks[id][lun];
|
|
|
|
if (hdd_id != 0xff) {
|
|
scsi_hd_reset(hdd_id);
|
|
SCSIDevices[id][lun].LunType = SCSI_DISK;
|
|
} else {
|
|
if (cdrom_id != 0xff) {
|
|
cdrom_reset(cdrom_id);
|
|
SCSIDevices[id][lun].LunType = SCSI_CDROM;
|
|
} else if (zip_id != 0xff) {
|
|
zip_reset(zip_id);
|
|
SCSIDevices[id][lun].LunType = SCSI_ZIP;
|
|
} else {
|
|
SCSIDevices[id][lun].LunType = SCSI_NONE;
|
|
}
|
|
}
|
|
|
|
if (SCSIDevices[id][lun].CmdBuffer != NULL) {
|
|
free(SCSIDevices[id][lun].CmdBuffer);
|
|
SCSIDevices[id][lun].CmdBuffer = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
scsi_mutex_wait(uint8_t wait)
|
|
{
|
|
if (wait)
|
|
thread_wait_mutex((mutex_t *) scsiMutex);
|
|
else
|
|
thread_release_mutex((mutex_t *) scsiMutex);
|
|
}
|