Macintosh-HW/SCSI2SD
1
0
Fork 0
mirror of https://github.com/fhgwright/SCSI2SD.git synced 2024-06-11 05:29:27 +00:00
Code Issues Projects Releases Wiki Activity

Untested port of V6 multidev branch commit 3dc7c11acb55b16fd0a8a033f9fe877d7b18f269

Browse Source
This commit is contained in:
Michael McMaster 2021-01-02 22:51:19 +10:00
parent c59a94a16b
commit 35dec8a9fe
16 changed files with 485 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
software/SCSI2SD/src/cdrom.c
View File

@ -152,8 +152,8 @@ static void doReadTOC(int MSF, uint8_t track, uint16_t allocationLength)
if (track > 1) if (track > 1)
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -162,8 +162,9 @@ static void doReadTOC(int MSF, uint8_t track, uint16_t allocationLength)
memcpy(scsiDev.data, SimpleTOC, len); memcpy(scsiDev.data, SimpleTOC, len);
uint32_t capacity = getScsiCapacity( uint32_t capacity = getScsiCapacity(
scsoDev.target->device,
scsiDev.target->cfg->sdSectorStart, scsiDev.target->cfg->sdSectorStart,
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->scsiSectors); scsiDev.target->cfg->scsiSectors);
// Replace start of leadout track // Replace start of leadout track
@ -213,8 +214,8 @@ static void doReadFullTOC(int convertBCD, uint8_t session, uint16_t allocationLe
if (session > 1) if (session > 1)
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -297,8 +298,8 @@ int scsiCDRomCommand()
default: default:
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }

18
software/SCSI2SD/src/config.c
View File

@ -31,7 +31,7 @@
#include <string.h> #include <string.h>
static const uint16_t FIRMWARE_VERSION = 0x0484; static const uint16_t FIRMWARE_VERSION = 0x0485;
// 1 flash row // 1 flash row
static const uint8_t DEFAULT_CONFIG[256] = static const uint8_t DEFAULT_CONFIG[256] =
@ -175,9 +175,9 @@ pingCommand()
static void static void
sdInfoCommand() sdInfoCommand()
{ {
uint8_t response[sizeof(sdDev.csd) + sizeof(sdDev.cid)]; uint8_t response[sizeof(sdCard.csd) + sizeof(sdCard.cid)];
memcpy(response, sdDev.csd, sizeof(sdDev.csd)); memcpy(response, sdCard.csd, sizeof(sdCard.csd));
memcpy(response + sizeof(sdDev.csd), sdDev.cid, sizeof(sdDev.cid)); memcpy(response + sizeof(sdCard.csd), sdCard.cid, sizeof(sdCard.cid));
hidPacket_send(response, sizeof(response)); hidPacket_send(response, sizeof(response));
} }
@ -340,16 +340,16 @@ void debugPoll()
hidBuffer[23] = scsiDev.msgCount; hidBuffer[23] = scsiDev.msgCount;
hidBuffer[24] = scsiDev.cmdCount; hidBuffer[24] = scsiDev.cmdCount;
hidBuffer[25] = scsiDev.watchdogTick; hidBuffer[25] = scsiDev.watchdogTick;
hidBuffer[26] = blockDev.state; hidBuffer[26] = 0; // OBSOLETE. Previously media state
hidBuffer[27] = scsiDev.lastSenseASC >> 8; hidBuffer[27] = scsiDev.lastSenseASC >> 8;
hidBuffer[28] = scsiDev.lastSenseASC; hidBuffer[28] = scsiDev.lastSenseASC;
hidBuffer[29] = scsiReadDBxPins(); hidBuffer[29] = scsiReadDBxPins();
hidBuffer[30] = LastTrace; hidBuffer[30] = LastTrace;
hidBuffer[58] = sdDev.capacity >> 24; hidBuffer[58] = sdCard.capacity >> 24;
hidBuffer[59] = sdDev.capacity >> 16; hidBuffer[59] = sdCard.capacity >> 16;
hidBuffer[60] = sdDev.capacity >> 8; hidBuffer[60] = sdCard.capacity >> 8;
hidBuffer[61] = sdDev.capacity; hidBuffer[61] = sdCard.capacity;
hidBuffer[62] = FIRMWARE_VERSION >> 8; hidBuffer[62] = FIRMWARE_VERSION >> 8;
hidBuffer[63] = FIRMWARE_VERSION; hidBuffer[63] = FIRMWARE_VERSION;

22
software/SCSI2SD/src/diagnostic.c
View File

@ -50,8 +50,8 @@ void scsiSendDiagnostic()
// Nowhere to store this data! // Nowhere to store this data!
// Shouldn't happen - our buffer should be many magnitudes larger // Shouldn't happen - our buffer should be many magnitudes larger
// than the required size for diagnostic parameters. // than the required size for diagnostic parameters.
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
@ -95,14 +95,14 @@ void scsiReceiveDiagnostic()
// 64bit linear address, then convert back again. // 64bit linear address, then convert back again.
uint64 fromByteAddr = uint64 fromByteAddr =
scsiByteAddress( scsiByteAddress(
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->headsPerCylinder, scsiDev.target->cfg->headsPerCylinder,
scsiDev.target->cfg->sectorsPerTrack, scsiDev.target->cfg->sectorsPerTrack,
suppliedFmt, suppliedFmt,
&scsiDev.data[6]); &scsiDev.data[6]);
scsiSaveByteAddress( scsiSaveByteAddress(
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->headsPerCylinder, scsiDev.target->cfg->headsPerCylinder,
scsiDev.target->cfg->sectorsPerTrack, scsiDev.target->cfg->sectorsPerTrack,
translateFmt, translateFmt,
@ -121,8 +121,8 @@ void scsiReceiveDiagnostic()
{ {
// error. // error.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
@ -169,8 +169,8 @@ void scsiReadBuffer()
{ {
// error. // error.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -208,8 +208,8 @@ void scsiWriteBuffer()
{ {
// error. // error.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -219,7 +219,7 @@ void scsiWriteBuffer()
// Section 4.3.14 // Section 4.3.14
void scsiWriteSectorBuffer() void scsiWriteSectorBuffer()
{ {
scsiDev.dataLen = scsiDev.target->liveCfg.bytesPerSector; scsiDev.dataLen = scsiDev.target->state.bytesPerSector;
scsiDev.phase = DATA_OUT; scsiDev.phase = DATA_OUT;
scsiDev.postDataOutHook = doWriteBuffer; scsiDev.postDataOutHook = doWriteBuffer;
} }

106
software/SCSI2SD/src/disk.c
View File

@ -28,24 +28,8 @@
#include <string.h> #include <string.h>
// Global // Global
BlockDevice blockDev;
Transfer transfer; Transfer transfer;
static int doSdInit()
{
int result = 0;
if (blockDev.state & DISK_PRESENT)
{
result = sdInit();
if (result)
{
blockDev.state = blockDev.state | DISK_INITIALISED;
}
}
return result;
}
// Callback once all data has been read in the data out phase. // Callback once all data has been read in the data out phase.
static void doFormatUnitComplete(void) static void doFormatUnitComplete(void)
{ {
@ -93,7 +77,7 @@ static void doFormatUnitHeader(void)
// Save the "MODE SELECT savable parameters" // Save the "MODE SELECT savable parameters"
configSave( configSave(
scsiDev.target->targetId, scsiDev.target->targetId,
scsiDev.target->liveCfg.bytesPerSector); scsiDev.target->state.bytesPerSector);
} }
if (IP) if (IP)
@ -123,8 +107,10 @@ static void doReadCapacity()
int pmi = scsiDev.cdb[8] & 1; int pmi = scsiDev.cdb[8] & 1;
uint32_t capacity = getScsiCapacity( uint32_t capacity = getScsiCapacity(
scsiDev.target->device,
scsiDev.device,
scsiDev.target->cfg->sdSectorStart, scsiDev.target->cfg->sdSectorStart,
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->scsiSectors); scsiDev.target->cfg->scsiSectors);
if (!pmi && lba) if (!pmi && lba)
@ -134,8 +120,8 @@ static void doReadCapacity()
// assume that delays are constant across each block. But the spec // assume that delays are constant across each block. But the spec
// says we must return this error if pmi is specified incorrectly. // says we must return this error if pmi is specified incorrectly.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else if (capacity > 0) else if (capacity > 0)
@ -147,7 +133,7 @@ static void doReadCapacity()
scsiDev.data[2] = highestBlock >> 8; scsiDev.data[2] = highestBlock >> 8;
scsiDev.data[3] = highestBlock; scsiDev.data[3] = highestBlock;
uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector; uint32_t bytesPerSector = scsiDev.target->state.bytesPerSector;
scsiDev.data[4] = bytesPerSector >> 24; scsiDev.data[4] = bytesPerSector >> 24;
scsiDev.data[5] = bytesPerSector >> 16; scsiDev.data[5] = bytesPerSector >> 16;
scsiDev.data[6] = bytesPerSector >> 8; scsiDev.data[6] = bytesPerSector >> 8;
@ -158,8 +144,8 @@ static void doReadCapacity()
else else
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = NOT_READY; scsiDev.target->state.sense.code = NOT_READY;
scsiDev.target->sense.asc = MEDIUM_NOT_PRESENT; scsiDev.target->state.sense.asc = MEDIUM_NOT_PRESENT;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -172,19 +158,21 @@ static void doWrite(uint32 lba, uint32 blocks)
CyDelay(10); CyDelay(10);
} }
uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector; uint32_t bytesPerSector = scsiDev.target->state.bytesPerSector;
MEDIA_STATE* mediaState = &(scsiDev.target->device->mediaState);
if (unlikely(blockDev.state & DISK_WP) || if (unlikely(*mediaState & MEDIA_WP) ||
unlikely(scsiDev.target->cfg->deviceType == CONFIG_OPTICAL)) unlikely(scsiDev.target->cfg->deviceType == CONFIG_OPTICAL))
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = WRITE_PROTECTED; scsiDev.target->state.sense.asc = WRITE_PROTECTED;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else if (unlikely(((uint64) lba) + blocks > else if (unlikely(((uint64) lba) + blocks >
getScsiCapacity( getScsiCapacity(
scsiDev->device,
scsiDev.target->cfg->sdSectorStart, scsiDev.target->cfg->sdSectorStart,
bytesPerSector, bytesPerSector,
scsiDev.target->cfg->scsiSectors scsiDev.target->cfg->scsiSectors
@ -192,8 +180,8 @@ static void doWrite(uint32 lba, uint32 blocks)
)) ))
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; scsiDev.target->state.sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -231,13 +219,13 @@ static void doRead(uint32 lba, uint32 blocks)
uint32_t capacity = getScsiCapacity( uint32_t capacity = getScsiCapacity(
scsiDev.target->cfg->sdSectorStart, scsiDev.target->cfg->sdSectorStart,
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->scsiSectors); scsiDev.target->cfg->scsiSectors);
if (unlikely(((uint64) lba) + blocks > capacity)) if (unlikely(((uint64) lba) + blocks > capacity))
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; scsiDev.target->state.sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -248,7 +236,7 @@ static void doRead(uint32 lba, uint32 blocks)
scsiDev.phase = DATA_IN; scsiDev.phase = DATA_IN;
scsiDev.dataLen = 0; // No data yet scsiDev.dataLen = 0; // No data yet
uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector; uint32_t bytesPerSector = scsiDev.target->state.bytesPerSector;
uint32_t sdSectorPerSCSISector = SDSectorsPerSCSISector(bytesPerSector); uint32_t sdSectorPerSCSISector = SDSectorsPerSCSISector(bytesPerSector);
uint32_t sdSectors = uint32_t sdSectors =
blocks * sdSectorPerSCSISector; blocks * sdSectorPerSCSISector;
@ -284,13 +272,13 @@ static void doSeek(uint32 lba)
if (lba >= if (lba >=
getScsiCapacity( getScsiCapacity(
scsiDev.target->cfg->sdSectorStart, scsiDev.target->cfg->sdSectorStart,
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->scsiSectors) scsiDev.target->cfg->scsiSectors)
) )
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE; scsiDev.target->state.sense.asc = LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -301,33 +289,35 @@ static void doSeek(uint32 lba)
static int doTestUnitReady() static int doTestUnitReady()
{ {
MEDIA_STATE* mediaState = &(scsiDev.target->device->mediaState);
int ready = 1; int ready = 1;
if (likely(blockDev.state == (DISK_STARTED | DISK_PRESENT | DISK_INITIALISED))) if (likely(*mediaState == (MEDIA_STARTED | MEDIA_PRESENT | MEDIA_INITIALISED)))
{ {
// nothing to do. // nothing to do.
} }
else if (unlikely(!(blockDev.state & DISK_STARTED))) else if (unlikely(!(*mediaState & MEDIA_STARTED)))
{ {
ready = 0; ready = 0;
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = NOT_READY; scsiDev.target->state.sense.code = NOT_READY;
scsiDev.target->sense.asc = LOGICAL_UNIT_NOT_READY_INITIALIZING_COMMAND_REQUIRED; scsiDev.target->state.sense.asc = LOGICAL_UNIT_NOT_READY_INITIALIZING_COMMAND_REQUIRED;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else if (unlikely(!(blockDev.state & DISK_PRESENT))) else if (unlikely(!(*mediaState & MEDIA_PRESENT)))
{ {
ready = 0; ready = 0;
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = NOT_READY; scsiDev.target->state.sense.code = NOT_READY;
scsiDev.target->sense.asc = MEDIUM_NOT_PRESENT; scsiDev.target->state.sense.asc = MEDIUM_NOT_PRESENT;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else if (unlikely(!(blockDev.state & DISK_INITIALISED))) else if (unlikely(!(*mediaState & MEDIA_INITIALISED)))
{ {
ready = 0; ready = 0;
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = NOT_READY; scsiDev.target->state.sense.code = NOT_READY;
scsiDev.target->sense.asc = LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE; scsiDev.target->state.sense.asc = LOGICAL_UNIT_NOT_READY_CAUSE_NOT_REPORTABLE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
return ready; return ready;
@ -347,17 +337,21 @@ int scsiDiskCommand()
//int immed = scsiDev.cdb[1] & 1; //int immed = scsiDev.cdb[1] & 1;
int start = scsiDev.cdb[4] & 1; int start = scsiDev.cdb[4] & 1;
MEDIA_STATE* mediaState = &(scsiDev.target->device->mediaState);
if (start) if (start)
{ {
blockDev.state = blockDev.state | DISK_STARTED; *mediaState = *mediaState | MEDIA_STARTED;
if (!(blockDev.state & DISK_INITIALISED)) if (!(*mediaState & MEDIA_INITIALISED))
{ {
doSdInit(); if (*mediaState & MEDIA_PRESENT)
{
*mediaState = *mediaState | MEDIA_INITIALISED;
}
} }
} }
else else
{ {
blockDev.state &= ~DISK_STARTED; *mediaState &= ~MEDIA_STARTED;
} }
} }
else if (unlikely(command == 0x00)) else if (unlikely(command == 0x00))
@ -514,8 +508,8 @@ int scsiDiskCommand()
// TODO. This means they are supplying data to verify against. // TODO. This means they are supplying data to verify against.
// Technically we should probably grab the data and compare it. // Technically we should probably grab the data and compare it.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -548,7 +542,7 @@ int scsiDiskCommand()
void scsiDiskPoll() void scsiDiskPoll()
{ {
uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector; uint32_t bytesPerSector = scsiDev.target->state.bytesPerSector;
if (scsiDev.phase == DATA_IN && if (scsiDev.phase == DATA_IN &&
transfer.currentBlock != transfer.blocks) transfer.currentBlock != transfer.blocks)
@ -799,8 +793,8 @@ void scsiDiskPoll()
(scsiDev.boardCfg.flags & CONFIG_ENABLE_PARITY) && (scsiDev.boardCfg.flags & CONFIG_ENABLE_PARITY) &&
(scsiDev.compatMode >= COMPAT_SCSI2)) (scsiDev.compatMode >= COMPAT_SCSI2))
{ {
scsiDev.target->sense.code = ABORTED_COMMAND; scsiDev.target->state.sense.code = ABORTED_COMMAND;
scsiDev.target->sense.asc = SCSI_PARITY_ERROR; scsiDev.target->state.sense.asc = SCSI_PARITY_ERROR;
scsiDev.status = CHECK_CONDITION;; scsiDev.status = CHECK_CONDITION;;
} }
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
@ -834,8 +828,6 @@ void scsiDiskInit()
{ {
scsiDiskReset(); scsiDiskReset();
// Don't require the host to send us a START STOP UNIT command
blockDev.state = DISK_STARTED;
// WP pin not available for micro-sd // WP pin not available for micro-sd
// TODO read card WP register // TODO read card WP register
#if 0 #if 0

14
software/SCSI2SD/src/disk.h
View File

@ -17,25 +17,12 @@
#ifndef DISK_H #ifndef DISK_H
#define DISK_H #define DISK_H
typedef enum
{
DISK_STARTED = 1, // Controlled via START STOP UNIT
DISK_PRESENT = 2, // SD card is physically present
DISK_INITIALISED = 4, // SD card responded to init sequence
DISK_WP = 8 // Write-protect.
} DISK_STATE;
typedef enum typedef enum
{ {
TRANSFER_READ, TRANSFER_READ,
TRANSFER_WRITE TRANSFER_WRITE
} TRANSFER_DIR; } TRANSFER_DIR;
typedef struct
{
int state;
} BlockDevice;
typedef struct typedef struct
{ {
int multiBlock; // True if we're using a multi-block SPI transfer. int multiBlock; // True if we're using a multi-block SPI transfer.
@ -45,7 +32,6 @@ typedef struct
uint32 currentBlock; uint32 currentBlock;
} Transfer; } Transfer;
extern BlockDevice blockDev;
extern Transfer transfer; extern Transfer transfer;
void scsiDiskInit(void); void scsiDiskInit(void);

3
software/SCSI2SD/src/geometry.h
View File

@ -20,7 +20,7 @@
#include "device.h" #include "device.h"
#include "config.h" #include "config.h"
#include "sd.h" #include "storedevice.h"
typedef enum typedef enum
{ {
@ -35,6 +35,7 @@ static inline int SDSectorsPerSCSISector(uint16_t bytesPerSector)
} }
uint32_t getScsiCapacity( uint32_t getScsiCapacity(
S2S_Device* device,
uint32_t sdSectorStart, uint32_t sdSectorStart,
uint16_t bytesPerSector, uint16_t bytesPerSector,
uint32_t scsiSectors); uint32_t scsiSectors);

12
software/SCSI2SD/src/inquiry.c
View File

@ -116,8 +116,8 @@ static void useCustomVPD(const TargetConfig* cfg, int pageCode)
{ {
// error. // error.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -141,8 +141,8 @@ void scsiInquiry()
{ {
// error. // error.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -206,8 +206,8 @@ void scsiInquiry()
{ {
// error. // error.
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }

16
software/SCSI2SD/src/main.c
View File

@ -29,6 +29,7 @@ int main()
{ {
timeInit(); timeInit();
ledInit(); ledInit();
s2s_deviceEarlyInit();
traceInit(); traceInit();
// Enable global interrupts. // Enable global interrupts.
@ -41,6 +42,7 @@ int main()
configInit(&scsiDev.boardCfg); configInit(&scsiDev.boardCfg);
debugInit(); debugInit();
scsiPhyConfig(); scsiPhyConfig();
scsiInit(); scsiInit();
@ -60,7 +62,6 @@ int main()
++delaySeconds; ++delaySeconds;
} }
uint32_t lastSDPoll = getTime_ms();
sdCheckPresent(); sdCheckPresent();
while (1) while (1)
@ -74,10 +75,10 @@ int main()
if (unlikely(scsiDev.phase == BUS_FREE)) if (unlikely(scsiDev.phase == BUS_FREE))
{ {
if (unlikely(elapsedTime_ms(lastSDPoll) > 200)) if (s2s_pollMediaChange())
{ {
lastSDPoll = getTime_ms(); scsiPhyConfig();
sdCheckPresent(); scsiInit();
} }
else else
{ {
@ -94,10 +95,11 @@ int main()
CyExitCriticalSection(interruptState); CyExitCriticalSection(interruptState);
} }
} }
else if ((scsiDev.phase >= 0) && (blockDev.state & DISK_PRESENT)) else if ((scsiDev.phase >= 0) &&
scsiDev.target &&
(scsiDev.target->device->mediaState & MEDIA_PRESENT))
{ {
// don't waste time scanning SD cards while we're doing disk IO scsiDev.target->device->pollMediaBusy();
lastSDPoll = getTime_ms();
} }
} }
return 0; return 0;

44
software/SCSI2SD/src/mode.c
View File

@ -269,7 +269,12 @@ static int useCustomPages(const TargetConfig* cfg, int pc, int pageCode, int* id
} }
static void doModeSense( static void doModeSense(
int sixByteCmd, int dbd, int pc, int pageCode, int allocLength) S2S_Device* dev,
int sixByteCmd,
int dbd,
int pc,
int pageCode,
int allocLength)
{ {
////////////// Mode Parameter Header ////////////// Mode Parameter Header
//////////////////////////////////// ////////////////////////////////////
@ -288,14 +293,14 @@ static void doModeSense(
mediumType = 0; // We should support various floppy types here! mediumType = 0; // We should support various floppy types here!
// Contains cache bits (0) and a Write-Protect bit. // Contains cache bits (0) and a Write-Protect bit.
deviceSpecificParam = deviceSpecificParam =
(blockDev.state & DISK_WP) ? 0x80 : 0; (dev->mediaState & MEDIA_WP) ? 0x80 : 0;
density = 0; // reserved for direct access density = 0; // reserved for direct access
break; break;
case CONFIG_FLOPPY_14MB: case CONFIG_FLOPPY_14MB:
mediumType = 0x1E; // 90mm/3.5" mediumType = 0x1E; // 90mm/3.5"
deviceSpecificParam = deviceSpecificParam =
(blockDev.state & DISK_WP) ? 0x80 : 0; (dev->mediaState & MEDIA_WP) ? 0x80 : 0;
density = 0; // reserved for direct access density = 0; // reserved for direct access
break; break;
@ -308,14 +313,14 @@ static void doModeSense(
case CONFIG_SEQUENTIAL: case CONFIG_SEQUENTIAL:
mediumType = 0; // reserved mediumType = 0; // reserved
deviceSpecificParam = deviceSpecificParam =
(blockDev.state & DISK_WP) ? 0x80 : 0; (dev->mediaState & MEDIA_WP) ? 0x80 : 0;
density = 0x13; // DAT Data Storage, X3B5/88-185A density = 0x13; // DAT Data Storage, X3B5/88-185A
break; break;
case CONFIG_MO: case CONFIG_MO:
mediumType = 0x03; // Optical reversible or erasable medium mediumType = 0x03; // Optical reversible or erasable medium
deviceSpecificParam = deviceSpecificParam =
(blockDev.state & DISK_WP) ? 0x80 : 0; (dev->mediaState & MEDIA_WP) ? 0x80 : 0;
density = 0x00; // Default density = 0x00; // Default
break; break;
@ -368,7 +373,7 @@ static void doModeSense(
scsiDev.data[idx++] = 0; // reserved scsiDev.data[idx++] = 0; // reserved
// Block length // Block length
uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector; uint32_t bytesPerSector = scsiDev.target->state.bytesPerSector;
scsiDev.data[idx++] = bytesPerSector >> 16; scsiDev.data[idx++] = bytesPerSector >> 16;
scsiDev.data[idx++] = bytesPerSector >> 8; scsiDev.data[idx++] = bytesPerSector >> 8;
scsiDev.data[idx++] = bytesPerSector & 0xFF; scsiDev.data[idx++] = bytesPerSector & 0xFF;
@ -423,7 +428,7 @@ static void doModeSense(
scsiDev.data[idx+11] = sectorsPerTrack & 0xFF; scsiDev.data[idx+11] = sectorsPerTrack & 0xFF;
// Fill out the configured bytes-per-sector // Fill out the configured bytes-per-sector
uint32_t bytesPerSector = scsiDev.target->liveCfg.bytesPerSector; uint32_t bytesPerSector = scsiDev.target->state.bytesPerSector;
scsiDev.data[idx+12] = bytesPerSector >> 8; scsiDev.data[idx+12] = bytesPerSector >> 8;
scsiDev.data[idx+13] = bytesPerSector & 0xFF; scsiDev.data[idx+13] = bytesPerSector & 0xFF;
} }
@ -457,8 +462,9 @@ static void doModeSense(
uint32 sector; uint32 sector;
LBA2CHS( LBA2CHS(
getScsiCapacity( getScsiCapacity(
scsiDev.target->device,
scsiDev.target->cfg->sdSectorStart, scsiDev.target->cfg->sdSectorStart,
scsiDev.target->liveCfg.bytesPerSector, scsiDev.target->state.bytesPerSector,
scsiDev.target->cfg->scsiSectors), scsiDev.target->cfg->scsiSectors),
&cyl, &cyl,
&head, &head,
@ -557,8 +563,8 @@ static void doModeSense(
// Unknown Page Code // Unknown Page Code
pageFound = 0; pageFound = 0;
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -617,7 +623,7 @@ static void doModeSelect(void)
} }
else else
{ {
scsiDev.target->liveCfg.bytesPerSector = bytesPerSector; scsiDev.target->state.bytesPerSector = bytesPerSector;
if (bytesPerSector != scsiDev.target->cfg->bytesPerSector) if (bytesPerSector != scsiDev.target->cfg->bytesPerSector)
{ {
configSave(scsiDev.target->targetId, bytesPerSector); configSave(scsiDev.target->targetId, bytesPerSector);
@ -650,7 +656,7 @@ static void doModeSelect(void)
goto bad; goto bad;
} }
scsiDev.target->liveCfg.bytesPerSector = bytesPerSector; scsiDev.target->state.bytesPerSector = bytesPerSector;
if (scsiDev.cdb[1] & 1) // SP Save Pages flag if (scsiDev.cdb[1] & 1) // SP Save Pages flag
{ {
configSave(scsiDev.target->targetId, bytesPerSector); configSave(scsiDev.target->targetId, bytesPerSector);
@ -669,14 +675,14 @@ static void doModeSelect(void)
goto out; goto out;
bad: bad:
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_PARAMETER_LIST; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_PARAMETER_LIST;
out: out:
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
int scsiModeCommand() int scsiModeCommand(S2S_Device* dev)
{ {
int commandHandled = 1; int commandHandled = 1;
@ -696,7 +702,7 @@ int scsiModeCommand()
// SCSI1 standard: (CCS X3T9.2/86-52) // SCSI1 standard: (CCS X3T9.2/86-52)
// "An Allocation Length of zero indicates that no MODE SENSE data shall // "An Allocation Length of zero indicates that no MODE SENSE data shall
// be transferred. This condition shall not be considered as an error." // be transferred. This condition shall not be considered as an error."
doModeSense(1, dbd, pc, pageCode, allocLength); doModeSense(dev, 1, dbd, pc, pageCode, allocLength);
} }
else if (command == 0x5A) else if (command == 0x5A)
{ {
@ -707,7 +713,7 @@ int scsiModeCommand()
int allocLength = int allocLength =
(((uint16) scsiDev.cdb[7]) << 8) + (((uint16) scsiDev.cdb[7]) << 8) +
scsiDev.cdb[8]; scsiDev.cdb[8];
doModeSense(0, dbd, pc, pageCode, allocLength); doModeSense(dev, 0, dbd, pc, pageCode, allocLength);
} }
else if (command == 0x15) else if (command == 0x15)
{ {

2
software/SCSI2SD/src/mode.h
View File

@ -17,6 +17,6 @@
#ifndef MODE_H #ifndef MODE_H
#define MODE_H #define MODE_H
int scsiModeCommand(void); int scsiModeCommand(S2S_Device* dev);
#endif #endif

158
software/SCSI2SD/src/scsi.c
View File

@ -132,8 +132,8 @@ static void enter_Status(uint8 status)
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
scsiDev.lastStatus = scsiDev.status; scsiDev.lastStatus = scsiDev.status;
scsiDev.lastSense = scsiDev.target->sense.code; scsiDev.lastSense = scsiDev.target->state.sense.code;
scsiDev.lastSenseASC = scsiDev.target->sense.asc; scsiDev.lastSenseASC = scsiDev.target->state.sense.asc;
} }
void process_Status() void process_Status()
@ -192,7 +192,7 @@ void process_Status()
} }
else if (scsiDev.target->cfg->quirks == CONFIG_QUIRKS_OMTI) else if (scsiDev.target->cfg->quirks == CONFIG_QUIRKS_OMTI)
{ {
scsiDev.status |= (scsiDev.target->targetId & 0x03) << 5; scsiDev.status |= (scsiDev.target->cfg->scsiId & 0x03) << 5;
scsiWriteByte(scsiDev.status); scsiWriteByte(scsiDev.status);
} }
else else
@ -201,8 +201,8 @@ void process_Status()
} }
scsiDev.lastStatus = scsiDev.status; scsiDev.lastStatus = scsiDev.status;
scsiDev.lastSense = scsiDev.target->sense.code; scsiDev.lastSense = scsiDev.target->state.sense.code;
scsiDev.lastSenseASC = scsiDev.target->sense.asc; scsiDev.lastSenseASC = scsiDev.target->state.sense.asc;
// Command Complete occurs AFTER a valid status has been // Command Complete occurs AFTER a valid status has been
@ -262,8 +262,8 @@ static void process_DataOut()
(scsiDev.boardCfg.flags & CONFIG_ENABLE_PARITY) && (scsiDev.boardCfg.flags & CONFIG_ENABLE_PARITY) &&
(scsiDev.compatMode >= COMPAT_SCSI2)) (scsiDev.compatMode >= COMPAT_SCSI2))
{ {
scsiDev.target->sense.code = ABORTED_COMMAND; scsiDev.target->state.sense.code = ABORTED_COMMAND;
scsiDev.target->sense.asc = SCSI_PARITY_ERROR; scsiDev.target->state.sense.asc = SCSI_PARITY_ERROR;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
} }
@ -318,15 +318,11 @@ static void process_Command()
// http://bitsavers.trailing-edge.com/pdf/xebec/104524C_S1410Man_Aug83.pdf // http://bitsavers.trailing-edge.com/pdf/xebec/104524C_S1410Man_Aug83.pdf
if ((scsiDev.lun > 0) && (scsiDev.boardCfg.flags & CONFIG_MAP_LUNS_TO_IDS)) if ((scsiDev.lun > 0) && (scsiDev.boardCfg.flags & CONFIG_MAP_LUNS_TO_IDS))
{ {
int tgtIndex; S2S_Target* lunTarget = s2s_DeviceFindByScsiId(scsiDev.lun);
for (tgtIndex = 0; tgtIndex < MAX_SCSI_TARGETS; ++tgtIndex) if (lunTarget! = NULL)
{ {
if (scsiDev.targets[tgtIndex].targetId == scsiDev.lun) scsiDev.target = lunTarget;
{ scsiDev.lun = 0;
scsiDev.target = &scsiDev.targets[tgtIndex];
scsiDev.lun = 0;
break;
}
} }
} }
@ -347,8 +343,8 @@ static void process_Command()
(scsiDev.boardCfg.flags & CONFIG_ENABLE_PARITY) && (scsiDev.boardCfg.flags & CONFIG_ENABLE_PARITY) &&
(scsiDev.compatMode >= COMPAT_SCSI2)) (scsiDev.compatMode >= COMPAT_SCSI2))
{ {
scsiDev.target->sense.code = ABORTED_COMMAND; scsiDev.target->state.sense.code = ABORTED_COMMAND;
scsiDev.target->sense.asc = SCSI_PARITY_ERROR; scsiDev.target->state.sense.asc = SCSI_PARITY_ERROR;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
else if ((control & 0x02) && ((control & 0x01) == 0) && else if ((control & 0x02) && ((control & 0x01) == 0) &&
@ -356,8 +352,8 @@ static void process_Command()
likely(scsiDev.target->cfg->quirks != CONFIG_QUIRKS_XEBEC)) likely(scsiDev.target->cfg->quirks != CONFIG_QUIRKS_XEBEC))
{ {
// FLAG set without LINK flag. // FLAG set without LINK flag.
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
else if (command == 0x12) else if (command == 0x12)
@ -373,11 +369,11 @@ static void process_Command()
{ {
// Completely non-standard // Completely non-standard
allocLength = 4; allocLength = 4;
if (scsiDev.target->sense.code == NO_SENSE) if (scsiDev.target->state.sense.code == NO_SENSE)
scsiDev.data[0] = 0; scsiDev.data[0] = 0;
else if (scsiDev.target->sense.code == ILLEGAL_REQUEST) else if (scsiDev.target->state.sense.code == ILLEGAL_REQUEST)
scsiDev.data[0] = 0x20; // Illegal command scsiDev.data[0] = 0x20; // Illegal command
else if (scsiDev.target->sense.code == NOT_READY) else if (scsiDev.target->state.sense.code == NOT_READY)
scsiDev.data[0] = 0x04; // Drive not ready scsiDev.data[0] = 0x04; // Drive not ready
else else
scsiDev.data[0] = 0x11; // Uncorrectable data error scsiDev.data[0] = 0x11; // Uncorrectable data error
@ -395,7 +391,7 @@ static void process_Command()
memset(scsiDev.data, 0, 256); // Max possible alloc length memset(scsiDev.data, 0, 256); // Max possible alloc length
scsiDev.data[0] = 0xF0; scsiDev.data[0] = 0xF0;
scsiDev.data[2] = scsiDev.target->sense.code & 0x0F; scsiDev.data[2] = scsiDev.target->state.sense.code & 0x0F;
scsiDev.data[3] = transfer.lba >> 24; scsiDev.data[3] = transfer.lba >> 24;
scsiDev.data[4] = transfer.lba >> 16; scsiDev.data[4] = transfer.lba >> 16;
@ -404,45 +400,45 @@ static void process_Command()
// Additional bytes if there are errors to report // Additional bytes if there are errors to report
scsiDev.data[7] = 10; // additional length scsiDev.data[7] = 10; // additional length
scsiDev.data[12] = scsiDev.target->sense.asc >> 8; scsiDev.data[12] = scsiDev.target->state.sense.asc >> 8;
scsiDev.data[13] = scsiDev.target->sense.asc; scsiDev.data[13] = scsiDev.target->state.sense.asc;
} }
// Silently truncate results. SCSI-2 spec 8.2.14. // Silently truncate results. SCSI-2 spec 8.2.14.
enter_DataIn(allocLength); enter_DataIn(allocLength);
// This is a good time to clear out old sense information. // This is a good time to clear out old sense information.
scsiDev.target->sense.code = NO_SENSE; scsiDev.target->state.sense.code = NO_SENSE;
scsiDev.target->sense.asc = NO_ADDITIONAL_SENSE_INFORMATION; scsiDev.target->state.sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
} }
// Some old SCSI drivers do NOT properly support // Some old SCSI drivers do NOT properly support
// unitAttention. eg. the Mac Plus would trigger a SCSI reset // unitAttention. eg. the Mac Plus would trigger a SCSI reset
// on receiving the unit attention response on boot, thus // on receiving the unit attention response on boot, thus
// triggering another unit attention condition. // triggering another unit attention condition.
else if (scsiDev.target->unitAttention && else if (scsiDev.target->state.unitAttention &&
(scsiDev.boardCfg.flags & CONFIG_ENABLE_UNIT_ATTENTION)) (scsiDev.boardCfg.flags & CONFIG_ENABLE_UNIT_ATTENTION))
{ {
scsiDev.target->sense.code = UNIT_ATTENTION; scsiDev.target->state.sense.code = UNIT_ATTENTION;
scsiDev.target->sense.asc = scsiDev.target->unitAttention; scsiDev.target->state.sense.asc = scsiDev.target->state.unitAttention;
// If initiator doesn't do REQUEST SENSE for the next command, then // If initiator doesn't do REQUEST SENSE for the next command, then
// data is lost. // data is lost.
scsiDev.target->unitAttention = 0; scsiDev.target->state.unitAttention = 0;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
else if (scsiDev.lun) else if (scsiDev.lun)
{ {
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = LOGICAL_UNIT_NOT_SUPPORTED; scsiDev.target->state.sense.asc = LOGICAL_UNIT_NOT_SUPPORTED;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
else if (command == 0x17 || command == 0x16) else if (command == 0x17 || command == 0x16)
{ {
doReserveRelease(); doReserveRelease();
} }
else if ((scsiDev.target->reservedId >= 0) && else if ((scsiDev.target->state.reservedId >= 0) &&
(scsiDev.target->reservedId != scsiDev.initiatorId)) (scsiDev.target->state.reservedId != scsiDev.initiatorId))
{ {
enter_Status(CONFLICT); enter_Status(CONFLICT);
} }
@ -481,10 +477,10 @@ static void process_Command()
{ {
scsiReadBuffer(); scsiReadBuffer();
} }
else if (!scsiModeCommand() && !scsiVendorCommand()) else if (!scsiModeCommand(scsiDev.target->device) && !scsiVendorCommand())
{ {
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_COMMAND_OPERATION_CODE; scsiDev.target->state.sense.asc = INVALID_COMMAND_OPERATION_CODE;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
@ -504,25 +500,25 @@ static void doReserveRelease()
uint8 command = scsiDev.cdb[0]; uint8 command = scsiDev.cdb[0];
int canRelease = int canRelease =
(!thirdPty && (scsiDev.initiatorId == scsiDev.target->reservedId)) || (!thirdPty && (scsiDev.initiatorId == scsiDev.target->state.reservedId)) ||
(thirdPty && (thirdPty &&
(scsiDev.target->reserverId == scsiDev.initiatorId) && (scsiDev.target->state.reserverId == scsiDev.initiatorId) &&
(scsiDev.target->reservedId == thirdPtyId) (scsiDev.target->state.reservedId == thirdPtyId)
); );
if (extentReservation) if (extentReservation)
{ {
// Not supported. // Not supported.
scsiDev.target->sense.code = ILLEGAL_REQUEST; scsiDev.target->state.sense.code = ILLEGAL_REQUEST;
scsiDev.target->sense.asc = INVALID_FIELD_IN_CDB; scsiDev.target->state.sense.asc = INVALID_FIELD_IN_CDB;
enter_Status(CHECK_CONDITION); enter_Status(CHECK_CONDITION);
} }
else if (command == 0x17) // release else if (command == 0x17) // release
{ {
if ((scsiDev.target->reservedId < 0) || canRelease) if ((scsiDev.target->state.reservedId < 0) || canRelease)
{ {
scsiDev.target->reservedId = -1; scsiDev.target->state.reservedId = -1;
scsiDev.target->reserverId = -1; scsiDev.target->state.reserverId = -1;
} }
else else
{ {
@ -531,16 +527,16 @@ static void doReserveRelease()
} }
else // assume reserve. else // assume reserve.
{ {
if ((scsiDev.target->reservedId < 0) || canRelease) if ((scsiDev.target->state.reservedId < 0) || canRelease)
{ {
scsiDev.target->reserverId = scsiDev.initiatorId; scsiDev.target->state.reserverId = scsiDev.initiatorId;
if (thirdPty) if (thirdPty)
{ {
scsiDev.target->reservedId = thirdPtyId; scsiDev.target->state.reservedId = thirdPtyId;
} }
else else
{ {
scsiDev.target->reservedId = scsiDev.initiatorId; scsiDev.target->state.reservedId = scsiDev.initiatorId;
} }
} }
else else
@ -569,14 +565,14 @@ static void scsiReset()
if (scsiDev.target) if (scsiDev.target)
{ {
if (scsiDev.target->unitAttention != POWER_ON_RESET) if (scsiDev.target->state.unitAttention != POWER_ON_RESET)
{ {
scsiDev.target->unitAttention = SCSI_BUS_RESET; scsiDev.target->state.unitAttention = SCSI_BUS_RESET;
} }
scsiDev.target->reservedId = -1; scsiDev.target->state.reservedId = -1;
scsiDev.target->reserverId = -1; scsiDev.target->state.reserverId = -1;
scsiDev.target->sense.code = NO_SENSE; scsiDev.target->state.sense.code = NO_SENSE;
scsiDev.target->sense.asc = NO_ADDITIONAL_SENSE_INFORMATION; scsiDev.target->state.sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
} }
scsiDev.target = NULL; scsiDev.target = NULL;
scsiDiskReset(); scsiDiskReset();
@ -666,16 +662,16 @@ static void process_SelectionPhase()
int goodParity = (Lookup_OddParity[mask] == SCSI_ReadPin(SCSI_In_DBP)); int goodParity = (Lookup_OddParity[mask] == SCSI_ReadPin(SCSI_In_DBP));
int atnFlag = SCSI_ReadFilt(SCSI_Filt_ATN); int atnFlag = SCSI_ReadFilt(SCSI_Filt_ATN);
int tgtIndex; S2S_Target* target = NULL;
TargetState* target = NULL; for (int testIdx = 0; testtIndex < 8; ++testtIndex)
for (tgtIndex = 0; tgtIndex < MAX_SCSI_TARGETS; ++tgtIndex)
{ {
if (mask & (1 << scsiDev.targets[tgtIndex].targetId)) target = s2s_DeviceFindByScsiId(1 << testIdx);
if (target)
{ {
target = &scsiDev.targets[tgtIndex];
break; break;
} }
} }
sel &= (selLatchCfg && scsiDev.selFlag) || SCSI_ReadFilt(SCSI_Filt_SEL); sel &= (selLatchCfg && scsiDev.selFlag) || SCSI_ReadFilt(SCSI_Filt_SEL);
bsy |= SCSI_ReadFilt(SCSI_Filt_BSY); bsy |= SCSI_ReadFilt(SCSI_Filt_BSY);
#ifdef SCSI_In_IO #ifdef SCSI_In_IO
@ -709,7 +705,7 @@ static void process_SelectionPhase()
// controllers don't generate parity bits. // controllers don't generate parity bits.
if (!scsiDev.atnFlag) if (!scsiDev.atnFlag)
{ {
target->unitAttention = 0; target->state.unitAttention = 0;
scsiDev.compatMode = COMPAT_SCSI1; scsiDev.compatMode = COMPAT_SCSI1;
} }
else if (!(scsiDev.boardCfg.flags & CONFIG_ENABLE_SCSI2)) else if (!(scsiDev.boardCfg.flags & CONFIG_ENABLE_SCSI2))
@ -816,11 +812,11 @@ static void process_MessageOut()
scsiDiskReset(); scsiDiskReset();
scsiDev.target->unitAttention = SCSI_BUS_RESET; scsiDev.target->state.unitAttention = SCSI_BUS_RESET;
// ANY initiator can reset the reservation state via this message. // ANY initiator can reset the reservation state via this message.
scsiDev.target->reservedId = -1; scsiDev.target->state.reservedId = -1;
scsiDev.target->reserverId = -1; scsiDev.target->state.reserverId = -1;
enter_BusFree(); enter_BusFree();
} }
else if (scsiDev.msgOut == 0x05) else if (scsiDev.msgOut == 0x05)
@ -1055,27 +1051,25 @@ void scsiInit()
scsiDev.target = NULL; scsiDev.target = NULL;
scsiDev.compatMode = COMPAT_UNKNOWN; scsiDev.compatMode = COMPAT_UNKNOWN;
int i; int deviceCount;
for (i = 0; i < MAX_SCSI_TARGETS; ++i) S2S_Device* allDevices = s2s_GetDevices(&deviceCount);
for (int devIdx = 0; devIdx < deviceCount; ++devIdx)
{ {
const TargetConfig* cfg = getConfigByIndex(i); int targetCount;
if (cfg && (cfg->scsiId & CONFIG_TARGET_ENABLED)) S2S_Target* targets = devices[deviceIdx].getTargets(devices + deviceIdx, &targetCount);
{
scsiDev.targets[i].targetId = cfg->scsiId & CONFIG_TARGET_ID_BITS;
scsiDev.targets[i].cfg = cfg;
scsiDev.targets[i].liveCfg.bytesPerSector = cfg->bytesPerSector; for (int i = 0; i < targetCount; ++i)
}
else
{ {
scsiDev.targets[i].targetId = 0xff; S2S_TargetState* state = &(targets[i].state);
scsiDev.targets[i].cfg = NULL;
scsiDev.targets[i].state.reservedId = -1;
scsiDev.targets[i].state.reserverId = -1;
scsiDev.targets[i].state.unitAttention = POWER_ON_RESET;
scsiDev.targets[i].state.sense.code = NO_SENSE;
scsiDev.targets[i].state.sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
state->bytesPerSector = targets[i].cfg->bytesPerSector;
} }
scsiDev.targets[i].reservedId = -1;
scsiDev.targets[i].reserverId = -1;
scsiDev.targets[i].unitAttention = POWER_ON_RESET;
scsiDev.targets[i].sense.code = NO_SENSE;
scsiDev.targets[i].sense.asc = NO_ADDITIONAL_SENSE_INFORMATION;
} }
} }

32
software/SCSI2SD/src/scsi.h
View File

@ -17,8 +17,8 @@
#ifndef SCSI_H #ifndef SCSI_H
#define SCSI_H #define SCSI_H
#include "storedevice.h"
#include "geometry.h" #include "geometry.h"
#include "sense.h"
typedef enum typedef enum
{ {
@ -73,37 +73,9 @@ typedef enum
#define MAX_SECTOR_SIZE 8192 #define MAX_SECTOR_SIZE 8192
#define MIN_SECTOR_SIZE 64 #define MIN_SECTOR_SIZE 64
// Shadow parameters, possibly not saved to flash yet.
// Set via Mode Select
typedef struct typedef struct
{ {
uint16_t bytesPerSector; S2S_Target* target;
} LiveCfg;
typedef struct
{
uint8_t targetId;
const TargetConfig* cfg;
LiveCfg liveCfg;
ScsiSense sense;
uint16 unitAttention; // Set to the sense qualifier key to be returned.
// Only let the reserved initiator talk to us.
// A 3rd party may be sending the RESERVE/RELEASE commands
int reservedId; // 0 -> 7 if reserved. -1 if not reserved.
int reserverId; // 0 -> 7 if reserved. -1 if not reserved.
} TargetState;
typedef struct
{
TargetState targets[MAX_SCSI_TARGETS];
TargetState* target;
BoardConfig boardCfg;
// Set to true (1) if the ATN flag was set, and we need to // Set to true (1) if the ATN flag was set, and we need to
// enter the MESSAGE_OUT phase. // enter the MESSAGE_OUT phase.

159
software/SCSI2SD/src/sd.c
View File

@ -28,8 +28,23 @@
#include <string.h> #include <string.h>
static void sd_earlyInit(S2S_Device* dev);
static S2S_Target* sd_getTargets(S2S_Device* dev, int* count);
static uint32_t sd_getCapacity(S2S_Device* dev);
static int sd_pollMediaChange(S2S_Device* dev);
static void sd_pollMediaBusy(S2S_Device* dev);
// Global // Global
SdDevice sdDev; SdCard sdCard S2S_DMA_ALIGN = {
{
sd_earlyInit,
sd_getTargets,
sd_getCapacity,
sd_pollMediaChange,
sd_pollMediaBusy
}
};
S2S_Device* sdDevice = &(sdCard.dev);
enum SD_CMD_STATE { CMD_STATE_IDLE, CMD_STATE_READ, CMD_STATE_WRITE }; enum SD_CMD_STATE { CMD_STATE_IDLE, CMD_STATE_READ, CMD_STATE_WRITE };
static int sdCmdState = CMD_STATE_IDLE; static int sdCmdState = CMD_STATE_IDLE;
@ -268,7 +283,7 @@ sdReadMultiSectorPrep(uint32_t sdLBA, uint32_t sdSectors)
{ {
uint32_t tmpNextLBA = sdLBA + sdSectors; uint32_t tmpNextLBA = sdLBA + sdSectors;
if (!sdDev.ccs) if (!sdCard.ccs)
{ {
sdLBA = sdLBA * SD_SECTOR_SIZE; sdLBA = sdLBA * SD_SECTOR_SIZE;
tmpNextLBA = tmpNextLBA * SD_SECTOR_SIZE; tmpNextLBA = tmpNextLBA * SD_SECTOR_SIZE;
@ -291,8 +306,8 @@ sdReadMultiSectorPrep(uint32_t sdLBA, uint32_t sdSectors)
sdClearStatus(); sdClearStatus();
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE; scsiDev.target->state.sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -330,8 +345,8 @@ dmaReadSector(uint8_t* outputBuffer)
if (scsiDev.status != CHECK_CONDITION) if (scsiDev.status != CHECK_CONDITION)
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = UNRECOVERED_READ_ERROR; scsiDev.target->state.sense.asc = UNRECOVERED_READ_ERROR;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
sdClearStatus(); sdClearStatus();
@ -399,7 +414,7 @@ void sdReadSingleSectorDMA(uint32_t lba, uint8_t* outputBuffer)
sdPreCmdState(CMD_STATE_READ); sdPreCmdState(CMD_STATE_READ);
uint8 v; uint8 v;
if (!sdDev.ccs) if (!sdCard.ccs)
{ {
lba = lba * SD_SECTOR_SIZE; lba = lba * SD_SECTOR_SIZE;
} }
@ -410,8 +425,8 @@ void sdReadSingleSectorDMA(uint32_t lba, uint8_t* outputBuffer)
sdClearStatus(); sdClearStatus();
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE; scsiDev.target->state.sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -446,8 +461,8 @@ static void sdCompleteRead()
if (unlikely(r1b) && (scsiDev.phase == DATA_IN)) if (unlikely(r1b) && (scsiDev.phase == DATA_IN))
{ {
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = UNRECOVERED_READ_ERROR; scsiDev.target->state.sense.asc = UNRECOVERED_READ_ERROR;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -544,8 +559,8 @@ sdWriteSectorDMAPoll()
sdClearStatus(); sdClearStatus();
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE; scsiDev.target->state.sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -599,8 +614,8 @@ static void sdCompleteWrite()
{ {
sdClearStatus(); sdClearStatus();
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = WRITE_ERROR_AUTO_REALLOCATION_FAILED; scsiDev.target->state.sense.asc = WRITE_ERROR_AUTO_REALLOCATION_FAILED;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
} }
@ -627,7 +642,7 @@ static int sendIfCond()
if (status == SD_R1_IDLE) if (status == SD_R1_IDLE)
{ {
// Version 2 card. // Version 2 card.
sdDev.version = 2; sdCard.version = 2;
// Read 32bit response. Should contain the same bytes that // Read 32bit response. Should contain the same bytes that
// we sent in the command parameter. // we sent in the command parameter.
sdSpiByte(0xFF); sdSpiByte(0xFF);
@ -639,7 +654,7 @@ static int sendIfCond()
else if (status & SD_R1_ILLEGAL) else if (status & SD_R1_ILLEGAL)
{ {
// Version 1 card. // Version 1 card.
sdDev.version = 1; sdCard.version = 1;
sdClearStatus(); sdClearStatus();
break; break;
} }
@ -688,7 +703,7 @@ static int sdReadOCR()
buf[i] = sdSpiByte(0xFF); buf[i] = sdSpiByte(0xFF);
} }
sdDev.ccs = (buf[0] & 0x40) ? 1 : 0; sdCard.ccs = (buf[0] & 0x40) ? 1 : 0;
complete = (buf[0] & 0x80); complete = (buf[0] & 0x80);
} while (!status && } while (!status &&
@ -715,7 +730,7 @@ static void sdReadCID()
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i)
{ {
sdDev.cid[i] = sdSpiByte(0xFF); sdCard.cid[i] = sdSpiByte(0xFF);
} }
sdSpiByte(0xFF); // CRC sdSpiByte(0xFF); // CRC
sdSpiByte(0xFF); // CRC sdSpiByte(0xFF); // CRC
@ -738,30 +753,30 @@ static int sdReadCSD()
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i)
{ {
sdDev.csd[i] = sdSpiByte(0xFF); sdCard.csd[i] = sdSpiByte(0xFF);
} }
sdSpiByte(0xFF); // CRC sdSpiByte(0xFF); // CRC
sdSpiByte(0xFF); // CRC sdSpiByte(0xFF); // CRC
if ((sdDev.csd[0] >> 6) == 0x00) if ((sdCard.csd[0] >> 6) == 0x00)
{ {
// CSD version 1 // CSD version 1
// C_SIZE in bits [73:62] // C_SIZE in bits [73:62]
uint32 c_size = (((((uint32)sdDev.csd[6]) & 0x3) << 16) | (((uint32)sdDev.csd[7]) << 8) | sdDev.csd[8]) >> 6; uint32 c_size = (((((uint32)sdCard.csd[6]) & 0x3) << 16) | (((uint32)sdCard.csd[7]) << 8) | sdCard.csd[8]) >> 6;
uint32 c_mult = (((((uint32)sdDev.csd[9]) & 0x3) << 8) | ((uint32)sdDev.csd[0xa])) >> 7; uint32 c_mult = (((((uint32)sdCard.csd[9]) & 0x3) << 8) | ((uint32)sdCard.csd[0xa])) >> 7;
uint32 sectorSize = sdDev.csd[5] & 0x0F; uint32 sectorSize = sdCard.csd[5] & 0x0F;
sdDev.capacity = ((c_size+1) * ((uint64)1 << (c_mult+2)) * ((uint64)1 << sectorSize)) / SD_SECTOR_SIZE; sdCard.capacity = ((c_size+1) * ((uint64)1 << (c_mult+2)) * ((uint64)1 << sectorSize)) / SD_SECTOR_SIZE;
} }
else if ((sdDev.csd[0] >> 6) == 0x01) else if ((sdCard.csd[0] >> 6) == 0x01)
{ {
// CSD version 2 // CSD version 2
// C_SIZE in bits [69:48] // C_SIZE in bits [69:48]
uint32 c_size = uint32 c_size =
((((uint32)sdDev.csd[7]) & 0x3F) << 16) | ((((uint32)sdCard.csd[7]) & 0x3F) << 16) |
(((uint32)sdDev.csd[8]) << 8) | (((uint32)sdCard.csd[8]) << 8) |
((uint32)sdDev.csd[7]); ((uint32)sdCard.csd[7]);
sdDev.capacity = (c_size + 1) * 1024; sdCard.capacity = (c_size + 1) * 1024;
} }
else else
{ {
@ -809,11 +824,11 @@ int sdInit()
uint8 v; uint8 v;
sdCmdState = CMD_STATE_IDLE; sdCmdState = CMD_STATE_IDLE;
sdDev.version = 0; sdCard.version = 0;
sdDev.ccs = 0; sdCard.ccs = 0;
sdDev.capacity = 0; sdCard.capacity = 0;
memset(sdDev.csd, 0, sizeof(sdDev.csd)); memset(sdCard.csd, 0, sizeof(sdCard.csd));
memset(sdDev.cid, 0, sizeof(sdDev.cid)); memset(sdCard.cid, 0, sizeof(sdCard.cid));
sdInitDMA(); sdInitDMA();
@ -848,7 +863,7 @@ int sdInit()
if (!sdOpCond()) goto bad; // ACMD41. Wait for init completes. if (!sdOpCond()) goto bad; // ACMD41. Wait for init completes.
if (!sdReadOCR()) goto bad; // CMD58. Get CCS flag. Only valid after init. if (!sdReadOCR()) goto bad; // CMD58. Get CCS flag. Only valid after init.
// This command will be ignored if sdDev.ccs is set. // This command will be ignored if sdCard.ccs is set.
// SDHC and SDXC are always 512bytes. // SDHC and SDXC are always 512bytes.
v = sdCRCCommandAndResponse(SD_SET_BLOCKLEN, SD_SECTOR_SIZE); //Force sector size v = sdCRCCommandAndResponse(SD_SET_BLOCKLEN, SD_SECTOR_SIZE); //Force sector size
if(v){goto bad;} if(v){goto bad;}
@ -882,7 +897,7 @@ int sdInit()
bad: bad:
SD_Data_Clk_SetDivider(clkDiv25MHz); // Restore the clock for our next retry SD_Data_Clk_SetDivider(clkDiv25MHz); // Restore the clock for our next retry
sdDev.capacity = 0; sdCard.capacity = 0;
out: out:
sdClearStatus(); sdClearStatus();
@ -895,7 +910,7 @@ void sdWriteMultiSectorPrep(uint32_t sdLBA, uint32_t sdSectors)
{ {
uint32_t tmpNextLBA = sdLBA + sdSectors; uint32_t tmpNextLBA = sdLBA + sdSectors;
if (!sdDev.ccs) if (!sdCard.ccs)
{ {
sdLBA = sdLBA * SD_SECTOR_SIZE; sdLBA = sdLBA * SD_SECTOR_SIZE;
tmpNextLBA = tmpNextLBA * SD_SECTOR_SIZE; tmpNextLBA = tmpNextLBA * SD_SECTOR_SIZE;
@ -924,8 +939,8 @@ void sdWriteMultiSectorPrep(uint32_t sdLBA, uint32_t sdSectors)
scsiDiskReset(); scsiDiskReset();
sdClearStatus(); sdClearStatus();
scsiDev.status = CHECK_CONDITION; scsiDev.status = CHECK_CONDITION;
scsiDev.target->sense.code = HARDWARE_ERROR; scsiDev.target->state.sense.code = HARDWARE_ERROR;
scsiDev.target->sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE; scsiDev.target->state.sense.asc = LOGICAL_UNIT_COMMUNICATION_FAILURE;
scsiDev.phase = STATUS; scsiDev.phase = STATUS;
} }
else else
@ -968,7 +983,7 @@ void sdCheckPresent()
uint8_t cs = SD_CS_Read(); uint8_t cs = SD_CS_Read();
SD_CS_SetDriveMode(SD_CS_DM_STRONG) ; SD_CS_SetDriveMode(SD_CS_DM_STRONG) ;
if (cs && !(blockDev.state & DISK_PRESENT)) if (cs && !(sdCard.dev.mediaState & MEDIA_PRESENT))
{ {
static int firstInit = 1; static int firstInit = 1;
@ -981,7 +996,7 @@ void sdCheckPresent()
if (sdInit()) if (sdInit())
{ {
blockDev.state |= DISK_PRESENT | DISK_INITIALISED; sdCard.dev.mediaState |= MEDIA_PRESENT | MEDIA_INITIALISED;
// Always "start" the device. Many systems (eg. Apple System 7) // Always "start" the device. Many systems (eg. Apple System 7)
// won't respond properly to // won't respond properly to
@ -1001,18 +1016,68 @@ void sdCheckPresent()
firstInit = 0; firstInit = 0;
} }
} }
else if (!cs && (blockDev.state & DISK_PRESENT)) else if (!cs && (sdCard.dev.mediaState & MEDIA_PRESENT))
{ {
sdDev.capacity = 0; sdCard.capacity = 0;
blockDev.state &= ~DISK_PRESENT; sdCard.dev.mediaState &= ~MEDIA_PRESENT;
blockDev.state &= ~DISK_INITIALISED; sdCard.dev.mediaState &= ~MEDIA_INITIALISED;
int i; int i;
for (i = 0; i < MAX_SCSI_TARGETS; ++i) for (i = 0; i < MAX_SCSI_TARGETS; ++i)
{ {
scsiDev.targets[i].unitAttention = PARAMETERS_CHANGED; sdCard.targets[i].state.unitAttention = PARAMETERS_CHANGED;
} }
} }
} }
firstCheck = 0; firstCheck = 0;
} }
static void sd_earlyInit(S2S_Device* dev)
{
SdCard* sdCardDevice = (SdCard*)dev;
for (int i = 0; i < MAX_TARGETS; ++i)
{
sdCardDevice->targets[i].device = dev;
sdCardDevice->targets[i].cfg = getConfigByIndex(i);
}
sdCardDevice->lastPollMediaTime = s2s_getTime_ms();
// Don't require the host to send us a START STOP UNIT command
sdCardDevice->dev.mediaState = MEDIA_STARTED;
}
static S2S_Target* sd_getTargets(S2S_Device* dev, int* count)
{
SdCard* sdCardDevice = (SdCard*)dev;
*count = MAX_TARGETS;
return sdCardDevice->targets;
}
static uint32_t sd_getCapacity(S2S_Device* dev)
{
SdCard* sdCardDevice = (SdCard*)dev;
return sdCardDevice->capacity;
}
static int sd_pollMediaChange(S2S_Device* dev)
{
SdCard* sdCardDevice = (SdCard*)dev;
if (s2s_elapsedTime_ms(sdCardDevice->lastPollMediaTime) > 200)
{
sdCardDevice->lastPollMediaTime = s2s_getTime_ms();
sdCheckPresent();
return 0;
}
else
{
return 0;
}
}
static void sd_pollMediaBusy(S2S_Device* dev)
{
SdCard* sdCardDevice = (SdCard*)dev;
sdCardDevice->lastPollMediaTime = s2s_getTime_ms();
}

14
software/SCSI2SD/src/sd.h
View File

@ -17,6 +17,8 @@
#ifndef SD_H #ifndef SD_H
#define SD_H #define SD_H
#include "storedevice.h"
#define SD_SECTOR_SIZE 512 #define SD_SECTOR_SIZE 512
typedef enum typedef enum
@ -52,15 +54,23 @@ typedef enum
typedef struct typedef struct
{ {
S2S_Device dev;
S2S_Target targets[MAX_TARGETS];
int version; // SDHC = version 2. int version; // SDHC = version 2.
int ccs; // Card Capacity Status. 1 = SDHC or SDXC int ccs; // Card Capacity Status. 1 = SDHC or SDXC
uint32 capacity; // in 512 byte blocks uint32 capacity; // in 512 byte blocks
uint8_t csd[16]; // Unparsed CSD uint8_t csd[16]; // Unparsed CSD
uint8_t cid[16]; // Unparsed CID uint8_t cid[16]; // Unparsed CID
} SdDevice;
extern SdDevice sdDev; uint32_t lastPollMediaTime;
} SdCard;
extern SdCard sdCard;
extern S2S_Device* sdDevice;
extern volatile uint8_t sdRxDMAComplete; extern volatile uint8_t sdRxDMAComplete;
extern volatile uint8_t sdTxDMAComplete; extern volatile uint8_t sdTxDMAComplete;

74
software/SCSI2SD/src/storedevice.c Normal file
View File

@ -0,0 +1,74 @@
// Copyright (C) 2020 Michael McMaster <michael@codesrc.com>
//
// This file is part of SCSI2SD.
//
// SCSI2SD 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 3 of the License, or
// (at your option) any later version.
//
// SCSI2SD 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 SCSI2SD. If not, see <http://www.gnu.org/licenses/>.
#include "storedevice.h"
#include "sd.h"
#include <stddef.h>
#include <string.h>
S2S_Target* s2s_DeviceFindByScsiId(int scsiId)
{
int deviceCount;
S2S_Device* devices = s2s_GetDevices(&deviceCount);
for (int deviceIdx = 0; deviceIdx < deviceCount; ++deviceIdx)
{
int targetCount;
S2S_Target* targets = devices[deviceIdx].getTargets(devices + deviceIdx, &targetCount);
for (int targetIdx = 0; targetIdx < targetCount; ++targetIdx)
{
S2S_Target* target = targets + targetIdx;
if (target &&
(target->cfg->scsiId & S2S_CFG_TARGET_ENABLED) &&
((target->cfg->scsiId & S2S_CFG_TARGET_ID_BITS) == scsiId))
{
return target;
}
}
}
return NULL;
}
S2S_Device* s2s_GetDevices(int* count)
{
*count = 1;
return sdDevice;
}
void s2s_deviceEarlyInit()
{
int count;
S2S_Device* devices = s2s_GetDevices(&count);
for (int i = 0; i < count; ++i)
{
devices[i].earlyInit(&(devices[i]));
}
}
int s2s_pollMediaChange()
{
int result = 0;
int count;
S2S_Device* devices = s2s_GetDevices(&count);
for (int i = 0; i < count; ++i)
{
int devResult = devices[i].pollMediaChange(&(devices[i]));
result = result || devResult;
}
return result;
}

89
software/SCSI2SD/src/storedevice.h Normal file
View File

@ -0,0 +1,89 @@
// Copyright (C) 2020 Michael McMaster <michael@codesrc.com>
//
// This file is part of SCSI2SD.
//
// SCSI2SD 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 3 of the License, or
// (at your option) any later version.
//
// SCSI2SD 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 SCSI2SD. If not, see <http://www.gnu.org/licenses/>.
#ifndef S2S_DEVICE_H
#define S2S_DEVICE_H
#include "scsi2sd.h"
#include "sense.h"
#include <stdint.h>
struct S2S_DeviceStruct;
typedef struct S2S_DeviceStruct S2S_Device;
struct S2S_TargetStruct;
typedef struct S2S_TargetStruct S2S_Target;
struct S2S_TargetStateStruct;
typedef struct S2S_TargetStateStruct S2S_TargetState;
typedef enum
{
MEDIA_STARTED = 1, // Controlled via START STOP UNIT
MEDIA_PRESENT = 2, // SD card is physically present
MEDIA_INITIALISED = 4, // SD card responded to init sequence
MEDIA_WP = 8 // Write-protect.
} MEDIA_STATE;
struct S2S_TargetStateStruct
{
ScsiSense sense;
uint16_t unitAttention; // Set to the sense qualifier key to be returned.
// Only let the reserved initiator talk to us.
// A 3rd party may be sending the RESERVE/RELEASE commands
int reservedId; // 0 -> 7 if reserved. -1 if not reserved.
int reserverId; // 0 -> 7 if reserved. -1 if not reserved.
// Shadow parameters, possibly not saved to flash yet.
// Set via Mode Select
uint16_t bytesPerSector;
};
struct S2S_TargetStruct
{
S2S_Device* device;
S2S_TargetCfg* cfg;
S2S_TargetState state;
};
struct S2S_DeviceStruct
{
void (*earlyInit)(S2S_Device* dev);
S2S_Target* (*getTargets)(S2S_Device* dev, int* count);
// Get the number of 512 byte blocks
uint32_t (*getCapacity)(S2S_Device* dev);
int (*pollMediaChange)(S2S_Device* dev);
void (*pollMediaBusy)(S2S_Device* dev);
MEDIA_STATE mediaState;
};
S2S_Target* s2s_DeviceFindByScsiId(int scsiId);
S2S_Device* s2s_GetDevices(int* count);
void s2s_deviceEarlyInit();
int s2s_pollMediaChange();
#endif