[SCSI2SD-V6.git] / software / SCSI2SD / src / disk.c

//	Copyright (C) 2013 Michael McMaster <michael@codesrc.com>\r
//	Copyright (C) 2014 Doug Brown <doug@downtowndougbrown.com>\r
//\r
//	This file is part of SCSI2SD.\r
//\r
//	SCSI2SD is free software: you can redistribute it and/or modify\r
//	it under the terms of the GNU General Public License as published by\r
//	the Free Software Foundation, either version 3 of the License, or\r
//	(at your option) any later version.\r
//\r
//	SCSI2SD is distributed in the hope that it will be useful,\r
//	but WITHOUT ANY WARRANTY; without even the implied warranty of\r
//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
//	GNU General Public License for more details.\r
//\r
//	You should have received a copy of the GNU General Public License\r
//	along with SCSI2SD.  If not, see <http://www.gnu.org/licenses/>.\r
#pragma GCC push_options\r
#pragma GCC optimize("-flto")\r
\r
#include "device.h"\r
#include "scsi.h"\r
#include "scsiPhy.h"\r
#include "config.h"\r
#include "debug.h"\r
#include "debug.h"\r
#include "disk.h"\r
#include "sd.h"\r
#include "time.h"\r
\r
#include <string.h>\r
\r
// Global\r
BlockDevice blockDev;\r
Transfer transfer;\r
\r
static int doSdInit()\r
{\r
	int result = 0;\r
	if (blockDev.state & DISK_PRESENT)\r
	{\r
		result = sdInit();\r
\r
		if (result)\r
		{\r
			blockDev.state = blockDev.state | DISK_INITIALISED;\r
		}\r
	}\r
	return result;\r
}\r
\r
// Callback once all data has been read in the data out phase.\r
static void doFormatUnitComplete(void)\r
{\r
	// TODO start writing the initialisation pattern to the SD\r
	// card\r
	scsiDev.phase = STATUS;\r
}\r
\r
static void doFormatUnitSkipData(int bytes)\r
{\r
	// We may not have enough memory to store the initialisation pattern and\r
	// defect list data.  Since we're not making use of it yet anyway, just\r
	// discard the bytes.\r
	scsiEnterPhase(DATA_OUT);\r
	int i;\r
	for (i = 0; i < bytes; ++i)\r
	{\r
		scsiReadByte();\r
	}\r
}\r
\r
// Callback from the data out phase.\r
static void doFormatUnitPatternHeader(void)\r
{\r
	int defectLength =\r
		((((uint16_t)scsiDev.data[2])) << 8) +\r
			scsiDev.data[3];\r
\r
	int patternLength =\r
		((((uint16_t)scsiDev.data[4 + 2])) << 8) +\r
		scsiDev.data[4 + 3];\r
\r
		doFormatUnitSkipData(defectLength + patternLength);\r
		doFormatUnitComplete();\r
}\r
\r
// Callback from the data out phase.\r
static void doFormatUnitHeader(void)\r
{\r
	int IP = (scsiDev.data[1] & 0x08) ? 1 : 0;\r
	int DSP = (scsiDev.data[1] & 0x04) ? 1 : 0;\r
\r
	if (! DSP) // disable save parameters\r
	{\r
		// Save the "MODE SELECT savable parameters"\r
		configSave(\r
			scsiDev.target->targetId,\r
			scsiDev.target->liveCfg.bytesPerSector);\r
	}\r
\r
	if (IP)\r
	{\r
		// We need to read the initialisation pattern header first.\r
		scsiDev.dataLen += 4;\r
		scsiDev.phase = DATA_OUT;\r
		scsiDev.postDataOutHook = doFormatUnitPatternHeader;\r
	}\r
	else\r
	{\r
		// Read the defect list data\r
		int defectLength =\r
			((((uint16_t)scsiDev.data[2])) << 8) +\r
			scsiDev.data[3];\r
		doFormatUnitSkipData(defectLength);\r
		doFormatUnitComplete();\r
	}\r
}\r
\r
static void doReadCapacity()\r
{\r
	uint32_t lba = (((uint32) scsiDev.cdb[2]) << 24) +\r
		(((uint32) scsiDev.cdb[3]) << 16) +\r
		(((uint32) scsiDev.cdb[4]) << 8) +\r
		scsiDev.cdb[5];\r
	int pmi = scsiDev.cdb[8] & 1;\r
\r
	uint32_t capacity = getScsiCapacity(\r
		scsiDev.target->cfg->sdSectorStart,\r
		scsiDev.target->liveCfg.bytesPerSector,\r
		scsiDev.target->cfg->scsiSectors);\r
\r
	if (!pmi && lba)\r
	{\r
		// error.\r
		// We don't do anything with the "partial medium indicator", and\r
		// assume that delays are constant across each block. But the spec\r
		// says we must return this error if pmi is specified incorrectly.\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
		scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB;\r
		scsiDev.phase = STATUS;\r
	}\r
	else if (capacity > 0)\r
	{\r
		uint32_t highestBlock = capacity - 1;\r
\r
		scsiDev.data[0] = highestBlock >> 24;\r
		scsiDev.data[1] = highestBlock >> 16;\r
		scsiDev.data[2] = highestBlock >> 8;\r
		scsiDev.data[3] = highestBlock;\r
\r
		uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector;\r
		scsiDev.data[4] = bytesPerSector >> 24;\r
		scsiDev.data[5] = bytesPerSector >> 16;\r
		scsiDev.data[6] = bytesPerSector >> 8;\r
		scsiDev.data[7] = bytesPerSector;\r
		scsiDev.dataLen = 8;\r
		scsiDev.phase = DATA_IN;\r
	}\r
	else\r
	{\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = NOT_READY;\r
		scsiDev.target->sense.asc = MEDIUM_NOT_PRESENT;\r
		scsiDev.phase = STATUS;\r
	}\r
}\r
\r
static void doWrite(uint32 lba, uint32 blocks)\r
{\r
	if (unlikely(blockDev.state & DISK_WP) ||\r
		unlikely(scsiDev.target->cfg->deviceType == CONFIG_OPTICAL))\r
\r
	{\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
		scsiDev.target->sense.asc = WRITE_PROTECTED;\r
		scsiDev.phase = STATUS;\r
	}\r
	else if (unlikely(((uint64) lba) + blocks >\r
		getScsiCapacity(\r
			scsiDev.target->cfg->sdSectorStart,\r
			scsiDev.target->liveCfg.bytesPerSector,\r
			scsiDev.target->cfg->scsiSectors\r
			)\r
		))\r
	{\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
		scsiDev.target->sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;\r
		scsiDev.phase = STATUS;\r
	}\r
	else\r
	{\r
		transfer.dir = TRANSFER_WRITE;\r
		transfer.lba = lba;\r
		transfer.blocks = blocks;\r
		transfer.currentBlock = 0;\r
		scsiDev.phase = DATA_OUT;\r
		scsiDev.dataLen = scsiDev.target->liveCfg.bytesPerSector;\r
		scsiDev.dataPtr = scsiDev.target->liveCfg.bytesPerSector;\r
\r
		// No need for single-block writes atm.  Overhead of the\r
		// multi-block write is minimal.\r
		transfer.multiBlock = 1;\r
\r
		sdWriteMultiSectorPrep();\r
	}\r
}\r
\r
\r
static void doRead(uint32 lba, uint32 blocks)\r
{\r
	uint32_t capacity = getScsiCapacity(\r
		scsiDev.target->cfg->sdSectorStart,\r
		scsiDev.target->liveCfg.bytesPerSector,\r
		scsiDev.target->cfg->scsiSectors);\r
	if (unlikely(((uint64) lba) + blocks > capacity))\r
	{\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
		scsiDev.target->sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;\r
		scsiDev.phase = STATUS;\r
	}\r
	else\r
	{\r
		transfer.dir = TRANSFER_READ;\r
		transfer.lba = lba;\r
		transfer.blocks = blocks;\r
		transfer.currentBlock = 0;\r
		scsiDev.phase = DATA_IN;\r
		scsiDev.dataLen = 0; // No data yet\r
\r
		if ((blocks == 1) ||\r
			unlikely(((uint64) lba) + blocks == capacity)\r
			)\r
		{\r
			// We get errors on reading the last sector using a multi-sector\r
			// read :-(\r
			transfer.multiBlock = 0;\r
		}\r
		else\r
		{\r
			transfer.multiBlock = 1;\r
			sdReadMultiSectorPrep();\r
		}\r
	}\r
}\r
\r
static void doSeek(uint32 lba)\r
{\r
	if (lba >=\r
		getScsiCapacity(\r
			scsiDev.target->cfg->sdSectorStart,\r
			scsiDev.target->liveCfg.bytesPerSector,\r
			scsiDev.target->cfg->scsiSectors)\r
		)\r
	{\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
		scsiDev.target->sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;\r
		scsiDev.phase = STATUS;\r
	}\r
}\r
\r
static int doTestUnitReady()\r
{\r
	int ready = 1;\r
	if (likely(blockDev.state == (DISK_STARTED | DISK_PRESENT | DISK_INITIALISED)))\r
	{\r
		// nothing to do.\r
	}\r
	else if (unlikely(!(blockDev.state & DISK_STARTED)))\r
	{\r
		ready = 0;\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = NOT_READY;\r
		scsiDev.target->sense.asc = LOGICAL_UNIT_NOT_READY_INITIALIZING_COMMAND_REQUIRED;\r
		scsiDev.phase = STATUS;\r
	}\r
	else if (unlikely(!(blockDev.state & DISK_PRESENT)))\r
	{\r
		ready = 0;\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = NOT_READY;\r
		scsiDev.target->sense.asc = MEDIUM_NOT_PRESENT;\r
		scsiDev.phase = STATUS;\r
	}\r
	else if (unlikely(!(blockDev.state & DISK_INITIALISED)))\r
	{\r
		ready = 0;\r
		scsiDev.status = CHECK_CONDITION;\r
		scsiDev.target->sense.code = NOT_READY;\r
		scsiDev.target->sense.asc = LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE;\r
		scsiDev.phase = STATUS;\r
	}\r
	return ready;\r
}\r
\r
// Handle direct-access scsi device commands\r
int scsiDiskCommand()\r
{\r
	int commandHandled = 1;\r
\r
	uint8 command = scsiDev.cdb[0];\r
	if (unlikely(command == 0x1B))\r
	{\r
		// START STOP UNIT\r
		// Enable or disable media access operations.\r
		// Ignore load/eject requests. We can't do that.\r
		//int immed = scsiDev.cdb[1] & 1;\r
		int start = scsiDev.cdb[4] & 1;\r
\r
		if (start)\r
		{\r
			blockDev.state = blockDev.state | DISK_STARTED;\r
			if (!(blockDev.state & DISK_INITIALISED))\r
			{\r
				doSdInit();\r
			}\r
		}\r
		else\r
		{\r
			blockDev.state &= ~DISK_STARTED;\r
		}\r
	}\r
	else if (unlikely(command == 0x00))\r
	{\r
		// TEST UNIT READY\r
		doTestUnitReady();\r
	}\r
	else if (unlikely(!doTestUnitReady()))\r
	{\r
		// Status and sense codes already set by doTestUnitReady\r
	}\r
	else if (likely(command == 0x08))\r
	{\r
		// READ(6)\r
		uint32 lba =\r
			(((uint32) scsiDev.cdb[1] & 0x1F) << 16) +\r
			(((uint32) scsiDev.cdb[2]) << 8) +\r
			scsiDev.cdb[3];\r
		uint32 blocks = scsiDev.cdb[4];\r
		if (unlikely(blocks == 0)) blocks = 256;\r
		doRead(lba, blocks);\r
	}\r
	else if (likely(command == 0x28))\r
	{\r
		// READ(10)\r
		// Ignore all cache control bits - we don't support a memory cache.\r
\r
		uint32 lba =\r
			(((uint32) scsiDev.cdb[2]) << 24) +\r
			(((uint32) scsiDev.cdb[3]) << 16) +\r
			(((uint32) scsiDev.cdb[4]) << 8) +\r
			scsiDev.cdb[5];\r
		uint32 blocks =\r
			(((uint32) scsiDev.cdb[7]) << 8) +\r
			scsiDev.cdb[8];\r
\r
		doRead(lba, blocks);\r
	}\r
	else if (likely(command == 0x0A))\r
	{\r
		// WRITE(6)\r
		uint32 lba =\r
			(((uint32) scsiDev.cdb[1] & 0x1F) << 16) +\r
			(((uint32) scsiDev.cdb[2]) << 8) +\r
			scsiDev.cdb[3];\r
		uint32 blocks = scsiDev.cdb[4];\r
		if (unlikely(blocks == 0)) blocks = 256;\r
		doWrite(lba, blocks);\r
	}\r
	else if (likely(command == 0x2A) || // WRITE(10)\r
		unlikely(command == 0x2E)) // WRITE AND VERIFY\r
	{\r
		// Ignore all cache control bits - we don't support a memory cache.\r
		// Don't bother verifying either. The SD card likely stores ECC\r
		// along with each flash row.\r
\r
		uint32 lba =\r
			(((uint32) scsiDev.cdb[2]) << 24) +\r
			(((uint32) scsiDev.cdb[3]) << 16) +\r
			(((uint32) scsiDev.cdb[4]) << 8) +\r
			scsiDev.cdb[5];\r
		uint32 blocks =\r
			(((uint32) scsiDev.cdb[7]) << 8) +\r
			scsiDev.cdb[8];\r
\r
		doWrite(lba, blocks);\r
	}\r
\r
	else if (unlikely(command == 0x04))\r
	{\r
		// FORMAT UNIT\r
		// We don't really do any formatting, but we need to read the correct\r
		// number of bytes in the DATA_OUT phase to make the SCSI host happy.\r
\r
		int fmtData = (scsiDev.cdb[1] & 0x10) ? 1 : 0;\r
		if (fmtData)\r
		{\r
			// We need to read the parameter list, but we don't know how\r
			// big it is yet. Start with the header.\r
			scsiDev.dataLen = 4;\r
			scsiDev.phase = DATA_OUT;\r
			scsiDev.postDataOutHook = doFormatUnitHeader;\r
		}\r
		else\r
		{\r
			// No data to read, we're already finished!\r
		}\r
	}\r
	else if (unlikely(command == 0x25))\r
	{\r
		// READ CAPACITY\r
		doReadCapacity();\r
	}\r
	else if (unlikely(command == 0x0B))\r
	{\r
		// SEEK(6)\r
		uint32 lba =\r
			(((uint32) scsiDev.cdb[1] & 0x1F) << 16) +\r
			(((uint32) scsiDev.cdb[2]) << 8) +\r
			scsiDev.cdb[3];\r
\r
		doSeek(lba);\r
	}\r
\r
	else if (unlikely(command == 0x2B))\r
	{\r
		// SEEK(10)\r
		uint32 lba =\r
			(((uint32) scsiDev.cdb[2]) << 24) +\r
			(((uint32) scsiDev.cdb[3]) << 16) +\r
			(((uint32) scsiDev.cdb[4]) << 8) +\r
			scsiDev.cdb[5];\r
\r
		doSeek(lba);\r
	}\r
	else if (unlikely(command == 0x36))\r
	{\r
		// LOCK UNLOCK CACHE\r
		// We don't have a cache to lock data into. do nothing.\r
	}\r
	else if (unlikely(command == 0x34))\r
	{\r
		// PRE-FETCH.\r
		// We don't have a cache to pre-fetch into. do nothing.\r
	}\r
	else if (unlikely(command == 0x1E))\r
	{\r
		// PREVENT ALLOW MEDIUM REMOVAL\r
		// Not much we can do to prevent the user removing the SD card.\r
		// do nothing.\r
	}\r
	else if (unlikely(command == 0x01))\r
	{\r
		// REZERO UNIT\r
		// Set the lun to a vendor-specific state. Ignore.\r
	}\r
	else if (unlikely(command == 0x35))\r
	{\r
		// SYNCHRONIZE CACHE\r
		// We don't have a cache. do nothing.\r
	}\r
	else if (unlikely(command == 0x2F))\r
	{\r
		// VERIFY\r
		// TODO: When they supply data to verify, we should read the data and\r
		// verify it. If they don't supply any data, just say success.\r
		if ((scsiDev.cdb[1] & 0x02) == 0)\r
		{\r
			// They are asking us to do a medium verification with no data\r
			// comparison. Assume success, do nothing.\r
		}\r
		else\r
		{\r
			// TODO. This means they are supplying data to verify against.\r
			// Technically we should probably grab the data and compare it.\r
			scsiDev.status = CHECK_CONDITION;\r
			scsiDev.target->sense.code = ILLEGAL_REQUEST;\r
			scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB;\r
			scsiDev.phase = STATUS;\r
		}\r
	}\r
	else\r
	{\r
		commandHandled = 0;\r
	}\r
\r
	return commandHandled;\r
}\r
\r
void scsiDiskPoll()\r
{\r
	debugPause(); // TODO comment re. timeouts.\r
\r
	if (scsiDev.phase == DATA_IN &&\r
		transfer.currentBlock != transfer.blocks)\r
	{\r
		scsiEnterPhase(DATA_IN);\r
\r
		int totalSDSectors =\r
			transfer.blocks *\r
				SDSectorsPerSCSISector(scsiDev.target->liveCfg.bytesPerSector);\r
		uint32_t sdLBA =\r
			SCSISector2SD(\r
				scsiDev.target->cfg->sdSectorStart,\r
				scsiDev.target->liveCfg.bytesPerSector,\r
				transfer.lba);\r
\r
		const int sdPerScsi =\r
			SDSectorsPerSCSISector(scsiDev.target->liveCfg.bytesPerSector);\r
		int buffers = sizeof(scsiDev.data) / SD_SECTOR_SIZE;\r
		int prep = 0;\r
		int i = 0;\r
		int scsiActive = 0;\r
		int sdActive = 0;\r
		while ((i < totalSDSectors) &&\r
			likely(scsiDev.phase == DATA_IN) &&\r
			likely(!scsiDev.resetFlag))\r
		{\r
			// Wait for the next DMA interrupt. It's beneficial to halt the\r
			// processor to give the DMA controller more memory bandwidth to\r
			// work with.\r
			// We're optimistically assuming a race condition won't occur\r
			// between these checks and the interrupt handers. The 1ms\r
			// systick timer interrupt saves us on the event of a race.\r
			int scsiBusy = scsiDMABusy();\r
			int sdBusy = sdDMABusy();\r
			if (scsiBusy && sdBusy) __WFI();\r
\r
			if (sdActive && !sdBusy && sdReadSectorDMAPoll())\r
			{\r
				sdActive = 0;\r
				prep++;\r
			}\r
			else if (!sdActive &&\r
				(prep - i < buffers) &&\r
				(prep < totalSDSectors))\r
			{\r
				// Start an SD transfer if we have space.\r
				if (transfer.multiBlock)\r
				{\r
					sdReadMultiSectorDMA(&scsiDev.data[SD_SECTOR_SIZE * (prep % buffers)]);\r
				}\r
				else\r
				{\r
					sdReadSingleSectorDMA(sdLBA + prep, &scsiDev.data[SD_SECTOR_SIZE * (prep % buffers)]);\r
				}\r
				sdActive = 1;\r
			}\r
\r
			if (scsiActive && !scsiBusy && scsiWriteDMAPoll())\r
			{\r
				scsiActive = 0;\r
				++i;\r
			}\r
			else if (!scsiActive && ((prep - i) > 0))\r
			{\r
				int dmaBytes = SD_SECTOR_SIZE;\r
				if ((i % sdPerScsi) == (sdPerScsi - 1))\r
				{\r
					dmaBytes = scsiDev.target->liveCfg.bytesPerSector % SD_SECTOR_SIZE;\r
					if (dmaBytes == 0) dmaBytes = SD_SECTOR_SIZE;\r
				}\r
				scsiWriteDMA(&scsiDev.data[SD_SECTOR_SIZE * (i % buffers)], dmaBytes);\r
				scsiActive = 1;\r
			}\r
		}\r
		if (scsiDev.phase == DATA_IN)\r
		{\r
			scsiDev.phase = STATUS;\r
		}\r
		scsiDiskReset();\r
	}\r
	else if (scsiDev.phase == DATA_OUT &&\r
		transfer.currentBlock != transfer.blocks)\r
	{\r
		scsiEnterPhase(DATA_OUT);\r
\r
		const int sdPerScsi =\r
			SDSectorsPerSCSISector(scsiDev.target->liveCfg.bytesPerSector);\r
		int totalSDSectors = transfer.blocks * sdPerScsi;\r
		int buffers = sizeof(scsiDev.data) / SD_SECTOR_SIZE;\r
		int prep = 0;\r
		int i = 0;\r
		int scsiDisconnected = 0;\r
		int scsiComplete = 0;\r
		uint32_t lastActivityTime = getTime_ms();\r
		int scsiActive = 0;\r
		int sdActive = 0;\r
\r
		while ((i < totalSDSectors) &&\r
			(likely(scsiDev.phase == DATA_OUT) || // scsiDisconnect keeps our phase.\r
				scsiComplete) &&\r
			likely(!scsiDev.resetFlag))\r
		{\r
			// Wait for the next DMA interrupt. It's beneficial to halt the\r
			// processor to give the DMA controller more memory bandwidth to\r
			// work with.\r
			// We're optimistically assuming a race condition won't occur\r
			// between these checks and the interrupt handers. The 1ms\r
			// systick timer interrupt saves us on the event of a race.\r
			int scsiBusy = scsiDMABusy();\r
			int sdBusy = sdDMABusy();\r
			if (scsiBusy && sdBusy) __WFI();\r
\r
			if (sdActive && !sdBusy && sdWriteSectorDMAPoll(i == (totalSDSectors - 1)))\r
			{\r
				sdActive = 0;\r
				i++;\r
			}\r
			else if (!sdActive && ((prep - i) > 0))\r
			{\r
				// Start an SD transfer if we have space.\r
				sdWriteMultiSectorDMA(&scsiDev.data[SD_SECTOR_SIZE * (i % buffers)]);\r
				sdActive = 1;\r
			}\r
\r
			uint32_t now = getTime_ms();\r
\r
			if (scsiActive && !scsiBusy && scsiReadDMAPoll())\r
			{\r
				scsiActive = 0;\r
				++prep;\r
				lastActivityTime = now;\r
			}\r
			else if (!scsiActive &&\r
				((prep - i) < buffers) &&\r
				(prep < totalSDSectors) &&\r
				likely(!scsiDisconnected))\r
			{\r
				int dmaBytes = SD_SECTOR_SIZE;\r
				if ((prep % sdPerScsi) == (sdPerScsi - 1))\r
				{\r
					dmaBytes = scsiDev.target->liveCfg.bytesPerSector % SD_SECTOR_SIZE;\r
					if (dmaBytes == 0) dmaBytes = SD_SECTOR_SIZE;\r
				}\r
				scsiReadDMA(&scsiDev.data[SD_SECTOR_SIZE * (prep % buffers)], dmaBytes);\r
				scsiActive = 1;\r
			}\r
			else if (\r
				(scsiActive == 0) &&\r
				likely(!scsiDisconnected) &&\r
				unlikely(scsiDev.discPriv) &&\r
				unlikely(diffTime_ms(lastActivityTime, now) >= 20) &&\r
				likely(scsiDev.phase == DATA_OUT))\r
			{\r
				// We're transferring over the SCSI bus faster than the SD card\r
				// can write.  There is no more buffer space once we've finished\r
				// this SCSI transfer.\r
				// The NCR 53C700 interface chips have a 250ms "byte-to-byte"\r
				// timeout buffer. SD card writes are supposed to complete\r
				// within 200ms, but sometimes they don't.\r
				// The NCR 53C700 series is used on HP 9000 workstations.\r
				scsiDisconnect();\r
				scsiDisconnected = 1;\r
				lastActivityTime = getTime_ms();\r
			}\r
			else if (unlikely(scsiDisconnected) &&\r
				(\r
					(prep == i) || // Buffers empty.\r
					// Send some messages every 100ms so we don't timeout.\r
					// At a minimum, a reselection involves an IDENTIFY message.\r
					unlikely(diffTime_ms(lastActivityTime, now) >= 100)\r
				))\r
			{\r
				int reconnected = scsiReconnect();\r
				if (reconnected)\r
				{\r
					scsiDisconnected = 0;\r
					lastActivityTime = getTime_ms(); // Don't disconnect immediately.\r
				}\r
				else if (diffTime_ms(lastActivityTime, getTime_ms()) >= 10000)\r
				{\r
					// Give up after 10 seconds of trying to reconnect.\r
					scsiDev.resetFlag = 1;\r
				}\r
			}\r
			else if (\r
				likely(!scsiComplete) &&\r
				(sdActive == 1) &&\r
				(prep == totalSDSectors) && // All scsi data read and buffered\r
				likely(!scsiDev.discPriv) && // Prefer disconnect where possible.\r
				unlikely(diffTime_ms(lastActivityTime, now) >= 150) &&\r
\r
				likely(scsiDev.phase == DATA_OUT) &&\r
				!(scsiDev.cdb[scsiDev.cdbLen - 1] & 0x01) // Not linked command\r
				)\r
			{\r
				// We're transferring over the SCSI bus faster than the SD card\r
				// can write.  All data is buffered, and we're just waiting for\r
				// the SD card to complete. The host won't let us disconnect.\r
				// Some drivers set a 250ms timeout on transfers to complete.\r
				// SD card writes are supposed to complete\r
				// within 200ms, but sometimes they don'to.\r
				// Just pretend we're finished.\r
				scsiComplete = 1;\r
\r
				process_Status();\r
				process_MessageIn(); // Will go to BUS_FREE state\r
\r
				// Try and prevent anyone else using the SCSI bus while we're not ready.\r
				SCSI_SetPin(SCSI_Out_BSY); \r
			}\r
		}\r
\r
		if (scsiComplete)\r
		{\r
			SCSI_ClearPin(SCSI_Out_BSY);\r
		}\r
		while (\r
			!scsiDev.resetFlag &&\r
			unlikely(scsiDisconnected) &&\r
			(elapsedTime_ms(lastActivityTime) <= 10000))\r
		{\r
			scsiDisconnected = !scsiReconnect();\r
		}\r
		if (scsiDisconnected)\r
		{\r
			// Failed to reconnect\r
			scsiDev.resetFlag = 1;\r
		}\r
\r
		if (scsiDev.phase == DATA_OUT)\r
		{\r
			if (scsiDev.parityError &&\r
				(scsiDev.target->cfg->flags & CONFIG_ENABLE_PARITY) &&\r
				(scsiDev.compatMode >= COMPAT_SCSI2))\r
			{\r
				scsiDev.target->sense.code = ABORTED_COMMAND;\r
				scsiDev.target->sense.asc = SCSI_PARITY_ERROR;\r
				scsiDev.status = CHECK_CONDITION;;\r
			}\r
			scsiDev.phase = STATUS;\r
		}\r
		scsiDiskReset();\r
	}\r
	debugResume(); // TODO comment re. timeouts.\r
}\r
\r
void scsiDiskReset()\r
{\r
	scsiDev.dataPtr = 0;\r
	scsiDev.savedDataPtr = 0;\r
	scsiDev.dataLen = 0;\r
	// transfer.lba = 0; // Needed in Request Sense to determine failure\r
	transfer.blocks = 0;\r
	transfer.currentBlock = 0;\r
\r
	// Cancel long running commands!\r
	if (unlikely(transfer.inProgress == 1))\r
	{\r
		if (transfer.dir == TRANSFER_WRITE)\r
		{\r
			sdCompleteWrite();\r
		}\r
		else\r
		{\r
			sdCompleteRead();\r
		}\r
	}\r
	transfer.inProgress = 0;\r
	transfer.multiBlock = 0;\r
}\r
\r
void scsiDiskInit()\r
{\r
	transfer.inProgress = 0;\r
	scsiDiskReset();\r
\r
	// Don't require the host to send us a START STOP UNIT command\r
	blockDev.state = DISK_STARTED;\r
	// WP pin not available for micro-sd\r
	// TODO read card WP register\r
	#if 0\r
	if (SD_WP_Read())\r
	{\r
		blockDev.state = blockDev.state | DISK_WP;\r
	}\r
	#endif\r
}\r
\r
#pragma GCC pop_options\r