mirror of
https://github.com/dkgrizzly/GreenSCSI.git
synced 2024-12-04 07:52:13 +00:00
1108 lines
29 KiB
C++
1108 lines
29 KiB
C++
/*
|
||
* SCSI-HD Device emulator for STM32F103
|
||
*/
|
||
|
||
#define X1TURBO_DTC510B 0 /* for SHARP X1turbo */
|
||
#define READ_SPEED_OPTIMIZE 1 /* Lead speedup */
|
||
#define WRITE_SPEED_OPTIMIZE 1 /* Speed up writes */
|
||
#define USE_DB2ID_TABLE 1 /* SEL-DB Use table to get ID from */
|
||
|
||
// SCSI config
|
||
#define NUM_SCSIID 7 // Maximum number of supported SCSI-IDs (The minimum is 0)
|
||
#define NUM_SCSILUN 2 // Maximum number of LUNs supported (The minimum is 0)
|
||
#define READ_PARITY_CHECK 0 // Perform read parity check (unverified)
|
||
|
||
// HDD format
|
||
#if X1TURBO_DTC510B
|
||
#define BLOCKSIZE 256 // 1 BLOCK size
|
||
#else
|
||
#define BLOCKSIZE 512 // 1 BLOCK size
|
||
#endif
|
||
|
||
//#include <SPI.h>
|
||
|
||
#include <SdFatConfig.h>
|
||
//SdFatEX CLASS To make available
|
||
#undef ENABLE_EXTENDED_TRANSFER_CLASS
|
||
#define ENABLE_EXTENDED_TRANSFER_CLASS 1
|
||
#include <SdFat.h>
|
||
|
||
#ifdef USE_STM32_DMA
|
||
#warning "warning USE_STM32_DMA"
|
||
#endif
|
||
|
||
SPIClass SPI_1(1);
|
||
SdFatEX SD(&SPI_1);
|
||
|
||
#if 0
|
||
#define LOG(XX) Serial.print(XX)
|
||
#define LOGHEX(XX) Serial.print(XX, HEX)
|
||
#define LOGN(XX) Serial.println(XX)
|
||
#define LOGHEXN(XX) Serial.println(XX, HEX)
|
||
#else
|
||
#define LOG(XX) //Serial.print(XX)
|
||
#define LOGHEX(XX) //Serial.print(XX, HEX)
|
||
#define LOGN(XX) //Serial.println(XX)
|
||
#define LOGHEXN(XX) //Serial.println(XX, HEX)
|
||
#endif
|
||
|
||
#define active 1
|
||
#define inactive 0
|
||
#define high 0
|
||
#define low 1
|
||
|
||
#define isHigh(XX) ((XX) == high)
|
||
#define isLow(XX) ((XX) != high)
|
||
|
||
#define gpio_mode(pin,val) gpio_set_mode(PIN_MAP[pin].gpio_device, PIN_MAP[pin].gpio_bit, val);
|
||
#define gpio_write(pin,val) gpio_write_bit(PIN_MAP[pin].gpio_device, PIN_MAP[pin].gpio_bit, val)
|
||
#define gpio_read(pin) gpio_read_bit(PIN_MAP[pin].gpio_device, PIN_MAP[pin].gpio_bit)
|
||
|
||
//#define DB0 PB8 // SCSI:DB0
|
||
//#define DB1 PB9 // SCSI:DB1
|
||
//#define DB2 PB10 // SCSI:DB2
|
||
//#define DB3 PB11 // SCSI:DB3
|
||
//#define DB4 PB12 // SCSI:DB4
|
||
//#define DB5 PB13 // SCSI:DB5
|
||
//#define DB6 PB14 // SCSI:DB6
|
||
//#define DB7 PB15 // SCSI:DB7
|
||
//#define DBP PB0 // SCSI:DBP
|
||
#define ATN PA8 // SCSI:ATN
|
||
#define BSY PA9 // SCSI:BSY
|
||
#define ACK PA10 // SCSI:ACK
|
||
#define RST PA15 // SCSI:RST
|
||
#define MSG PB3 // SCSI:MSG
|
||
#define SEL PB4 // SCSI:SEL
|
||
#define CD PB5 // SCSI:C/D
|
||
#define REQ PB6 // SCSI:REQ
|
||
#define IO PB7 // SCSI:I/O
|
||
|
||
#define SD_CS PA4 // SDCARD:CS
|
||
#define LED PC13 // LED
|
||
|
||
// GPIO register port
|
||
#define PAREG GPIOA->regs
|
||
#define PBREG GPIOB->regs
|
||
|
||
// LED control
|
||
#define LED_ON() gpio_write(LED, high);
|
||
#define LED_OFF() gpio_write(LED, low);
|
||
|
||
|
||
// Virtual pin (Arduio compatibility is slow, so make it MCU-dependent)
|
||
#define PA(BIT) (BIT)
|
||
#define PB(BIT) (BIT+16)
|
||
// Virtual pin decoding
|
||
#define GPIOREG(VPIN) ((VPIN)>=16?PBREG:PAREG)
|
||
#define BITMASK(VPIN) (1<<((VPIN)&15))
|
||
|
||
#define vATN PA(8) // SCSI:ATN
|
||
#define vBSY PA(9) // SCSI:BSY
|
||
#define vACK PA(10) // SCSI:ACK
|
||
#define vRST PA(15) // SCSI:RST
|
||
#define vMSG PB(3) // SCSI:MSG
|
||
#define vSEL PB(4) // SCSI:SEL
|
||
#define vCD PB(5) // SCSI:C/D
|
||
#define vREQ PB(6) // SCSI:REQ
|
||
#define vIO PB(7) // SCSI:I/O
|
||
#define vSD_CS PA(4) // SDCARD:CS
|
||
|
||
// SCSI output pin control: opendrain active LOW (direct pin drive)
|
||
#define SCSI_OUT(VPIN,ACTIVE) { GPIOREG(VPIN)->BSRR = BITMASK(VPIN)<<((ACTIVE)?16:0); }
|
||
|
||
// SCSI input pin check (inactive=0,avtive=1)
|
||
#define SCSI_IN(VPIN) ((~GPIOREG(VPIN)->IDR>>(VPIN&15))&1)
|
||
|
||
// GPIO mode
|
||
// IN , FLOAT : 4
|
||
// IN , PU/PD : 8
|
||
// OUT, PUSH/PULL : 3
|
||
// OUT, OD : 1
|
||
//#define DB_MODE_OUT 3
|
||
#define DB_MODE_OUT 1
|
||
#define DB_MODE_IN 8
|
||
|
||
// Put DB and DP in output mode
|
||
#define SCSI_DB_OUTPUT() { PBREG->CRL=(PBREG->CRL &0xfffffff0)|DB_MODE_OUT; PBREG->CRH = 0x11111111*DB_MODE_OUT; }
|
||
// Put DB and DP in input mode
|
||
#define SCSI_DB_INPUT() { PBREG->CRL=(PBREG->CRL &0xfffffff0)|DB_MODE_IN ; PBREG->CRH = 0x11111111*DB_MODE_IN; }
|
||
|
||
// Turn on the output only for BSY
|
||
#define SCSI_BSY_ACTIVE() { gpio_mode(BSY, GPIO_OUTPUT_OD); SCSI_OUT(vBSY, active) }
|
||
// BSY,REQ,MSG,CD,IO Turn on the output (no change required for OD)
|
||
#define SCSI_TARGET_ACTIVE() { }
|
||
// BSY,REQ,MSG,CD,IO Turn off output, BSY is the last input
|
||
#define SCSI_TARGET_INACTIVE() { SCSI_OUT(vREQ,inactive); SCSI_OUT(vMSG,inactive); SCSI_OUT(vCD,inactive);SCSI_OUT(vIO,inactive); SCSI_OUT(vBSY,inactive); gpio_mode(BSY, GPIO_INPUT_PU); }
|
||
|
||
// HDDiamge file
|
||
#define HDIMG_FILE "HDxx.HDS" // HD image file name base
|
||
#define HDIMG_ID_POS 2 // Position to embed ID number
|
||
#define HDIMG_LUN_POS 3 // Position to embed LUN numbers
|
||
|
||
// HDD image
|
||
typedef struct hddimg_struct
|
||
{
|
||
File m_file; // File object
|
||
uint32_t m_fileSize; // File size
|
||
}HDDIMG;
|
||
HDDIMG img[NUM_SCSIID][NUM_SCSILUN]; // Maximum number
|
||
|
||
uint8_t m_senseKey = 0; // Sense key
|
||
volatile bool m_isBusReset = false; // Bus reset
|
||
|
||
byte scsi_id_mask; // Mask list of responding SCSI IDs
|
||
byte m_id; // Currently responding SCSI-ID
|
||
byte m_lun; // Logical unit number currently responding
|
||
byte m_sts; // Status byte
|
||
byte m_msg; // Message bytes
|
||
HDDIMG *m_img; // HDD image for current SCSI-ID, LUN
|
||
byte m_buf[BLOCKSIZE+1]; // General purpose buffer + overrun fetch
|
||
int m_msc;
|
||
bool m_msb[256];
|
||
|
||
/*
|
||
* Data byte to BSRR register setting value and parity table
|
||
*/
|
||
|
||
// Parity bit generation
|
||
#define PTY(V) (1^((V)^((V)>>1)^((V)>>2)^((V)>>3)^((V)>>4)^((V)>>5)^((V)>>6)^((V)>>7))&1)
|
||
|
||
// Data byte to BSRR register setting value conversion table
|
||
// BSRR[31:24] = DB[7:0]
|
||
// BSRR[ 16] = PTY(DB)
|
||
// BSRR[15: 8] = ~DB[7:0]
|
||
// BSRR[ 0] = ~PTY(DB)
|
||
|
||
// Set DBP, set REQ = inactive
|
||
#define DBP(D) ((((((uint32_t)(D)<<8)|PTY(D))*0x00010001)^0x0000ff01)|BITMASK(vREQ))
|
||
|
||
#define DBP8(D) DBP(D),DBP(D+1),DBP(D+2),DBP(D+3),DBP(D+4),DBP(D+5),DBP(D+6),DBP(D+7)
|
||
#define DBP32(D) DBP8(D),DBP8(D+8),DBP8(D+16),DBP8(D+24)
|
||
|
||
// BSRR register control value that simultaneously performs DB set, DP set, and REQ = H (inactrive)
|
||
static const uint32_t db_bsrr[256]={
|
||
DBP32(0x00),DBP32(0x20),DBP32(0x40),DBP32(0x60),
|
||
DBP32(0x80),DBP32(0xA0),DBP32(0xC0),DBP32(0xE0)
|
||
};
|
||
// Parity bit acquisition
|
||
#define PARITY(DB) (db_bsrr[DB]&1)
|
||
|
||
// Macro cleaning
|
||
#undef DBP32
|
||
#undef DBP8
|
||
//#undef DBP
|
||
//#undef PTY
|
||
|
||
#if USE_DB2ID_TABLE
|
||
/* DB to SCSI-ID table */
|
||
static const byte db2scsiid[256]={
|
||
0xff,
|
||
0,
|
||
1,1,
|
||
2,2,2,2,
|
||
3,3,3,3,3,3,3,3,
|
||
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
|
||
5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
|
||
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
||
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
|
||
};
|
||
#endif
|
||
|
||
|
||
|
||
|
||
void onFalseInit(void);
|
||
void onBusReset(void);
|
||
|
||
/*
|
||
* IO read.
|
||
*/
|
||
inline byte readIO(void)
|
||
{
|
||
// Port input data register
|
||
uint32 ret = GPIOB->regs->IDR;
|
||
byte bret = (byte)((~ret)>>8);
|
||
#if READ_PARITY_CHECK
|
||
if((db_bsrr[bret]^ret)&1)
|
||
m_sts |= 0x01; // parity error
|
||
#endif
|
||
|
||
return bret;
|
||
}
|
||
|
||
/*
|
||
* Initialization.
|
||
* Initialize the bus and set the PIN orientation
|
||
*/
|
||
void setup()
|
||
{
|
||
// PA15 / PB3 / PB4 Cannot be used
|
||
// JTAG Because it is used for debugging.
|
||
disableDebugPorts();
|
||
|
||
// Serial initialization
|
||
//Serial.begin(9600);
|
||
//while (!Serial);
|
||
|
||
// PIN initialization
|
||
gpio_mode(LED, GPIO_OUTPUT_OD);
|
||
gpio_write(LED, low);
|
||
|
||
//GPIO(SCSI BUS)Initialization
|
||
//Port setting register (lower)
|
||
// GPIOB->regs->CRL |= 0x000000008; // SET INPUT W/ PUPD on PAB-PB0
|
||
//Port setting register (upper)
|
||
//GPIOB->regs->CRH = 0x88888888; // SET INPUT W/ PUPD on PB15-PB8
|
||
// GPIOB->regs->ODR = 0x0000FF00; // SET PULL-UPs on PB15-PB8
|
||
// DB,DPは入力モード
|
||
SCSI_DB_INPUT()
|
||
|
||
// Input port
|
||
gpio_mode(ATN, GPIO_INPUT_PU);
|
||
gpio_mode(BSY, GPIO_INPUT_PU);
|
||
gpio_mode(ACK, GPIO_INPUT_PU);
|
||
gpio_mode(RST, GPIO_INPUT_PU);
|
||
gpio_mode(SEL, GPIO_INPUT_PU);
|
||
// Output port
|
||
gpio_mode(MSG, GPIO_OUTPUT_OD);
|
||
gpio_mode(CD, GPIO_OUTPUT_OD);
|
||
gpio_mode(REQ, GPIO_OUTPUT_OD);
|
||
gpio_mode(IO, GPIO_OUTPUT_OD);
|
||
// Turn off the output port
|
||
SCSI_TARGET_INACTIVE()
|
||
|
||
//#if X1TURBO_DTC510B
|
||
// Serial initialization
|
||
Serial.begin(9600);
|
||
for(int tout=3000/200;tout;tout--)
|
||
{
|
||
if(Serial) break;
|
||
Serial.print(".");
|
||
delay(200);
|
||
break;
|
||
}
|
||
Serial.println("DTC510B HDD emulator for X1turbo");
|
||
//#endif
|
||
|
||
//Occurs when the RST pin state changes from HIGH to LOW
|
||
//attachInterrupt(PIN_MAP[RST].gpio_bit, onBusReset, FALLING);
|
||
|
||
LED_ON();
|
||
|
||
// clock = 36MHz , about 4Mbytes/sec
|
||
if(!SD.begin(SD_CS,SPI_FULL_SPEED)) {
|
||
Serial.println("SD initialization failed!");
|
||
onFalseInit();
|
||
}
|
||
|
||
//Sector data overrun byte setting
|
||
m_buf[BLOCKSIZE] = 0xff; // DB0 all off,DBP off
|
||
//HD image file open
|
||
//int totalImage = 0;
|
||
scsi_id_mask = 0x00;
|
||
for(int id=0;id<NUM_SCSIID;id++)
|
||
{
|
||
for(int lun=0;lun<NUM_SCSILUN;lun++)
|
||
{
|
||
HDDIMG *h = &img[id][lun];
|
||
char file_path[sizeof(HDIMG_FILE)+1] = HDIMG_FILE;
|
||
// build file path
|
||
file_path[HDIMG_ID_POS ] = '0'+id;
|
||
file_path[HDIMG_LUN_POS] = '0'+lun;
|
||
|
||
h->m_fileSize = 0;
|
||
h->m_file = SD.open(file_path, O_RDWR);
|
||
if(h->m_file.isOpen())
|
||
{
|
||
h->m_fileSize = h->m_file.size();
|
||
Serial.print("Found Imagefile:");
|
||
Serial.print(file_path);
|
||
if(h->m_fileSize==0)
|
||
{
|
||
h->m_file.close();
|
||
}
|
||
else
|
||
{
|
||
Serial.print(" / ");
|
||
Serial.print(h->m_fileSize);
|
||
Serial.print("bytes / ");
|
||
Serial.print(h->m_fileSize / 1024);
|
||
Serial.print("KiB / ");
|
||
Serial.print(h->m_fileSize / 1024 / 1024);
|
||
Serial.println("MiB");
|
||
// Marked as a responsive ID
|
||
scsi_id_mask |= 1<<id;
|
||
//totalImage++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Error if the image file is 0
|
||
if(scsi_id_mask==0) onFalseInit();
|
||
// Drive map display
|
||
Serial.println("I:<-----LUN----->:");
|
||
Serial.println("D:0:1:2:3:4:5:6:7:");
|
||
for(int id=0;id<NUM_SCSIID;id++)
|
||
{
|
||
Serial.print(id);
|
||
for(int lun=0;lun<NUM_SCSILUN;lun++)
|
||
{
|
||
if( (lun<NUM_SCSILUN) && (img[id][lun].m_file))
|
||
Serial.print(":*");
|
||
else
|
||
Serial.print(":-");
|
||
}
|
||
Serial.println(":");
|
||
}
|
||
#if 0
|
||
//test dump table
|
||
for(int i=0;i<256;i++)
|
||
{
|
||
if(i%16==0)
|
||
{
|
||
Serial.println(' ');
|
||
Serial.print(i, HEX);
|
||
Serial.print(':');
|
||
}
|
||
Serial.print(db_bsrr[i], HEX);
|
||
Serial.print(',');
|
||
}
|
||
#endif
|
||
LED_OFF();
|
||
//Occurs when the RST pin state changes from HIGH to LOW
|
||
attachInterrupt(PIN_MAP[RST].gpio_bit, onBusReset, FALLING);
|
||
}
|
||
|
||
/*
|
||
* Initialization failed.
|
||
*/
|
||
void onFalseInit(void)
|
||
{
|
||
while(true) {
|
||
gpio_write(LED, high);
|
||
delay(500);
|
||
gpio_write(LED, low);
|
||
delay(500);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Bus reset interrupt.
|
||
*/
|
||
void onBusReset(void)
|
||
{
|
||
#if X1TURBO_DTC510B
|
||
// The RST pulse is a write cycle + 2 clocks, only about 1.25us.
|
||
{{
|
||
#else
|
||
if(isHigh(gpio_read(RST))) {
|
||
delayMicroseconds(20);
|
||
if(isHigh(gpio_read(RST))) {
|
||
#endif
|
||
// BUS FREE is done in the main process
|
||
// gpio_mode(MSG, GPIO_OUTPUT_OD);
|
||
// gpio_mode(CD, GPIO_OUTPUT_OD);
|
||
// gpio_mode(REQ, GPIO_OUTPUT_OD);
|
||
// gpio_mode(IO, GPIO_OUTPUT_OD);
|
||
// Should I enter DB and DBP once?
|
||
SCSI_DB_INPUT()
|
||
|
||
LOGN("BusReset!");
|
||
m_isBusReset = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Read by handshake.
|
||
*/
|
||
inline byte readHandshake(void)
|
||
{
|
||
SCSI_OUT(vREQ,active)
|
||
//SCSI_DB_INPUT()
|
||
while(!SCSI_IN(vACK)) { if(m_isBusReset) return 0; }
|
||
byte r = readIO();
|
||
SCSI_OUT(vREQ,inactive)
|
||
while( SCSI_IN(vACK)) { if(m_isBusReset) return 0; }
|
||
return r;
|
||
}
|
||
|
||
/*
|
||
* Write with a handshake.
|
||
*/
|
||
inline void writeHandshake(byte d)
|
||
{
|
||
GPIOB->regs->BSRR = db_bsrr[d]; // setup DB,DBP (160ns)
|
||
SCSI_DB_OUTPUT() // (180ns)
|
||
// ACK.Fall to DB output delay 100ns(MAX) (DTC-510B)
|
||
SCSI_OUT(vREQ,inactive) // setup wait (30ns)
|
||
SCSI_OUT(vREQ,inactive) // setup wait (30ns)
|
||
SCSI_OUT(vREQ,inactive) // setup wait (30ns)
|
||
SCSI_OUT(vREQ,active) // (30ns)
|
||
//while(!SCSI_IN(vACK)) { if(m_isBusReset){ SCSI_DB_INPUT() return; }}
|
||
while(!m_isBusReset && !SCSI_IN(vACK));
|
||
// ACK.Fall to REQ.Raise delay 500ns(typ.) (DTC-510B)
|
||
GPIOB->regs->BSRR = DBP(0xff); // DB=0xFF , SCSI_OUT(vREQ,inactive)
|
||
// REQ.Raise to DB hold time 0ns
|
||
SCSI_DB_INPUT() // (150ns)
|
||
while( SCSI_IN(vACK)) { if(m_isBusReset) return; }
|
||
}
|
||
|
||
/*
|
||
* Data in phase.
|
||
* Send len bytes of data array p.
|
||
*/
|
||
void writeDataPhase(int len, const byte* p)
|
||
{
|
||
LOGN("DATAIN PHASE");
|
||
SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
SCSI_OUT(vCD ,inactive) // gpio_write(CD, low);
|
||
SCSI_OUT(vIO , active) // gpio_write(IO, high);
|
||
for (int i = 0; i < len; i++) {
|
||
if(m_isBusReset) {
|
||
return;
|
||
}
|
||
writeHandshake(p[i]);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Data in phase.
|
||
* Send len block while reading from SD card.
|
||
*/
|
||
void writeDataPhaseSD(uint32_t adds, uint32_t len)
|
||
{
|
||
LOGN("DATAIN PHASE(SD)");
|
||
uint32_t pos = adds * BLOCKSIZE;
|
||
m_img->m_file.seek(pos);
|
||
|
||
SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
SCSI_OUT(vCD ,inactive) // gpio_write(CD, low);
|
||
SCSI_OUT(vIO , active) // gpio_write(IO, high);
|
||
|
||
for(uint32_t i = 0; i < len; i++) {
|
||
// Asynchronous reads will make it faster ...
|
||
m_img->m_file.read(m_buf, BLOCKSIZE);
|
||
|
||
#if READ_SPEED_OPTIMIZE
|
||
|
||
//#define REQ_ON() SCSI_OUT(vREQ,active)
|
||
#define REQ_ON() (*db_dst = BITMASK(vREQ)<<16)
|
||
#define FETCH_SRC() (src_byte = *srcptr++)
|
||
#define FETCH_BSRR_DB() (bsrr_val = bsrr_tbl[src_byte])
|
||
#define REQ_OFF_DB_SET(BSRR_VAL) *db_dst = BSRR_VAL
|
||
#define WAIT_ACK_ACTIVE() while(!m_isBusReset && !SCSI_IN(vACK))
|
||
#define WAIT_ACK_INACTIVE() do{ if(m_isBusReset) return; }while(SCSI_IN(vACK))
|
||
|
||
SCSI_DB_OUTPUT()
|
||
register byte *srcptr= m_buf; // Source buffer
|
||
/*register*/ byte src_byte; // Send data bytes
|
||
register const uint32_t *bsrr_tbl = db_bsrr; // Table to convert to BSRR
|
||
register uint32_t bsrr_val; // BSRR value to output (DB, DBP, REQ = ACTIVE)
|
||
register volatile uint32_t *db_dst = &(GPIOB->regs->BSRR); // Output port
|
||
|
||
// prefetch & 1st out
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
// DB.set to REQ.F setup 100ns max (DTC-510B)
|
||
// Maybe there should be some weight here
|
||
// WAIT_ACK_INACTIVE();
|
||
do{
|
||
// 0
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
// ACK.F to REQ.R 500ns typ. (DTC-510B)
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 1
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 2
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 3
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 4
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 5
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 6
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
// 7
|
||
REQ_ON();
|
||
FETCH_SRC();
|
||
FETCH_BSRR_DB();
|
||
WAIT_ACK_ACTIVE();
|
||
REQ_OFF_DB_SET(bsrr_val);
|
||
WAIT_ACK_INACTIVE();
|
||
}while(srcptr < m_buf+BLOCKSIZE);
|
||
SCSI_DB_INPUT()
|
||
#else
|
||
for(int j = 0; j < BLOCKSIZE; j++) {
|
||
if(m_isBusReset) {
|
||
return;
|
||
}
|
||
writeHandshake(m_buf[j]);
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
/*
|
||
* Data out phase.
|
||
* len block read
|
||
*/
|
||
void readDataPhase(int len, byte* p)
|
||
{
|
||
LOGN("DATAOUT PHASE");
|
||
SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
SCSI_OUT(vCD ,inactive) // gpio_write(CD, low);
|
||
SCSI_OUT(vIO ,inactive) // gpio_write(IO, low);
|
||
for(uint32_t i = 0; i < len; i++)
|
||
p[i] = readHandshake();
|
||
}
|
||
|
||
/*
|
||
* Data out phase.
|
||
* Write to SD card while reading len block.
|
||
*/
|
||
void readDataPhaseSD(uint32_t adds, uint32_t len)
|
||
{
|
||
LOGN("DATAOUT PHASE(SD)");
|
||
uint32_t pos = adds * BLOCKSIZE;
|
||
m_img->m_file.seek(pos);
|
||
SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
SCSI_OUT(vCD ,inactive) // gpio_write(CD, low);
|
||
SCSI_OUT(vIO ,inactive) // gpio_write(IO, low);
|
||
for(uint32_t i = 0; i < len; i++) {
|
||
#if WRITE_SPEED_OPTIMIZE
|
||
register byte *dstptr= m_buf;
|
||
for(int j = 0; j < BLOCKSIZE/8; j++) {
|
||
dstptr[0] = readHandshake();
|
||
dstptr[1] = readHandshake();
|
||
dstptr[2] = readHandshake();
|
||
dstptr[3] = readHandshake();
|
||
dstptr[4] = readHandshake();
|
||
dstptr[5] = readHandshake();
|
||
dstptr[6] = readHandshake();
|
||
dstptr[7] = readHandshake();
|
||
if(m_isBusReset) {
|
||
return;
|
||
}
|
||
dstptr+=8;
|
||
}
|
||
#else
|
||
for(int j = 0; j < BLOCKSIZE; j++) {
|
||
if(m_isBusReset) {
|
||
return;
|
||
}
|
||
m_buf[j] = readHandshake();
|
||
}
|
||
#endif
|
||
m_img->m_file.write(m_buf, BLOCKSIZE);
|
||
}
|
||
m_img->m_file.flush();
|
||
}
|
||
|
||
/*
|
||
* INQUIRY command processing.
|
||
*/
|
||
byte onInquiryCommand(byte len)
|
||
{
|
||
byte buf[36] = {
|
||
0x00, //device type
|
||
0x00, //RMB = 0
|
||
0x01, //ISO, ECMA, ANSI version
|
||
0x01, //Response data format
|
||
35 - 4, //Additional data length
|
||
0, 0, //Reserve
|
||
0x00, //Support function
|
||
'T', 'N', 'B', ' ', ' ', ' ', ' ', ' ',
|
||
'A', 'r', 'd', 'S', 'C', 'S', 'i', 'n', 'o', ' ', ' ',' ', ' ', ' ', ' ', ' ',
|
||
'0', '0', '1', '0',
|
||
};
|
||
writeDataPhase(len < 36 ? len : 36, buf);
|
||
return 0x00;
|
||
}
|
||
|
||
/*
|
||
* REQUEST SENSE command processing.
|
||
*/
|
||
void onRequestSenseCommand(byte len)
|
||
{
|
||
byte buf[18] = {
|
||
0x70, //CheckCondition
|
||
0, //Segment number
|
||
0x00, //Sense key
|
||
0, 0, 0, 0, //information
|
||
17 - 7 , //Additional data length
|
||
0,
|
||
};
|
||
buf[2] = m_senseKey;
|
||
m_senseKey = 0;
|
||
writeDataPhase(len < 18 ? len : 18, buf);
|
||
}
|
||
|
||
/*
|
||
* READ CAPACITY command processing.
|
||
*/
|
||
byte onReadCapacityCommand(byte pmi)
|
||
{
|
||
if(!m_img) return 0x02; // Image file absent
|
||
|
||
uint32_t bc = m_img->m_fileSize / BLOCKSIZE;
|
||
uint32_t bl = BLOCKSIZE;
|
||
uint8_t buf[8] = {
|
||
bc >> 24, bc >> 16, bc >> 8, bc,
|
||
bl >> 24, bl >> 16, bl >> 8, bl
|
||
};
|
||
writeDataPhase(8, buf);
|
||
return 0x00;
|
||
}
|
||
|
||
/*
|
||
* READ6 / 10 Command processing.
|
||
*/
|
||
byte onReadCommand(uint32_t adds, uint32_t len)
|
||
{
|
||
LOGN("-R");
|
||
LOGHEXN(adds);
|
||
LOGHEXN(len);
|
||
|
||
if(!m_img) return 0x02; // Image file absent
|
||
|
||
gpio_write(LED, high);
|
||
writeDataPhaseSD(adds, len);
|
||
gpio_write(LED, low);
|
||
return 0x00; //sts
|
||
}
|
||
|
||
/*
|
||
* WRITE6 / 10 Command processing.
|
||
*/
|
||
byte onWriteCommand(uint32_t adds, uint32_t len)
|
||
{
|
||
LOGN("-W");
|
||
LOGHEXN(adds);
|
||
LOGHEXN(len);
|
||
|
||
if(!m_img) return 0x02; // Image file absent
|
||
|
||
gpio_write(LED, high);
|
||
readDataPhaseSD(adds, len);
|
||
gpio_write(LED, low);
|
||
return 0; //sts
|
||
}
|
||
|
||
/*
|
||
* MODE SENSE command processing.
|
||
*/
|
||
byte onModeSenseCommand(byte dbd, int pageCode, uint32_t len)
|
||
{
|
||
if(!m_img) return 0x02; // Image file absent
|
||
|
||
memset(m_buf, 0, sizeof(m_buf));
|
||
int a = 4;
|
||
if(dbd == 0) {
|
||
uint32_t bc = m_img->m_fileSize / BLOCKSIZE;
|
||
uint32_t bl = BLOCKSIZE;
|
||
byte c[8] = {
|
||
0,//Density code
|
||
bc >> 16, bc >> 8, bc,
|
||
0, //Reserve
|
||
bl >> 16, bl >> 8, bl
|
||
};
|
||
memcpy(&m_buf[4], c, 8);
|
||
a += 8;
|
||
m_buf[3] = 0x08;
|
||
}
|
||
switch(pageCode) {
|
||
case 0x3F:
|
||
case 0x03: //Drive parameters
|
||
m_buf[a + 0] = 0x03; //Page code
|
||
m_buf[a + 1] = 0x16; // Page length
|
||
m_buf[a + 11] = 0x3F;//Number of sectors / track
|
||
a += 24;
|
||
if(pageCode != 0x3F) {
|
||
break;
|
||
}
|
||
case 0x04: //Drive parameters
|
||
{
|
||
uint32_t bc = m_img->m_fileSize / BLOCKSIZE;
|
||
m_buf[a + 0] = 0x04; //Page code
|
||
m_buf[a + 1] = 0x16; // Page length
|
||
m_buf[a + 2] = bc >> 16;// Cylinder length
|
||
m_buf[a + 3] = bc >> 8;
|
||
m_buf[a + 4] = bc;
|
||
m_buf[a + 5] = 1; //Number of heads
|
||
a += 24;
|
||
}
|
||
if(pageCode != 0x3F) {
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
m_buf[0] = a - 1;
|
||
writeDataPhase(len < a ? len : a, m_buf);
|
||
return 0x00;
|
||
}
|
||
|
||
|
||
#if X1TURBO_DTC510B
|
||
/*
|
||
* dtc510b_setDriveparameter
|
||
*/
|
||
#define PACKED __attribute__((packed))
|
||
typedef struct PACKED dtc500_cmd_c2_param_struct
|
||
{
|
||
uint8_t StepPlusWidth; // Default is 13.6usec (11)
|
||
uint8_t StepPeriod; // Default is 3 msec.(60)
|
||
uint8_t StepMode; // Default is Bufferd (0)
|
||
uint8_t MaximumHeadAdress; // Default is 4 heads (3)
|
||
uint8_t HighCylinderAddressByte; // Default set to 0 (0)
|
||
uint8_t LowCylinderAddressByte; // Default is 153 cylinders (152)
|
||
uint8_t ReduceWrietCurrent; // Default is above Cylinder 128 (127)
|
||
uint8_t DriveType_SeekCompleteOption;// (0)
|
||
uint8_t Reserved8; // (0)
|
||
uint8_t Reserved9; // (0)
|
||
} DTC510_CMD_C2_PARAM;
|
||
|
||
static void logStrHex(const char *msg,uint32_t num)
|
||
{
|
||
LOG(msg);
|
||
LOGHEXN(num);
|
||
}
|
||
|
||
static byte dtc510b_setDriveparameter(void)
|
||
{
|
||
DTC510_CMD_C2_PARAM DriveParameter;
|
||
uint16_t maxCylinder;
|
||
uint16_t numLAD;
|
||
//uint32_t stepPulseUsec;
|
||
int StepPeriodMsec;
|
||
|
||
// receive paramter
|
||
writeDataPhase(sizeof(DriveParameter),(byte *)(&DriveParameter));
|
||
|
||
maxCylinder =
|
||
(((uint16_t)DriveParameter.HighCylinderAddressByte)<<8) |
|
||
(DriveParameter.LowCylinderAddressByte);
|
||
numLAD = maxCylinder * (DriveParameter.MaximumHeadAdress+1);
|
||
//stepPulseUsec = calcStepPulseUsec(DriveParameter.StepPlusWidth);
|
||
StepPeriodMsec = DriveParameter.StepPeriod*50;
|
||
logStrHex (" StepPlusWidth : ",DriveParameter.StepPlusWidth);
|
||
logStrHex (" StepPeriod : ",DriveParameter.StepPeriod );
|
||
logStrHex (" StepMode : ",DriveParameter.StepMode );
|
||
logStrHex (" MaximumHeadAdress : ",DriveParameter.MaximumHeadAdress);
|
||
logStrHex (" CylinderAddress : ",maxCylinder);
|
||
logStrHex (" ReduceWrietCurrent : ",DriveParameter.ReduceWrietCurrent);
|
||
logStrHex (" DriveType/SeekCompleteOption : ",DriveParameter.DriveType_SeekCompleteOption);
|
||
logStrHex (" Maximum LAD : ",numLAD-1);
|
||
return 0; // error result
|
||
}
|
||
#endif
|
||
|
||
/*
|
||
* MsgIn2.
|
||
*/
|
||
void MsgIn2(int msg)
|
||
{
|
||
LOGN("MsgIn2");
|
||
SCSI_OUT(vMSG, active) // gpio_write(MSG, high);
|
||
SCSI_OUT(vCD , active) // gpio_write(CD, high);
|
||
SCSI_OUT(vIO , active) // gpio_write(IO, high);
|
||
writeHandshake(msg);
|
||
}
|
||
|
||
/*
|
||
* MsgOut2.
|
||
*/
|
||
void MsgOut2()
|
||
{
|
||
LOGN("MsgOut2");
|
||
SCSI_OUT(vMSG, active) // gpio_write(MSG, high);
|
||
SCSI_OUT(vCD , active) // gpio_write(CD, high);
|
||
SCSI_OUT(vIO ,inactive) // gpio_write(IO, low);
|
||
m_msb[m_msc] = readHandshake();
|
||
m_msc++;
|
||
m_msc %= 256;
|
||
}
|
||
|
||
/*
|
||
* Main loop.
|
||
*/
|
||
void loop()
|
||
{
|
||
//int msg = 0;
|
||
m_msg = 0;
|
||
|
||
// Wait until RST = H, BSY = H, SEL = L
|
||
do {} while( SCSI_IN(vBSY) || !SCSI_IN(vSEL) || SCSI_IN(vRST));
|
||
|
||
// BSY+ SEL-
|
||
// If the ID to respond is not driven, wait for the next
|
||
//byte db = readIO();
|
||
//byte scsiid = db & scsi_id_mask;
|
||
byte scsiid = readIO() & scsi_id_mask;
|
||
if((scsiid) == 0) {
|
||
return;
|
||
}
|
||
LOGN("Selection");
|
||
m_isBusReset = false;
|
||
// Set BSY to-when selected
|
||
SCSI_BSY_ACTIVE(); // Turn only BSY output ON, ACTIVE
|
||
|
||
// Ask for a TARGET-ID to respond
|
||
#if USE_DB2ID_TABLE
|
||
m_id = db2scsiid[scsiid];
|
||
//if(m_id==0xff) return;
|
||
#else
|
||
for(m_id=7;m_id>=0;m_id--)
|
||
if(scsiid & (1<<m_id)) break;
|
||
//if(m_id<0) return;
|
||
#endif
|
||
|
||
// Wait until SEL becomes inactive
|
||
while(isHigh(gpio_read(SEL))) {
|
||
if(m_isBusReset) {
|
||
goto BusFree;
|
||
}
|
||
}
|
||
SCSI_TARGET_ACTIVE() // (BSY), REQ, MSG, CD, IO output turned on
|
||
//
|
||
if(isHigh(gpio_read(ATN))) {
|
||
bool syncenable = false;
|
||
int syncperiod = 50;
|
||
int syncoffset = 0;
|
||
m_msc = 0;
|
||
memset(m_msb, 0x00, sizeof(m_msb));
|
||
while(isHigh(gpio_read(ATN))) {
|
||
MsgOut2();
|
||
}
|
||
for(int i = 0; i < m_msc; i++) {
|
||
// ABORT
|
||
if (m_msb[i] == 0x06) {
|
||
goto BusFree;
|
||
}
|
||
// BUS DEVICE RESET
|
||
if (m_msb[i] == 0x0C) {
|
||
syncoffset = 0;
|
||
goto BusFree;
|
||
}
|
||
// IDENTIFY
|
||
if (m_msb[i] >= 0x80) {
|
||
}
|
||
// Extended message
|
||
if (m_msb[i] == 0x01) {
|
||
// Check only when synchronous transfer is possible
|
||
if (!syncenable || m_msb[i + 2] != 0x01) {
|
||
MsgIn2(0x07);
|
||
break;
|
||
}
|
||
// Transfer period factor(50 x 4 = Limited to 200ns)
|
||
syncperiod = m_msb[i + 3];
|
||
if (syncperiod > 50) {
|
||
syncoffset = 50;
|
||
}
|
||
// REQ/ACK offset(Limited to 16)
|
||
syncoffset = m_msb[i + 4];
|
||
if (syncoffset > 16) {
|
||
syncoffset = 16;
|
||
}
|
||
// STDR response message generation
|
||
MsgIn2(0x01);
|
||
MsgIn2(0x03);
|
||
MsgIn2(0x01);
|
||
MsgIn2(syncperiod);
|
||
MsgIn2(syncoffset);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
LOG("Command:");
|
||
SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
SCSI_OUT(vCD , active) // gpio_write(CD, high);
|
||
SCSI_OUT(vIO ,inactive) // gpio_write(IO, low);
|
||
|
||
int len;
|
||
byte cmd[12];
|
||
cmd[0] = readHandshake(); if(m_isBusReset) goto BusFree;
|
||
LOGHEX(cmd[0]);
|
||
// Command length selection, reception
|
||
static const int cmd_class_len[8]={6,10,10,6,6,12,6,6};
|
||
len = cmd_class_len[cmd[0] >> 5];
|
||
cmd[1] = readHandshake(); LOG(":");LOGHEX(cmd[1]); if(m_isBusReset) goto BusFree;
|
||
cmd[2] = readHandshake(); LOG(":");LOGHEX(cmd[2]); if(m_isBusReset) goto BusFree;
|
||
cmd[3] = readHandshake(); LOG(":");LOGHEX(cmd[3]); if(m_isBusReset) goto BusFree;
|
||
cmd[4] = readHandshake(); LOG(":");LOGHEX(cmd[4]); if(m_isBusReset) goto BusFree;
|
||
cmd[5] = readHandshake(); LOG(":");LOGHEX(cmd[5]); if(m_isBusReset) goto BusFree;
|
||
// Receive the remaining commands
|
||
for(int i = 6; i < len; i++ ) {
|
||
cmd[i] = readHandshake();
|
||
LOG(":");
|
||
LOGHEX(cmd[i]);
|
||
if(m_isBusReset) goto BusFree;
|
||
}
|
||
// LUN confirmation
|
||
m_lun = m_sts>>5;
|
||
m_sts = cmd[1]&0xe0; // Preset LUN in status byte
|
||
// HDD Image selection
|
||
m_img = (HDDIMG *)0; // None
|
||
if( (m_lun <= NUM_SCSILUN) )
|
||
{
|
||
m_img = &(img[m_id][m_lun]); // There is an image
|
||
if(!(m_img->m_file.isOpen()))
|
||
m_img = (HDDIMG *)0; // Image absent
|
||
}
|
||
// if(!m_img) m_sts |= 0x02; // Missing image file for LUN
|
||
//LOGHEX(((uint32_t)m_img));
|
||
|
||
LOG(":ID ");
|
||
LOG(m_id);
|
||
LOG(":LUN ");
|
||
LOG(m_lun);
|
||
|
||
LOGN("");
|
||
switch(cmd[0]) {
|
||
case 0x00:
|
||
LOGN("[Test Unit]");
|
||
break;
|
||
case 0x01:
|
||
LOGN("[Rezero Unit]");
|
||
break;
|
||
case 0x03:
|
||
LOGN("[RequestSense]");
|
||
onRequestSenseCommand(cmd[4]);
|
||
break;
|
||
case 0x04:
|
||
LOGN("[FormatUnit]");
|
||
break;
|
||
case 0x06:
|
||
LOGN("[FormatUnit]");
|
||
break;
|
||
case 0x07:
|
||
LOGN("[ReassignBlocks]");
|
||
break;
|
||
case 0x08:
|
||
LOGN("[Read6]");
|
||
m_sts |= onReadCommand((((uint32_t)cmd[1] & 0x1F) << 16) | ((uint32_t)cmd[2] << 8) | cmd[3], (cmd[4] == 0) ? 0x100 : cmd[4]);
|
||
break;
|
||
case 0x0A:
|
||
LOGN("[Write6]");
|
||
m_sts |= onWriteCommand((((uint32_t)cmd[1] & 0x1F) << 16) | ((uint32_t)cmd[2] << 8) | cmd[3], (cmd[4] == 0) ? 0x100 : cmd[4]);
|
||
break;
|
||
case 0x0B:
|
||
LOGN("[Seek6]");
|
||
break;
|
||
case 0x12:
|
||
LOGN("[Inquiry]");
|
||
m_sts |= onInquiryCommand(cmd[4]);
|
||
break;
|
||
case 0x1A:
|
||
LOGN("[ModeSense6]");
|
||
m_sts |= onModeSenseCommand(cmd[1]&0x80, cmd[2] & 0x3F, cmd[4]);
|
||
break;
|
||
case 0x1B:
|
||
LOGN("[StartStopUnit]");
|
||
break;
|
||
case 0x1E:
|
||
LOGN("[PreAllowMed.Removal]");
|
||
break;
|
||
case 0x25:
|
||
LOGN("[ReadCapacity]");
|
||
m_sts |= onReadCapacityCommand(cmd[8]);
|
||
break;
|
||
case 0x28:
|
||
LOGN("[Read10]");
|
||
m_sts |= onReadCommand(((uint32_t)cmd[2] << 24) | ((uint32_t)cmd[3] << 16) | ((uint32_t)cmd[4] << 8) | cmd[5], ((uint32_t)cmd[7] << 8) | cmd[8]);
|
||
break;
|
||
case 0x2A:
|
||
LOGN("[Write10]");
|
||
m_sts |= onWriteCommand(((uint32_t)cmd[2] << 24) | ((uint32_t)cmd[3] << 16) | ((uint32_t)cmd[4] << 8) | cmd[5], ((uint32_t)cmd[7] << 8) | cmd[8]);
|
||
break;
|
||
case 0x2B:
|
||
LOGN("[Seek10]");
|
||
break;
|
||
case 0x5A:
|
||
LOGN("[ModeSense10]");
|
||
onModeSenseCommand(cmd[1] & 0x80, cmd[2] & 0x3F, ((uint32_t)cmd[7] << 8) | cmd[8]);
|
||
break;
|
||
#if X1TURBO_DTC510B
|
||
case 0xc2:
|
||
LOGN("[DTC510B setDriveParameter]");
|
||
m_sts |= dtc510b_setDriveparameter();
|
||
break;
|
||
#endif
|
||
default:
|
||
LOGN("[*Unknown]");
|
||
m_sts |= 0x02;
|
||
m_senseKey = 5;
|
||
break;
|
||
}
|
||
if(m_isBusReset) {
|
||
goto BusFree;
|
||
}
|
||
|
||
LOGN("Sts");
|
||
SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
SCSI_OUT(vCD , active) // gpio_write(CD, high);
|
||
SCSI_OUT(vIO , active) // gpio_write(IO, high);
|
||
writeHandshake(m_sts);
|
||
if(m_isBusReset) {
|
||
goto BusFree;
|
||
}
|
||
|
||
LOGN("MsgIn");
|
||
SCSI_OUT(vMSG, active) // gpio_write(MSG, high);
|
||
SCSI_OUT(vCD , active) // gpio_write(CD, high);
|
||
SCSI_OUT(vIO , active) // gpio_write(IO, high);
|
||
writeHandshake(m_msg);
|
||
|
||
BusFree:
|
||
LOGN("BusFree");
|
||
m_isBusReset = false;
|
||
//SCSI_OUT(vREQ,inactive) // gpio_write(REQ, low);
|
||
//SCSI_OUT(vMSG,inactive) // gpio_write(MSG, low);
|
||
//SCSI_OUT(vCD ,inactive) // gpio_write(CD, low);
|
||
//SCSI_OUT(vIO ,inactive) // gpio_write(IO, low);
|
||
//SCSI_OUT(vBSY,inactive)
|
||
SCSI_TARGET_INACTIVE() // Turn off BSY, REQ, MSG, CD, IO output
|
||
}
|