Macintosh-HW/RASCSI
1
0
Fork 0
mirror of https://github.com/akuker/RASCSI.git synced 2025-03-30 05:30:48 +00:00
Code Issues Projects Releases Wiki Activity

FASTCALL/INLINE removal (#151)

Browse Source 
* Removed FASTCALL and INLINE, added translations, update Disk constructor

* Disk ID cannot be empty, ensured by assertion in constructor

* Disk ID cannot be empty, ensured by assertion in constructor
This commit is contained in:
Uwe Seimet 2021-07-26 20:33:36 +02:00 committed by GitHub
parent b3862c4726
commit e70469d344
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
35 changed files with 764 additions and 799 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/raspberrypi/controllers/sasidev_ctrl.cpp
View File

@ -78,7 +78,7 @@ SASIDEV::~SASIDEV()
// Device reset
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Reset()
void SASIDEV::Reset()
{
// Work initialization
memset(ctrl.cmd, 0x00, sizeof(ctrl.cmd));
@ -105,7 +105,7 @@ void FASTCALL SASIDEV::Reset()
// Connect the controller
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Connect(int id, BUS *bus)
void SASIDEV::Connect(int id, BUS *bus)
{
ctrl.m_scsi_id = id;
ctrl.bus = bus;
@ -116,7 +116,7 @@ void FASTCALL SASIDEV::Connect(int id, BUS *bus)
// Get the logical unit
//
//---------------------------------------------------------------------------
Disk* FASTCALL SASIDEV::GetUnit(int no)
Disk* SASIDEV::GetUnit(int no)
{
ASSERT(no < UnitMax);
@ -128,7 +128,7 @@ Disk* FASTCALL SASIDEV::GetUnit(int no)
// Set the logical unit
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::SetUnit(int no, Disk *dev)
void SASIDEV::SetUnit(int no, Disk *dev)
{
ASSERT(no < UnitMax);
@ -140,7 +140,7 @@ void FASTCALL SASIDEV::SetUnit(int no, Disk *dev)
// Check to see if this has a valid logical unit
//
//---------------------------------------------------------------------------
BOOL FASTCALL SASIDEV::HasUnit()
BOOL SASIDEV::HasUnit()
{
for (int i = 0; i < UnitMax; i++) {
if (ctrl.unit[i]) {
@ -156,7 +156,7 @@ BOOL FASTCALL SASIDEV::HasUnit()
// Get internal data
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::GetCTRL(ctrl_t *buffer)
void SASIDEV::GetCTRL(ctrl_t *buffer)
{
ASSERT(buffer);
@ -169,7 +169,7 @@ void FASTCALL SASIDEV::GetCTRL(ctrl_t *buffer)
// Get a busy unit
//
//---------------------------------------------------------------------------
Disk* FASTCALL SASIDEV::GetBusyUnit()
Disk* SASIDEV::GetBusyUnit()
{
// Logical Unit
DWORD lun = (ctrl.cmd[1] >> 5) & 0x07;
@ -181,7 +181,7 @@ Disk* FASTCALL SASIDEV::GetBusyUnit()
// Run
//
//---------------------------------------------------------------------------
BUS::phase_t FASTCALL SASIDEV::Process()
BUS::phase_t SASIDEV::Process()
{
// Do nothing if not connected
if (ctrl.m_scsi_id < 0 || ctrl.bus == NULL) {
@ -255,7 +255,7 @@ BUS::phase_t FASTCALL SASIDEV::Process()
// Bus free phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::BusFree()
void SASIDEV::BusFree()
{
// Phase change
if (ctrl.phase != BUS::busfree) {
@ -288,7 +288,7 @@ void FASTCALL SASIDEV::BusFree()
// Selection phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Selection()
void SASIDEV::Selection()
{
// Phase change
if (ctrl.phase != BUS::selection) {
@ -324,7 +324,7 @@ void FASTCALL SASIDEV::Selection()
// Command phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Command()
void SASIDEV::Command()
{
int count;
int i;
@ -392,7 +392,7 @@ void FASTCALL SASIDEV::Command()
// Execution Phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Execute()
void SASIDEV::Execute()
{
LOGTRACE("%s Execution Phase Command %02X", __PRETTY_FUNCTION__, (WORD)ctrl.cmd[0]);
@ -491,7 +491,7 @@ void FASTCALL SASIDEV::Execute()
// Status phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Status()
void SASIDEV::Status()
{
DWORD min_exec_time;
DWORD time;
@ -538,7 +538,7 @@ void FASTCALL SASIDEV::Status()
// Message in phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::MsgIn()
void SASIDEV::MsgIn()
{
// Phase change
if (ctrl.phase != BUS::msgin) {
@ -569,7 +569,7 @@ void FASTCALL SASIDEV::MsgIn()
// Data-in Phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::DataIn()
void SASIDEV::DataIn()
{
DWORD min_exec_time;
DWORD time;
@ -620,7 +620,7 @@ void FASTCALL SASIDEV::DataIn()
// Data out phase
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::DataOut()
void SASIDEV::DataOut()
{
DWORD min_exec_time;
DWORD time;
@ -671,7 +671,7 @@ void FASTCALL SASIDEV::DataOut()
// Error
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Error(ERROR_CODES::sense_key sense_key, ERROR_CODES::asc asc)
void SASIDEV::Error(ERROR_CODES::sense_key sense_key, ERROR_CODES::asc asc)
{
// Get bus information
((GPIOBUS*)ctrl.bus)->Aquire();
@ -717,7 +717,7 @@ void FASTCALL SASIDEV::Error(ERROR_CODES::sense_key sense_key, ERROR_CODES::asc
// TEST UNIT READY
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdTestUnitReady()
void SASIDEV::CmdTestUnitReady()
{
LOGTRACE("%s TEST UNIT READY Command ", __PRETTY_FUNCTION__);
@ -740,7 +740,7 @@ void FASTCALL SASIDEV::CmdTestUnitReady()
// REZERO UNIT
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdRezero()
void SASIDEV::CmdRezero()
{
LOGTRACE( "%s REZERO UNIT Command ", __PRETTY_FUNCTION__);
@ -763,7 +763,7 @@ void FASTCALL SASIDEV::CmdRezero()
// REQUEST SENSE
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdRequestSense()
void SASIDEV::CmdRequestSense()
{
LOGTRACE( "%s REQUEST SENSE Command ", __PRETTY_FUNCTION__);
@ -807,7 +807,7 @@ void FASTCALL SASIDEV::CmdRequestSense()
// FORMAT UNIT
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdFormat()
void SASIDEV::CmdFormat()
{
LOGTRACE( "%s FORMAT UNIT Command ", __PRETTY_FUNCTION__);
@ -830,7 +830,7 @@ void FASTCALL SASIDEV::CmdFormat()
// REASSIGN BLOCKS
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdReassign()
void SASIDEV::CmdReassign()
{
LOGTRACE("%s REASSIGN BLOCKS Command ", __PRETTY_FUNCTION__);
@ -858,7 +858,7 @@ void FASTCALL SASIDEV::CmdReassign()
// just respond with an OK status.
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdReserveUnit()
void SASIDEV::CmdReserveUnit()
{
LOGTRACE( "%s Reserve(6) Command", __PRETTY_FUNCTION__);
@ -876,7 +876,7 @@ void FASTCALL SASIDEV::CmdReserveUnit()
// just respond with an OK status.
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdReleaseUnit()
void SASIDEV::CmdReleaseUnit()
{
LOGTRACE( "%s Release(6) Command", __PRETTY_FUNCTION__);
@ -889,7 +889,7 @@ void FASTCALL SASIDEV::CmdReleaseUnit()
// READ(6)
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdRead6()
void SASIDEV::CmdRead6()
{
DWORD lun = GetLun();
@ -935,7 +935,7 @@ void FASTCALL SASIDEV::CmdRead6()
// This Send Message command is used by the DaynaPort SCSI/Link
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::DaynaPortWrite()
void SASIDEV::DaynaPortWrite()
{
DWORD lun = GetLun();
@ -987,7 +987,7 @@ void FASTCALL SASIDEV::DaynaPortWrite()
// WRITE(6)
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdWrite6()
void SASIDEV::CmdWrite6()
{
DWORD lun = GetLun();
@ -1031,7 +1031,7 @@ void FASTCALL SASIDEV::CmdWrite6()
// SEEK(6)
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdSeek6()
void SASIDEV::CmdSeek6()
{
LOGTRACE("%s SEEK(6) Command ", __PRETTY_FUNCTION__);
@ -1054,7 +1054,7 @@ void FASTCALL SASIDEV::CmdSeek6()
// ASSIGN
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdAssign()
void SASIDEV::CmdAssign()
{
LOGTRACE("%s ASSIGN Command ", __PRETTY_FUNCTION__);
@ -1080,7 +1080,7 @@ void FASTCALL SASIDEV::CmdAssign()
// SPECIFY
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdSpecify()
void SASIDEV::CmdSpecify()
{
LOGTRACE("%s SPECIFY Command ", __PRETTY_FUNCTION__);
@ -1106,7 +1106,7 @@ void FASTCALL SASIDEV::CmdSpecify()
// Unsupported command
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::CmdInvalid()
void SASIDEV::CmdInvalid()
{
LOGWARN("%s Command not supported", __PRETTY_FUNCTION__);
@ -1124,7 +1124,7 @@ void FASTCALL SASIDEV::CmdInvalid()
// Data transmission
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Send()
void SASIDEV::Send()
{
int len;
BOOL result;
@ -1216,7 +1216,7 @@ void FASTCALL SASIDEV::Send()
// Receive data
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::Receive()
void SASIDEV::Receive()
{
int len;
BOOL result;
@ -1301,7 +1301,7 @@ void FASTCALL SASIDEV::Receive()
// *Reset offset and length
//
//---------------------------------------------------------------------------
BOOL FASTCALL SASIDEV::XferIn(BYTE *buf)
BOOL SASIDEV::XferIn(BYTE *buf)
{
ASSERT(ctrl.phase == BUS::datain);
LOGTRACE("%s ctrl.cmd[0]=%02X", __PRETTY_FUNCTION__, (unsigned int)ctrl.cmd[0]);
@ -1348,7 +1348,7 @@ BOOL FASTCALL SASIDEV::XferIn(BYTE *buf)
// *If cont=true, reset the offset and length
//
//---------------------------------------------------------------------------
BOOL FASTCALL SASIDEV::XferOut(BOOL cont)
BOOL SASIDEV::XferOut(BOOL cont)
{
SCSIBR *bridge;
@ -1447,7 +1447,7 @@ BOOL FASTCALL SASIDEV::XferOut(BOOL cont)
// Logical unit flush
//
//---------------------------------------------------------------------------
void FASTCALL SASIDEV::FlushUnit()
void SASIDEV::FlushUnit()
{
ASSERT(ctrl.phase == BUS::dataout);
@ -1560,7 +1560,7 @@ void SASIDEV::GetPhaseStr(char *str)
// Validate LUN
//
//---------------------------------------------------------------------------
DWORD FASTCALL SASIDEV::GetLun()
DWORD SASIDEV::GetLun()
{
DWORD lun = (ctrl.cmd[1] >> 5) & 0x07;
if (!ctrl.unit[lun]) {

86
src/raspberrypi/controllers/sasidev_ctrl.h
View File

@ -147,72 +147,72 @@ public:
// Basic Functions
SASIDEV();
virtual ~SASIDEV(); // Destructor
virtual void FASTCALL Reset(); // Device Reset
virtual void Reset(); // Device Reset
// External API
virtual BUS::phase_t FASTCALL Process(); // Run
virtual BUS::phase_t Process(); // Run
// Connect
void FASTCALL Connect(int id, BUS *sbus); // Controller connection
Disk* FASTCALL GetUnit(int no); // Get logical unit
void FASTCALL SetUnit(int no, Disk *dev); // Logical unit setting
BOOL FASTCALL HasUnit(); // Has a valid logical unit
void Connect(int id, BUS *sbus); // Controller connection
Disk* GetUnit(int no); // Get logical unit
void SetUnit(int no, Disk *dev); // Logical unit setting
BOOL HasUnit(); // Has a valid logical unit
// Other
BUS::phase_t FASTCALL GetPhase() {return ctrl.phase;} // Get the phase
BUS::phase_t GetPhase() {return ctrl.phase;} // Get the phase
#ifdef DISK_LOG
// Function to get the current phase as a String.
void FASTCALL GetPhaseStr(char *str);
void GetPhaseStr(char *str);
#endif
int FASTCALL GetSCSIID() {return ctrl.m_scsi_id;} // Get the ID
void FASTCALL GetCTRL(ctrl_t *buffer); // Get the internal information
ctrl_t* FASTCALL GetWorkAddr() { return &ctrl; } // Get the internal information address
virtual BOOL FASTCALL IsSASI() const {return TRUE;} // SASI Check
virtual BOOL FASTCALL IsSCSI() const {return FALSE;} // SCSI check
Disk* FASTCALL GetBusyUnit(); // Get the busy unit
int GetSCSIID() {return ctrl.m_scsi_id;} // Get the ID
void GetCTRL(ctrl_t *buffer); // Get the internal information
ctrl_t* GetWorkAddr() { return &ctrl; } // Get the internal information address
virtual BOOL IsSASI() const {return TRUE;} // SASI Check
virtual BOOL IsSCSI() const {return FALSE;} // SCSI check
Disk* GetBusyUnit(); // Get the busy unit
protected:
// Phase processing
virtual void FASTCALL BusFree(); // Bus free phase
virtual void FASTCALL Selection(); // Selection phase
virtual void FASTCALL Command(); // Command phase
virtual void FASTCALL Execute(); // Execution phase
void FASTCALL Status(); // Status phase
void FASTCALL MsgIn(); // Message in phase
void FASTCALL DataIn(); // Data in phase
void FASTCALL DataOut(); // Data out phase
virtual void FASTCALL Error(ERROR_CODES::sense_key sense_key = ERROR_CODES::sense_key::NO_SENSE,
virtual void BusFree(); // Bus free phase
virtual void Selection(); // Selection phase
virtual void Command(); // Command phase
virtual void Execute(); // Execution phase
void Status(); // Status phase
void MsgIn(); // Message in phase
void DataIn(); // Data in phase
void DataOut(); // Data out phase
virtual void Error(ERROR_CODES::sense_key sense_key = ERROR_CODES::sense_key::NO_SENSE,
ERROR_CODES::asc = ERROR_CODES::asc::NO_ADDITIONAL_SENSE_INFORMATION); // Common error handling
// commands
void FASTCALL CmdTestUnitReady(); // TEST UNIT READY command
void FASTCALL CmdRezero(); // REZERO UNIT command
void FASTCALL CmdRequestSense(); // REQUEST SENSE command
void FASTCALL CmdFormat(); // FORMAT command
void FASTCALL CmdReassign(); // REASSIGN BLOCKS command
void FASTCALL CmdReserveUnit(); // RESERVE UNIT command
void FASTCALL CmdReleaseUnit(); // RELEASE UNIT command
void FASTCALL CmdRead6(); // READ(6) command
void FASTCALL CmdWrite6(); // WRITE(6) command
void FASTCALL CmdSeek6(); // SEEK(6) command
void FASTCALL CmdAssign(); // ASSIGN command
void FASTCALL CmdSpecify(); // SPECIFY command
void FASTCALL CmdInvalid(); // Unsupported command
void FASTCALL DaynaPortWrite(); // DaynaPort specific 'write' operation
void CmdTestUnitReady(); // TEST UNIT READY command
void CmdRezero(); // REZERO UNIT command
void CmdRequestSense(); // REQUEST SENSE command
void CmdFormat(); // FORMAT command
void CmdReassign(); // REASSIGN BLOCKS command
void CmdReserveUnit(); // RESERVE UNIT command
void CmdReleaseUnit(); // RELEASE UNIT command
void CmdRead6(); // READ(6) command
void CmdWrite6(); // WRITE(6) command
void CmdSeek6(); // SEEK(6) command
void CmdAssign(); // ASSIGN command
void CmdSpecify(); // SPECIFY command
void CmdInvalid(); // Unsupported command
void DaynaPortWrite(); // DaynaPort specific 'write' operation
// データ転送
virtual void FASTCALL Send(); // Send data
virtual void Send(); // Send data
virtual void FASTCALL Receive(); // Receive data
virtual void Receive(); // Receive data
BOOL FASTCALL XferIn(BYTE* buf); // Data transfer IN
BOOL FASTCALL XferOut(BOOL cont); // Data transfer OUT
BOOL XferIn(BYTE* buf); // Data transfer IN
BOOL XferOut(BOOL cont); // Data transfer OUT
// Special operations
void FASTCALL FlushUnit(); // Flush the logical unit
void FlushUnit(); // Flush the logical unit
DWORD FASTCALL GetLun(); // Get the validated LUN
DWORD GetLun(); // Get the validated LUN
protected:
ctrl_t ctrl; // Internal data

80
src/raspberrypi/controllers/scsidev_ctrl.cpp
View File

@ -90,7 +90,7 @@ SCSIDEV::~SCSIDEV()
}
}
void FASTCALL SCSIDEV::SetupCommand(scsi_command opcode, const char* name, void FASTCALL (SCSIDEV::*execute)(void))
void SCSIDEV::SetupCommand(scsi_command opcode, const char* name, void (SCSIDEV::*execute)(void))
{
scsi_commands[opcode] = new command_t(name, execute);
}
@ -100,7 +100,7 @@ void FASTCALL SCSIDEV::SetupCommand(scsi_command opcode, const char* name, void
// Device reset
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::Reset()
void SCSIDEV::Reset()
{
// Work initialization
scsi.atnmsg = FALSE;
@ -116,7 +116,7 @@ void FASTCALL SCSIDEV::Reset()
// Process
//
//---------------------------------------------------------------------------
BUS::phase_t FASTCALL SCSIDEV::Process()
BUS::phase_t SCSIDEV::Process()
{
// Do nothing if not connected
if (ctrl.m_scsi_id < 0 || ctrl.bus == NULL) {
@ -200,7 +200,7 @@ BUS::phase_t FASTCALL SCSIDEV::Process()
// Bus free phase
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::BusFree()
void SCSIDEV::BusFree()
{
// Phase change
if (ctrl.phase != BUS::busfree) {
@ -237,7 +237,7 @@ void FASTCALL SCSIDEV::BusFree()
// Selection Phase
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::Selection()
void SCSIDEV::Selection()
{
// Phase change
if (ctrl.phase != BUS::selection) {
@ -278,7 +278,7 @@ void FASTCALL SCSIDEV::Selection()
// Execution Phase
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::Execute()
void SCSIDEV::Execute()
{
LOGTRACE( "%s Execution phase command $%02X", __PRETTY_FUNCTION__, (unsigned int)ctrl.cmd[0]);
@ -316,7 +316,7 @@ void FASTCALL SCSIDEV::Execute()
// Message out phase
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::MsgOut()
void SCSIDEV::MsgOut()
{
LOGTRACE("%s ID: %d",__PRETTY_FUNCTION__, this->GetSCSIID());
@ -357,7 +357,7 @@ void FASTCALL SCSIDEV::MsgOut()
// Common Error Handling
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::Error(ERROR_CODES::sense_key sense_key, ERROR_CODES::asc asc)
void SCSIDEV::Error(ERROR_CODES::sense_key sense_key, ERROR_CODES::asc asc)
{
// Get bus information
((GPIOBUS*)ctrl.bus)->Aquire();
@ -405,7 +405,7 @@ void FASTCALL SCSIDEV::Error(ERROR_CODES::sense_key sense_key, ERROR_CODES::asc
// INQUIRY
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdInquiry()
void SCSIDEV::CmdInquiry()
{
LOGTRACE("%s INQUIRY Command", __PRETTY_FUNCTION__);
@ -458,7 +458,7 @@ void FASTCALL SCSIDEV::CmdInquiry()
// MODE SELECT
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdModeSelect()
void SCSIDEV::CmdModeSelect()
{
LOGTRACE( "%s MODE SELECT Command", __PRETTY_FUNCTION__);
@ -486,7 +486,7 @@ void FASTCALL SCSIDEV::CmdModeSelect()
// just respond with an OK status.
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdReserve6()
void SCSIDEV::CmdReserve6()
{
LOGTRACE( "%s Reserve(6) Command", __PRETTY_FUNCTION__);
@ -504,7 +504,7 @@ void FASTCALL SCSIDEV::CmdReserve6()
// just respond with an OK status.
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdReserve10()
void SCSIDEV::CmdReserve10()
{
LOGTRACE( "%s Reserve(10) Command", __PRETTY_FUNCTION__);
@ -522,7 +522,7 @@ void FASTCALL SCSIDEV::CmdReserve10()
// just respond with an OK status.
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdRelease6()
void SCSIDEV::CmdRelease6()
{
LOGTRACE( "%s Release(6) Command", __PRETTY_FUNCTION__);
@ -540,7 +540,7 @@ void FASTCALL SCSIDEV::CmdRelease6()
// just respond with an OK status.
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdRelease10()
void SCSIDEV::CmdRelease10()
{
LOGTRACE( "%s Release(10) Command", __PRETTY_FUNCTION__);
@ -553,7 +553,7 @@ void FASTCALL SCSIDEV::CmdRelease10()
// MODE SENSE
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdModeSense()
void SCSIDEV::CmdModeSense()
{
LOGTRACE( "%s MODE SENSE Command ", __PRETTY_FUNCTION__);
@ -579,7 +579,7 @@ void FASTCALL SCSIDEV::CmdModeSense()
// START STOP UNIT
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdStartStop()
void SCSIDEV::CmdStartStop()
{
LOGTRACE( "%s START STOP UNIT Command ", __PRETTY_FUNCTION__);
@ -602,7 +602,7 @@ void FASTCALL SCSIDEV::CmdStartStop()
// SEND DIAGNOSTIC
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdSendDiag()
void SCSIDEV::CmdSendDiag()
{
LOGTRACE( "%s SEND DIAGNOSTIC Command ", __PRETTY_FUNCTION__);
@ -625,7 +625,7 @@ void FASTCALL SCSIDEV::CmdSendDiag()
// PREVENT/ALLOW MEDIUM REMOVAL
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdRemoval()
void SCSIDEV::CmdRemoval()
{
LOGTRACE( "%s PREVENT/ALLOW MEDIUM REMOVAL Command ", __PRETTY_FUNCTION__);
@ -648,7 +648,7 @@ void FASTCALL SCSIDEV::CmdRemoval()
// READ CAPACITY
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdReadCapacity()
void SCSIDEV::CmdReadCapacity()
{
LOGTRACE( "%s READ CAPACITY Command ", __PRETTY_FUNCTION__);
@ -674,7 +674,7 @@ void FASTCALL SCSIDEV::CmdReadCapacity()
// READ(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdRead10()
void SCSIDEV::CmdRead10()
{
DWORD lun = GetLun();
@ -724,7 +724,7 @@ void FASTCALL SCSIDEV::CmdRead10()
// WRITE(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdWrite10()
void SCSIDEV::CmdWrite10()
{
DWORD lun = GetLun();
@ -774,7 +774,7 @@ void FASTCALL SCSIDEV::CmdWrite10()
// SEEK(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdSeek10()
void SCSIDEV::CmdSeek10()
{
LOGTRACE( "%s SEEK(10) Command ", __PRETTY_FUNCTION__);
@ -797,7 +797,7 @@ void FASTCALL SCSIDEV::CmdSeek10()
// VERIFY
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdVerify()
void SCSIDEV::CmdVerify()
{
BOOL status;
@ -858,7 +858,7 @@ void FASTCALL SCSIDEV::CmdVerify()
// SYNCHRONIZE CACHE
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdSynchronizeCache()
void SCSIDEV::CmdSynchronizeCache()
{
GetLun();
@ -873,7 +873,7 @@ void FASTCALL SCSIDEV::CmdSynchronizeCache()
// READ DEFECT DATA(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdReadDefectData10()
void SCSIDEV::CmdReadDefectData10()
{
LOGTRACE( "%s READ DEFECT DATA(10) Command ", __PRETTY_FUNCTION__);
@ -897,7 +897,7 @@ void FASTCALL SCSIDEV::CmdReadDefectData10()
// READ TOC
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdReadToc()
void SCSIDEV::CmdReadToc()
{
DWORD lun = GetLun();
@ -918,7 +918,7 @@ void FASTCALL SCSIDEV::CmdReadToc()
// PLAY AUDIO(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdPlayAudio10()
void SCSIDEV::CmdPlayAudio10()
{
DWORD lun = GetLun();
@ -939,7 +939,7 @@ void FASTCALL SCSIDEV::CmdPlayAudio10()
// PLAY AUDIO MSF
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdPlayAudioMSF()
void SCSIDEV::CmdPlayAudioMSF()
{
DWORD lun = GetLun();
@ -960,7 +960,7 @@ void FASTCALL SCSIDEV::CmdPlayAudioMSF()
// PLAY AUDIO TRACK
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdPlayAudioTrack()
void SCSIDEV::CmdPlayAudioTrack()
{
DWORD lun = GetLun();
@ -981,7 +981,7 @@ void FASTCALL SCSIDEV::CmdPlayAudioTrack()
// MODE SELECT10
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdModeSelect10()
void SCSIDEV::CmdModeSelect10()
{
LOGTRACE( "%s MODE SELECT10 Command ", __PRETTY_FUNCTION__);
@ -1004,7 +1004,7 @@ void FASTCALL SCSIDEV::CmdModeSelect10()
// MODE SENSE(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdModeSense10()
void SCSIDEV::CmdModeSense10()
{
LOGTRACE( "%s MODE SENSE(10) Command ", __PRETTY_FUNCTION__);
@ -1030,7 +1030,7 @@ void FASTCALL SCSIDEV::CmdModeSense10()
// GET MESSAGE(10)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdGetMessage10()
void SCSIDEV::CmdGetMessage10()
{
SCSIBR *bridge;
@ -1075,7 +1075,7 @@ void FASTCALL SCSIDEV::CmdGetMessage10()
// This Send Message command is used by the X68000 host driver
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdSendMessage10()
void SCSIDEV::CmdSendMessage10()
{
DWORD lun = GetLun();
@ -1119,7 +1119,7 @@ void FASTCALL SCSIDEV::CmdSendMessage10()
// Retrieve Statistics (09)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdRetrieveStats()
void SCSIDEV::CmdRetrieveStats()
{
DWORD lun = GetLun();
@ -1153,7 +1153,7 @@ void FASTCALL SCSIDEV::CmdRetrieveStats()
// Set Interface Mode (0c)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdSetIfaceMode()
void SCSIDEV::CmdSetIfaceMode()
{
LOGTRACE("%s",__PRETTY_FUNCTION__);
@ -1193,7 +1193,7 @@ void FASTCALL SCSIDEV::CmdSetIfaceMode()
// Set the multicast address
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdSetMcastAddr()
void SCSIDEV::CmdSetMcastAddr()
{
LOGTRACE("%s Set Multicast Address Command ", __PRETTY_FUNCTION__);
@ -1225,7 +1225,7 @@ void FASTCALL SCSIDEV::CmdSetMcastAddr()
// Enable/disable Interface (0e)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::CmdEnableInterface()
void SCSIDEV::CmdEnableInterface()
{
LOGTRACE("%s",__PRETTY_FUNCTION__);
@ -1264,7 +1264,7 @@ void FASTCALL SCSIDEV::CmdEnableInterface()
// Send data
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::Send()
void SCSIDEV::Send()
{
int len;
BOOL result;
@ -1373,7 +1373,7 @@ void FASTCALL SCSIDEV::Send()
// Receive Data
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDEV::Receive()
void SCSIDEV::Receive()
{
int len;
int i;
@ -1588,7 +1588,7 @@ void FASTCALL SCSIDEV::Receive()
// Transfer MSG
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIDEV::XferMsg(DWORD msg)
BOOL SCSIDEV::XferMsg(DWORD msg)
{
ASSERT(ctrl.phase == BUS::msgout);

90
src/raspberrypi/controllers/scsidev_ctrl.h
View File

@ -42,9 +42,9 @@ public:
// SCSI command name and pointer to implementation
typedef struct _command_t {
const char* name;
void FASTCALL (SCSIDEV::*execute)(void);
void (SCSIDEV::*execute)(void);
_command_t(const char* _name, void FASTCALL (SCSIDEV::*_execute)(void)) : name(_name), execute(_execute) { };
_command_t(const char* _name, void (SCSIDEV::*_execute)(void)) : name(_name), execute(_execute) { };
} command_t;
// Mapping of SCSI opcodes to command implementations
@ -55,62 +55,62 @@ public:
SCSIDEV();
~SCSIDEV();
void FASTCALL Reset(); // Device Reset
void Reset(); // Device Reset
// 外部API
BUS::phase_t FASTCALL Process(); // Run
BUS::phase_t Process(); // Run
void FASTCALL SyncTransfer(BOOL enable) { scsi.syncenable = enable; } // Synchronouse transfer enable setting
void SyncTransfer(BOOL enable) { scsi.syncenable = enable; } // Synchronouse transfer enable setting
// Other
BOOL FASTCALL IsSASI() const {return FALSE;} // SASI Check
BOOL FASTCALL IsSCSI() const {return TRUE;} // SCSI check
BOOL IsSASI() const {return FALSE;} // SASI Check
BOOL IsSCSI() const {return TRUE;} // SCSI check
private:
void FASTCALL SetupCommand(scsi_command, const char*, void FASTCALL (SCSIDEV::*)(void));
void SetupCommand(scsi_command, const char*, void (SCSIDEV::*)(void));
// Phase
void FASTCALL BusFree(); // Bus free phase
void FASTCALL Selection(); // Selection phase
void FASTCALL Execute(); // Execution phase
void FASTCALL MsgOut(); // Message out phase
void FASTCALL Error(ERROR_CODES::sense_key sense_key = ERROR_CODES::sense_key::NO_SENSE,
void BusFree(); // Bus free phase
void Selection(); // Selection phase
void Execute(); // Execution phase
void MsgOut(); // Message out phase
void Error(ERROR_CODES::sense_key sense_key = ERROR_CODES::sense_key::NO_SENSE,
ERROR_CODES::asc asc = ERROR_CODES::asc::NO_ADDITIONAL_SENSE_INFORMATION); // Common erorr handling
// commands
void FASTCALL CmdInquiry(); // INQUIRY command
void FASTCALL CmdModeSelect(); // MODE SELECT command
void FASTCALL CmdReserve6(); // RESERVE(6) command
void FASTCALL CmdReserve10(); // RESERVE(10) command
void FASTCALL CmdRelease6(); // RELEASE(6) command
void FASTCALL CmdRelease10(); // RELEASE(10) command
void FASTCALL CmdModeSense(); // MODE SENSE command
void FASTCALL CmdStartStop(); // START STOP UNIT command
void FASTCALL CmdSendDiag(); // SEND DIAGNOSTIC command
void FASTCALL CmdRemoval(); // PREVENT/ALLOW MEDIUM REMOVAL command
void FASTCALL CmdReadCapacity(); // READ CAPACITY command
void FASTCALL CmdRead10(); // READ(10) command
void FASTCALL CmdWrite10(); // WRITE(10) command
void FASTCALL CmdSeek10(); // SEEK(10) command
void FASTCALL CmdVerify(); // VERIFY command
void FASTCALL CmdSynchronizeCache(); // SYNCHRONIZE CACHE command
void FASTCALL CmdReadDefectData10(); // READ DEFECT DATA(10) command
void FASTCALL CmdReadToc(); // READ TOC command
void FASTCALL CmdPlayAudio10(); // PLAY AUDIO(10) command
void FASTCALL CmdPlayAudioMSF(); // PLAY AUDIO MSF command
void FASTCALL CmdPlayAudioTrack(); // PLAY AUDIO TRACK INDEX command
void FASTCALL CmdModeSelect10(); // MODE SELECT(10) command
void FASTCALL CmdModeSense10(); // MODE SENSE(10) command
void FASTCALL CmdGetMessage10(); // GET MESSAGE(10) command
void FASTCALL CmdSendMessage10(); // SEND MESSAGE(10) command
void FASTCALL CmdRetrieveStats(); // DaynaPort specific command
void FASTCALL CmdSetIfaceMode(); // DaynaPort specific command
void FASTCALL CmdSetMcastAddr(); // DaynaPort specific command
void FASTCALL CmdEnableInterface(); // DaynaPort specific command
void CmdInquiry(); // INQUIRY command
void CmdModeSelect(); // MODE SELECT command
void CmdReserve6(); // RESERVE(6) command
void CmdReserve10(); // RESERVE(10) command
void CmdRelease6(); // RELEASE(6) command
void CmdRelease10(); // RELEASE(10) command
void CmdModeSense(); // MODE SENSE command
void CmdStartStop(); // START STOP UNIT command
void CmdSendDiag(); // SEND DIAGNOSTIC command
void CmdRemoval(); // PREVENT/ALLOW MEDIUM REMOVAL command
void CmdReadCapacity(); // READ CAPACITY command
void CmdRead10(); // READ(10) command
void CmdWrite10(); // WRITE(10) command
void CmdSeek10(); // SEEK(10) command
void CmdVerify(); // VERIFY command
void CmdSynchronizeCache(); // SYNCHRONIZE CACHE command
void CmdReadDefectData10(); // READ DEFECT DATA(10) command
void CmdReadToc(); // READ TOC command
void CmdPlayAudio10(); // PLAY AUDIO(10) command
void CmdPlayAudioMSF(); // PLAY AUDIO MSF command
void CmdPlayAudioTrack(); // PLAY AUDIO TRACK INDEX command
void CmdModeSelect10(); // MODE SELECT(10) command
void CmdModeSense10(); // MODE SENSE(10) command
void CmdGetMessage10(); // GET MESSAGE(10) command
void CmdSendMessage10(); // SEND MESSAGE(10) command
void CmdRetrieveStats(); // DaynaPort specific command
void CmdSetIfaceMode(); // DaynaPort specific command
void CmdSetMcastAddr(); // DaynaPort specific command
void CmdEnableInterface(); // DaynaPort specific command
// データ転送
void FASTCALL Send(); // Send data
void FASTCALL Receive(); // Receive data
BOOL FASTCALL XferMsg(DWORD msg); // Data transfer message
void Send(); // Send data
void Receive(); // Receive data
BOOL XferMsg(DWORD msg); // Data transfer message
scsi_t scsi; // Internal data
};

4
src/raspberrypi/devices/cfilesystem.h
View File

@ -137,9 +137,9 @@ namespace Human68k {
BYTE add[10]; ///< ファイル名追加 (PADDING 0x00)
// 文字列取得
void FASTCALL GetCopyPath(BYTE* szPath) const;
void GetCopyPath(BYTE* szPath) const;
///< パス名取得
void FASTCALL GetCopyFilename(BYTE* szFilename) const;
void GetCopyFilename(BYTE* szFilename) const;
///< ファイル名取得
};

22
src/raspberrypi/devices/ctapdriver.cpp
View File

@ -85,7 +85,7 @@ static BOOL ip_link(int fd, const char* ifname, BOOL up) {
return TRUE;
}
BOOL FASTCALL CTapDriver::Init()
BOOL CTapDriver::Init()
{
LOGTRACE("%s",__PRETTY_FUNCTION__);
@ -202,7 +202,7 @@ BOOL FASTCALL CTapDriver::Init()
#endif // __linux__
#ifdef __NetBSD__
BOOL FASTCALL CTapDriver::Init()
BOOL CTapDriver::Init()
{
struct ifreq ifr;
struct ifaddrs *ifa, *a;
@ -247,7 +247,7 @@ BOOL FASTCALL CTapDriver::Init()
}
#endif // __NetBSD__
BOOL FASTCALL CTapDriver::OpenDump(const Filepath& path) {
BOOL CTapDriver::OpenDump(const Filepath& path) {
if (m_pcap == NULL) {
m_pcap = pcap_open_dead(DLT_EN10MB, 65535);
}
@ -268,7 +268,7 @@ BOOL FASTCALL CTapDriver::OpenDump(const Filepath& path) {
// Cleanup
//
//---------------------------------------------------------------------------
void FASTCALL CTapDriver::Cleanup()
void CTapDriver::Cleanup()
{
int br_socket_fd = -1;
if ((br_socket_fd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0) {
@ -302,7 +302,7 @@ void FASTCALL CTapDriver::Cleanup()
// Enable
//
//---------------------------------------------------------------------------
BOOL FASTCALL CTapDriver::Enable(){
BOOL CTapDriver::Enable(){
int fd = socket(PF_INET, SOCK_DGRAM, 0);
LOGDEBUG("%s: ip link set ras0 up", __PRETTY_FUNCTION__);
BOOL result = ip_link(fd, "ras0", TRUE);
@ -315,7 +315,7 @@ BOOL FASTCALL CTapDriver::Enable(){
// Disable
//
//---------------------------------------------------------------------------
BOOL FASTCALL CTapDriver::Disable(){
BOOL CTapDriver::Disable(){
int fd = socket(PF_INET, SOCK_DGRAM, 0);
LOGDEBUG("%s: ip link set ras0 down", __PRETTY_FUNCTION__);
BOOL result = ip_link(fd, "ras0", FALSE);
@ -328,7 +328,7 @@ BOOL FASTCALL CTapDriver::Disable(){
// Flush
//
//---------------------------------------------------------------------------
BOOL FASTCALL CTapDriver::Flush(){
BOOL CTapDriver::Flush(){
LOGTRACE("%s", __PRETTY_FUNCTION__);
while(PendingPackets()){
(void)Rx(m_garbage_buffer);
@ -341,7 +341,7 @@ BOOL FASTCALL CTapDriver::Flush(){
// MGet MAC Address
//
//---------------------------------------------------------------------------
void FASTCALL CTapDriver::GetMacAddr(BYTE *mac)
void CTapDriver::GetMacAddr(BYTE *mac)
{
ASSERT(mac);
@ -353,7 +353,7 @@ void FASTCALL CTapDriver::GetMacAddr(BYTE *mac)
// Receive
//
//---------------------------------------------------------------------------
BOOL FASTCALL CTapDriver::PendingPackets()
BOOL CTapDriver::PendingPackets()
{
struct pollfd fds;
@ -377,7 +377,7 @@ BOOL FASTCALL CTapDriver::PendingPackets()
// Receive
//
//---------------------------------------------------------------------------
int FASTCALL CTapDriver::Rx(BYTE *buf)
int CTapDriver::Rx(BYTE *buf)
{
ASSERT(m_hTAP != -1);
@ -434,7 +434,7 @@ int FASTCALL CTapDriver::Rx(BYTE *buf)
// Send
//
//---------------------------------------------------------------------------
int FASTCALL CTapDriver::Tx(const BYTE *buf, int len)
int CTapDriver::Tx(const BYTE *buf, int len)
{
ASSERT(m_hTAP != -1);

20
src/raspberrypi/devices/ctapdriver.h
View File

@ -33,17 +33,17 @@ class CTapDriver
public:
// Basic Functionality
CTapDriver(); // Constructor
BOOL FASTCALL Init(); // Initilization
BOOL FASTCALL OpenDump(const Filepath& path);
BOOL Init(); // Initilization
BOOL OpenDump(const Filepath& path);
// Capture packets
void FASTCALL Cleanup(); // Cleanup
void FASTCALL GetMacAddr(BYTE *mac); // Get Mac Address
int FASTCALL Rx(BYTE *buf); // Receive
int FASTCALL Tx(const BYTE *buf, int len); // Send
BOOL FASTCALL PendingPackets(); // Check if there are IP packets available
BOOL FASTCALL Enable(); // Enable the ras0 interface
BOOL FASTCALL Disable(); // Disable the ras0 interface
BOOL FASTCALL Flush(); // Purge all of the packets that are waiting to be processed
void Cleanup(); // Cleanup
void GetMacAddr(BYTE *mac); // Get Mac Address
int Rx(BYTE *buf); // Receive
int Tx(const BYTE *buf, int len); // Send
BOOL PendingPackets(); // Check if there are IP packets available
BOOL Enable(); // Enable the ras0 interface
BOOL Disable(); // Disable the ras0 interface
BOOL Flush(); // Purge all of the packets that are waiting to be processed
private:
BYTE m_MacAddr[6]; // MAC Address

148
src/raspberrypi/devices/disk.cpp
View File

@ -83,7 +83,7 @@ DiskTrack::~DiskTrack()
// Initialization
//
//---------------------------------------------------------------------------
void FASTCALL DiskTrack::Init(
void DiskTrack::Init(
int track, int size, int sectors, BOOL raw, off64_t imgoff)
{
ASSERT(track >= 0);
@ -112,7 +112,7 @@ void FASTCALL DiskTrack::Init(
// Load
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskTrack::Load(const Filepath& path)
BOOL DiskTrack::Load(const Filepath& path)
{
Fileio fio;
int i;
@ -231,7 +231,7 @@ BOOL FASTCALL DiskTrack::Load(const Filepath& path)
// Save
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskTrack::Save(const Filepath& path)
BOOL DiskTrack::Save(const Filepath& path)
{
int i;
int j;
@ -324,7 +324,7 @@ BOOL FASTCALL DiskTrack::Save(const Filepath& path)
// Read Sector
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskTrack::Read(BYTE *buf, int sec) const
BOOL DiskTrack::Read(BYTE *buf, int sec) const
{
ASSERT(buf);
ASSERT((sec >= 0) & (sec < 0x100));
@ -355,7 +355,7 @@ BOOL FASTCALL DiskTrack::Read(BYTE *buf, int sec) const
// Write Sector
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskTrack::Write(const BYTE *buf, int sec)
BOOL DiskTrack::Write(const BYTE *buf, int sec)
{
ASSERT(buf);
ASSERT((sec >= 0) & (sec < 0x100));
@ -444,7 +444,7 @@ DiskCache::~DiskCache()
// RAW Mode Setting
//
//---------------------------------------------------------------------------
void FASTCALL DiskCache::SetRawMode(BOOL raw)
void DiskCache::SetRawMode(BOOL raw)
{
ASSERT(sec_size == 11);
@ -457,7 +457,7 @@ void FASTCALL DiskCache::SetRawMode(BOOL raw)
// Save
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskCache::Save()
BOOL DiskCache::Save()
{
// Save track
for (int i = 0; i < CacheMax; i++) {
@ -478,7 +478,7 @@ BOOL FASTCALL DiskCache::Save()
// Get disk cache information
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskCache::GetCache(int index, int& track, DWORD& aserial) const
BOOL DiskCache::GetCache(int index, int& track, DWORD& aserial) const
{
ASSERT((index >= 0) && (index < CacheMax));
@ -499,7 +499,7 @@ BOOL FASTCALL DiskCache::GetCache(int index, int& track, DWORD& aserial) const
// Clear
//
//---------------------------------------------------------------------------
void FASTCALL DiskCache::Clear()
void DiskCache::Clear()
{
// Free the cache
for (int i = 0; i < CacheMax; i++) {
@ -515,7 +515,7 @@ void FASTCALL DiskCache::Clear()
// Sector Read
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskCache::Read(BYTE *buf, int block)
BOOL DiskCache::Read(BYTE *buf, int block)
{
ASSERT(sec_size != 0);
@ -540,7 +540,7 @@ BOOL FASTCALL DiskCache::Read(BYTE *buf, int block)
// Sector write
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskCache::Write(const BYTE *buf, int block)
BOOL DiskCache::Write(const BYTE *buf, int block)
{
ASSERT(sec_size != 0);
@ -565,7 +565,7 @@ BOOL FASTCALL DiskCache::Write(const BYTE *buf, int block)
// Track Assignment
//
//---------------------------------------------------------------------------
DiskTrack* FASTCALL DiskCache::Assign(int track)
DiskTrack* DiskCache::Assign(int track)
{
ASSERT(sec_size != 0);
ASSERT(track >= 0);
@ -638,7 +638,7 @@ DiskTrack* FASTCALL DiskCache::Assign(int track)
// Load cache
//
//---------------------------------------------------------------------------
BOOL FASTCALL DiskCache::Load(int index, int track, DiskTrack *disktrk)
BOOL DiskCache::Load(int index, int track, DiskTrack *disktrk)
{
ASSERT((index >= 0) && (index < CacheMax));
ASSERT(track >= 0);
@ -677,7 +677,7 @@ BOOL FASTCALL DiskCache::Load(int index, int track, DiskTrack *disktrk)
// Update serial number
//
//---------------------------------------------------------------------------
void FASTCALL DiskCache::Update()
void DiskCache::Update()
{
// Update and do nothing except 0
serial++;
@ -703,8 +703,12 @@ void FASTCALL DiskCache::Update()
// Constructor
//
//---------------------------------------------------------------------------
Disk::Disk()
Disk::Disk(std::string id)
{
assert(id.length() == 4);
disk.id = id;
// Work initialization
disk.ready = FALSE;
disk.writep = FALSE;
@ -751,7 +755,7 @@ Disk::~Disk()
// Reset
//
//---------------------------------------------------------------------------
void FASTCALL Disk::Reset()
void Disk::Reset()
{
// no lock, no attention, reset
disk.lock = FALSE;
@ -759,22 +763,12 @@ void FASTCALL Disk::Reset()
disk.reset = TRUE;
}
//---------------------------------------------------------------------------
//
// NULL Check
//
//---------------------------------------------------------------------------
bool FASTCALL Disk::IsNULL() const
{
return disk.id.empty();
}
//---------------------------------------------------------------------------
//
// Retrieve the disk's ID
//
//---------------------------------------------------------------------------
const std::string& FASTCALL Disk::GetID() const
const std::string& Disk::GetID() const
{
return disk.id;
}
@ -785,7 +779,7 @@ const std::string& FASTCALL Disk::GetID() const
// Get cache writeback mode
//
//---------------------------------------------------------------------------
bool FASTCALL Disk::IsCacheWB()
bool Disk::IsCacheWB()
{
return cache_wb;
}
@ -795,7 +789,7 @@ bool FASTCALL Disk::IsCacheWB()
// Set cache writeback mode
//
//---------------------------------------------------------------------------
void FASTCALL Disk::SetCacheWB(BOOL enable)
void Disk::SetCacheWB(BOOL enable)
{
cache_wb = enable;
}
@ -806,37 +800,37 @@ void FASTCALL Disk::SetCacheWB(BOOL enable)
//
//---------------------------------------------------------------------------
bool FASTCALL Disk::IsSASI() const
bool Disk::IsSASI() const
{
return disk.id == "SAHD";
}
bool FASTCALL Disk::IsSCSI() const
bool Disk::IsSCSI() const
{
return disk.id == "SCHD";
}
bool FASTCALL Disk::IsCdRom() const
bool Disk::IsCdRom() const
{
return disk.id == "SCCD";
}
bool FASTCALL Disk::IsMo() const
bool Disk::IsMo() const
{
return disk.id == "SCMO";
}
bool FASTCALL Disk::IsBridge() const
bool Disk::IsBridge() const
{
return disk.id == "SCBR";
}
bool FASTCALL Disk::IsDaynaPort() const
bool Disk::IsDaynaPort() const
{
return disk.id == "SCDP";
}
bool FASTCALL Disk::IsNuvolink() const
bool Disk::IsNuvolink() const
{
return disk.id == "SCNL";
}
@ -847,7 +841,7 @@ bool FASTCALL Disk::IsNuvolink() const
// * Call as a post-process after successful opening in a derived class
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Open(const Filepath& path, BOOL /*attn*/)
BOOL Disk::Open(const Filepath& path, BOOL /*attn*/)
{
ASSERT((disk.size >= 8) && (disk.size <= 11));
ASSERT(disk.blocks > 0);
@ -888,7 +882,7 @@ BOOL FASTCALL Disk::Open(const Filepath& path, BOOL /*attn*/)
// Eject
//
//---------------------------------------------------------------------------
void FASTCALL Disk::Eject(BOOL force)
void Disk::Eject(BOOL force)
{
// Can only be ejected if it is removable
if (!disk.removable) {
@ -924,7 +918,7 @@ void FASTCALL Disk::Eject(BOOL force)
// Write Protected
//
//---------------------------------------------------------------------------
void FASTCALL Disk::WriteP(BOOL writep)
void Disk::WriteP(BOOL writep)
{
// be ready
if (!disk.ready) {
@ -946,7 +940,7 @@ void FASTCALL Disk::WriteP(BOOL writep)
// Get Path
//
//---------------------------------------------------------------------------
void FASTCALL Disk::GetPath(Filepath& path) const
void Disk::GetPath(Filepath& path) const
{
path = diskpath;
}
@ -956,7 +950,7 @@ void FASTCALL Disk::GetPath(Filepath& path) const
// Flush
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Flush()
BOOL Disk::Flush()
{
// Do nothing if there's nothing cached
if (!disk.dcache) {
@ -972,7 +966,7 @@ BOOL FASTCALL Disk::Flush()
// Check Ready
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::CheckReady()
BOOL Disk::CheckReady()
{
// Not ready if reset
if (disk.reset) {
@ -1010,7 +1004,7 @@ BOOL FASTCALL Disk::CheckReady()
// *You need to be successful at all times
//
//---------------------------------------------------------------------------
int FASTCALL Disk::Inquiry(
int Disk::Inquiry(
const DWORD* /*cdb*/, BYTE* /*buf*/, DWORD /*major*/, DWORD /*minor*/)
{
// default is INQUIRY failure
@ -1024,7 +1018,7 @@ int FASTCALL Disk::Inquiry(
// *SASI is a separate process
//
//---------------------------------------------------------------------------
int FASTCALL Disk::RequestSense(const DWORD *cdb, BYTE *buf)
int Disk::RequestSense(const DWORD *cdb, BYTE *buf)
{
ASSERT(cdb);
ASSERT(buf);
@ -1072,7 +1066,7 @@ int FASTCALL Disk::RequestSense(const DWORD *cdb, BYTE *buf)
// *Not affected by disk.code
//
//---------------------------------------------------------------------------
int FASTCALL Disk::SelectCheck(const DWORD *cdb)
int Disk::SelectCheck(const DWORD *cdb)
{
ASSERT(cdb);
@ -1097,7 +1091,7 @@ int FASTCALL Disk::SelectCheck(const DWORD *cdb)
// * Not affected by disk.code
//
//---------------------------------------------------------------------------
int FASTCALL Disk::SelectCheck10(const DWORD *cdb)
int Disk::SelectCheck10(const DWORD *cdb)
{
ASSERT(cdb);
@ -1126,7 +1120,7 @@ int FASTCALL Disk::SelectCheck10(const DWORD *cdb)
// * Not affected by disk.code
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::ModeSelect(
BOOL Disk::ModeSelect(
const DWORD* /*cdb*/, const BYTE *buf, int length)
{
ASSERT(buf);
@ -1144,7 +1138,7 @@ BOOL FASTCALL Disk::ModeSelect(
// *Not affected by disk.code
//
//---------------------------------------------------------------------------
int FASTCALL Disk::ModeSense(const DWORD *cdb, BYTE *buf)
int Disk::ModeSense(const DWORD *cdb, BYTE *buf)
{
BOOL valid;
BOOL change;
@ -1285,7 +1279,7 @@ int FASTCALL Disk::ModeSense(const DWORD *cdb, BYTE *buf)
// *Not affected by disk.code
//
//---------------------------------------------------------------------------
int FASTCALL Disk::ModeSense10(const DWORD *cdb, BYTE *buf)
int Disk::ModeSense10(const DWORD *cdb, BYTE *buf)
{
BOOL valid;
BOOL change;
@ -1423,7 +1417,7 @@ int FASTCALL Disk::ModeSense10(const DWORD *cdb, BYTE *buf)
// Add error page
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddError(BOOL change, BYTE *buf)
int Disk::AddError(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -1445,7 +1439,7 @@ int FASTCALL Disk::AddError(BOOL change, BYTE *buf)
// Add format page
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddFormat(BOOL change, BYTE *buf)
int Disk::AddFormat(BOOL change, BYTE *buf)
{
int size;
@ -1490,7 +1484,7 @@ int FASTCALL Disk::AddFormat(BOOL change, BYTE *buf)
// Add drive page
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddDrive(BOOL change, BYTE *buf)
int Disk::AddDrive(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -1525,7 +1519,7 @@ int FASTCALL Disk::AddDrive(BOOL change, BYTE *buf)
// Add option
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddOpt(BOOL change, BYTE *buf)
int Disk::AddOpt(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -1547,7 +1541,7 @@ int FASTCALL Disk::AddOpt(BOOL change, BYTE *buf)
// Add Cache Page
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddCache(BOOL change, BYTE *buf)
int Disk::AddCache(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -1569,7 +1563,7 @@ int FASTCALL Disk::AddCache(BOOL change, BYTE *buf)
// Add CDROM Page
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddCDROM(BOOL change, BYTE *buf)
int Disk::AddCDROM(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -1597,7 +1591,7 @@ int FASTCALL Disk::AddCDROM(BOOL change, BYTE *buf)
// CD-DAページ追加
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddCDDA(BOOL change, BYTE *buf)
int Disk::AddCDDA(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -1620,7 +1614,7 @@ int FASTCALL Disk::AddCDDA(BOOL change, BYTE *buf)
// Add special vendor page
//
//---------------------------------------------------------------------------
int FASTCALL Disk::AddVendor(int /*page*/, BOOL /*change*/, BYTE *buf)
int Disk::AddVendor(int /*page*/, BOOL /*change*/, BYTE *buf)
{
ASSERT(buf);
@ -1633,7 +1627,7 @@ int FASTCALL Disk::AddVendor(int /*page*/, BOOL /*change*/, BYTE *buf)
// *Not affected by disk.code
//
//---------------------------------------------------------------------------
int FASTCALL Disk::ReadDefectData10(const DWORD *cdb, BYTE *buf)
int Disk::ReadDefectData10(const DWORD *cdb, BYTE *buf)
{
ASSERT(cdb);
ASSERT(buf);
@ -1679,7 +1673,7 @@ int FASTCALL Disk::ReadDefectData10(const DWORD *cdb, BYTE *buf)
// TEST UNIT READY
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::TestUnitReady(const DWORD* /*cdb*/)
BOOL Disk::TestUnitReady(const DWORD* /*cdb*/)
{
// Status check
if (!CheckReady()) {
@ -1695,7 +1689,7 @@ BOOL FASTCALL Disk::TestUnitReady(const DWORD* /*cdb*/)
// REZERO UNIT
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Rezero(const DWORD* /*cdb*/)
BOOL Disk::Rezero(const DWORD* /*cdb*/)
{
// Status check
if (!CheckReady()) {
@ -1712,7 +1706,7 @@ BOOL FASTCALL Disk::Rezero(const DWORD* /*cdb*/)
// *Opcode $06 for SASI, Opcode $04 for SCSI
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Format(const DWORD *cdb)
BOOL Disk::Format(const DWORD *cdb)
{
// Status check
if (!CheckReady()) {
@ -1734,7 +1728,7 @@ BOOL FASTCALL Disk::Format(const DWORD *cdb)
// REASSIGN BLOCKS
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Reassign(const DWORD* /*cdb*/)
BOOL Disk::Reassign(const DWORD* /*cdb*/)
{
// Status check
if (!CheckReady()) {
@ -1750,7 +1744,7 @@ BOOL FASTCALL Disk::Reassign(const DWORD* /*cdb*/)
// READ
//
//---------------------------------------------------------------------------
int FASTCALL Disk::Read(const DWORD *cdb, BYTE *buf, DWORD block)
int Disk::Read(const DWORD *cdb, BYTE *buf, DWORD block)
{
ASSERT(buf);
@ -1780,7 +1774,7 @@ int FASTCALL Disk::Read(const DWORD *cdb, BYTE *buf, DWORD block)
// WRITE check
//
//---------------------------------------------------------------------------
int FASTCALL Disk::WriteCheck(DWORD block)
int Disk::WriteCheck(DWORD block)
{
// Status check
if (!CheckReady()) {
@ -1807,7 +1801,7 @@ int FASTCALL Disk::WriteCheck(DWORD block)
// WRITE
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Write(const DWORD *cdb, const BYTE *buf, DWORD block)
BOOL Disk::Write(const DWORD *cdb, const BYTE *buf, DWORD block)
{
ASSERT(buf);
@ -1847,7 +1841,7 @@ BOOL FASTCALL Disk::Write(const DWORD *cdb, const BYTE *buf, DWORD block)
// *Does not check LBA (SASI IOCS)
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Seek(const DWORD* /*cdb*/)
BOOL Disk::Seek(const DWORD* /*cdb*/)
{
// Status check
if (!CheckReady()) {
@ -1863,7 +1857,7 @@ BOOL FASTCALL Disk::Seek(const DWORD* /*cdb*/)
// ASSIGN
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Assign(const DWORD* /*cdb*/)
BOOL Disk::Assign(const DWORD* /*cdb*/)
{
// Status check
if (!CheckReady()) {
@ -1879,7 +1873,7 @@ BOOL FASTCALL Disk::Assign(const DWORD* /*cdb*/)
// SPECIFY
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Specify(const DWORD* /*cdb*/)
BOOL Disk::Specify(const DWORD* /*cdb*/)
{
// Status check
if (!CheckReady()) {
@ -1895,7 +1889,7 @@ BOOL FASTCALL Disk::Specify(const DWORD* /*cdb*/)
// START STOP UNIT
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::StartStop(const DWORD *cdb)
BOOL Disk::StartStop(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x1b);
@ -1922,7 +1916,7 @@ BOOL FASTCALL Disk::StartStop(const DWORD *cdb)
// SEND DIAGNOSTIC
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::SendDiag(const DWORD *cdb)
BOOL Disk::SendDiag(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x1d);
@ -1949,7 +1943,7 @@ BOOL FASTCALL Disk::SendDiag(const DWORD *cdb)
// PREVENT/ALLOW MEDIUM REMOVAL
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Removal(const DWORD *cdb)
BOOL Disk::Removal(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x1e);
@ -1975,7 +1969,7 @@ BOOL FASTCALL Disk::Removal(const DWORD *cdb)
// READ CAPACITY
//
//---------------------------------------------------------------------------
int FASTCALL Disk::ReadCapacity(const DWORD* /*cdb*/, BYTE *buf)
int Disk::ReadCapacity(const DWORD* /*cdb*/, BYTE *buf)
{
DWORD blocks;
DWORD length;
@ -2019,7 +2013,7 @@ int FASTCALL Disk::ReadCapacity(const DWORD* /*cdb*/, BYTE *buf)
// VERIFY
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::Verify(const DWORD *cdb)
BOOL Disk::Verify(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x2f);
@ -2056,7 +2050,7 @@ BOOL FASTCALL Disk::Verify(const DWORD *cdb)
// READ TOC
//
//---------------------------------------------------------------------------
int FASTCALL Disk::ReadToc(const DWORD *cdb, BYTE *buf)
int Disk::ReadToc(const DWORD *cdb, BYTE *buf)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x43);
@ -2072,7 +2066,7 @@ int FASTCALL Disk::ReadToc(const DWORD *cdb, BYTE *buf)
// PLAY AUDIO
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::PlayAudio(const DWORD *cdb)
BOOL Disk::PlayAudio(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x45);
@ -2087,7 +2081,7 @@ BOOL FASTCALL Disk::PlayAudio(const DWORD *cdb)
// PLAY AUDIO MSF
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::PlayAudioMSF(const DWORD *cdb)
BOOL Disk::PlayAudioMSF(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x47);
@ -2102,7 +2096,7 @@ BOOL FASTCALL Disk::PlayAudioMSF(const DWORD *cdb)
// PLAY AUDIO TRACK
//
//---------------------------------------------------------------------------
BOOL FASTCALL Disk::PlayAudioTrack(const DWORD *cdb)
BOOL Disk::PlayAudioTrack(const DWORD *cdb)
{
ASSERT(cdb);
ASSERT(cdb[0] == 0x48);

156
src/raspberrypi/devices/disk.h
View File

@ -21,6 +21,7 @@
#include "log.h"
#include "scsi.h"
#include "filepath.h"
#include <string>
//---------------------------------------------------------------------------
//
@ -89,17 +90,17 @@ public:
// Basic Functions
DiskTrack(); // Constructor
virtual ~DiskTrack(); // Destructor
void FASTCALL Init(int track, int size, int sectors, BOOL raw = FALSE, off64_t imgoff = 0);// Initialization
BOOL FASTCALL Load(const Filepath& path); // Load
BOOL FASTCALL Save(const Filepath& path); // Save
void Init(int track, int size, int sectors, BOOL raw = FALSE, off64_t imgoff = 0);// Initialization
BOOL Load(const Filepath& path); // Load
BOOL Save(const Filepath& path); // Save
// Read / Write
BOOL FASTCALL Read(BYTE *buf, int sec) const; // Sector Read
BOOL FASTCALL Write(const BYTE *buf, int sec); // Sector Write
BOOL Read(BYTE *buf, int sec) const; // Sector Read
BOOL Write(const BYTE *buf, int sec); // Sector Write
// Other
int FASTCALL GetTrack() const { return dt.track; } // Get track
BOOL FASTCALL IsChanged() const { return dt.changed; } // Changed flag check
int GetTrack() const { return dt.track; } // Get track
BOOL IsChanged() const { return dt.changed; } // Changed flag check
private:
// Internal data
@ -129,20 +130,20 @@ public:
// Basic Functions
DiskCache(const Filepath& path, int size, int blocks,off64_t imgoff = 0);// Constructor
virtual ~DiskCache(); // Destructor
void FASTCALL SetRawMode(BOOL raw); // CD-ROM raw mode setting
void SetRawMode(BOOL raw); // CD-ROM raw mode setting
// Access
BOOL FASTCALL Save(); // Save and release all
BOOL FASTCALL Read(BYTE *buf, int block); // Sector Read
BOOL FASTCALL Write(const BYTE *buf, int block); // Sector Write
BOOL FASTCALL GetCache(int index, int& track, DWORD& serial) const; // Get cache information
BOOL Save(); // Save and release all
BOOL Read(BYTE *buf, int block); // Sector Read
BOOL Write(const BYTE *buf, int block); // Sector Write
BOOL GetCache(int index, int& track, DWORD& serial) const; // Get cache information
private:
// Internal Management
void FASTCALL Clear(); // Clear all tracks
DiskTrack* FASTCALL Assign(int track); // Load track
BOOL FASTCALL Load(int index, int track, DiskTrack *disktrk = NULL); // Load track
void FASTCALL Update(); // Update serial number
void Clear(); // Clear all tracks
DiskTrack* Assign(int track); // Load track
BOOL Load(int index, int track, DiskTrack *disktrk = NULL); // Load track
void Update(); // Update serial number
// Internal data
cache_t cache[CacheMax]; // Cache management
@ -182,82 +183,81 @@ public:
public:
// Basic Functions
Disk(); // Constructor
Disk(std::string); // Constructor
virtual ~Disk(); // Destructor
virtual void FASTCALL Reset(); // Device Reset
virtual void Reset(); // Device Reset
// ID
const std::string& FASTCALL GetID() const; // Get media ID
bool FASTCALL IsNULL() const; // NULL check
bool FASTCALL IsSASI() const; // SASI Check
bool FASTCALL IsSCSI() const; // SASI Check
bool FASTCALL IsCdRom() const;
bool FASTCALL IsMo() const;
bool FASTCALL IsBridge() const;
bool FASTCALL IsDaynaPort() const;
bool FASTCALL IsNuvolink() const;
const std::string& GetID() const; // Get media ID
bool IsSASI() const; // SASI Check
bool IsSCSI() const; // SASI Check
bool IsCdRom() const;
bool IsMo() const;
bool IsBridge() const;
bool IsDaynaPort() const;
bool IsNuvolink() const;
// Media Operations
virtual BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); // Open
void FASTCALL GetPath(Filepath& path) const; // Get the path
void FASTCALL Eject(BOOL force); // Eject
BOOL FASTCALL IsReady() const { return disk.ready; } // Ready check
void FASTCALL WriteP(BOOL flag); // Set Write Protect flag
BOOL FASTCALL IsWriteP() const { return disk.writep; } // Get write protect flag
BOOL FASTCALL IsReadOnly() const { return disk.readonly; } // Get read only flag
BOOL FASTCALL IsRemovable() const { return disk.removable; } // Get is removable flag
BOOL FASTCALL IsLocked() const { return disk.lock; } // Get locked status
BOOL FASTCALL IsAttn() const { return disk.attn; } // Get attention flag
BOOL FASTCALL Flush(); // Flush the cache
virtual BOOL Open(const Filepath& path, BOOL attn = TRUE); // Open
void GetPath(Filepath& path) const; // Get the path
void Eject(BOOL force); // Eject
BOOL IsReady() const { return disk.ready; } // Ready check
void WriteP(BOOL flag); // Set Write Protect flag
BOOL IsWriteP() const { return disk.writep; } // Get write protect flag
BOOL IsReadOnly() const { return disk.readonly; } // Get read only flag
BOOL IsRemovable() const { return disk.removable; } // Get is removable flag
BOOL IsLocked() const { return disk.lock; } // Get locked status
BOOL IsAttn() const { return disk.attn; } // Get attention flag
BOOL Flush(); // Flush the cache
// Properties
void FASTCALL SetLUN(DWORD lun) { disk.lun = lun; } // LUN set
DWORD FASTCALL GetLUN() { return disk.lun; } // LUN get
void SetLUN(DWORD lun) { disk.lun = lun; } // LUN set
DWORD GetLUN() { return disk.lun; } // LUN get
// commands
virtual int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor);// INQUIRY command
virtual int FASTCALL RequestSense(const DWORD *cdb, BYTE *buf); // REQUEST SENSE command
int FASTCALL SelectCheck(const DWORD *cdb); // SELECT check
int FASTCALL SelectCheck10(const DWORD *cdb); // SELECT(10) check
virtual BOOL FASTCALL ModeSelect(const DWORD *cdb, const BYTE *buf, int length);// MODE SELECT command
virtual int FASTCALL ModeSense(const DWORD *cdb, BYTE *buf); // MODE SENSE command
virtual int FASTCALL ModeSense10(const DWORD *cdb, BYTE *buf); // MODE SENSE(10) command
int FASTCALL ReadDefectData10(const DWORD *cdb, BYTE *buf); // READ DEFECT DATA(10) command
virtual BOOL FASTCALL TestUnitReady(const DWORD *cdb); // TEST UNIT READY command
BOOL FASTCALL Rezero(const DWORD *cdb); // REZERO command
BOOL FASTCALL Format(const DWORD *cdb); // FORMAT UNIT command
BOOL FASTCALL Reassign(const DWORD *cdb); // REASSIGN UNIT command
virtual int FASTCALL Read(const DWORD *cdb, BYTE *buf, DWORD block); // READ command
virtual int FASTCALL WriteCheck(DWORD block); // WRITE check
virtual BOOL FASTCALL Write(const DWORD *cdb, const BYTE *buf, DWORD block); // WRITE command
BOOL FASTCALL Seek(const DWORD *cdb); // SEEK command
BOOL FASTCALL Assign(const DWORD *cdb); // ASSIGN command
BOOL FASTCALL Specify(const DWORD *cdb); // SPECIFY command
BOOL FASTCALL StartStop(const DWORD *cdb); // START STOP UNIT command
BOOL FASTCALL SendDiag(const DWORD *cdb); // SEND DIAGNOSTIC command
BOOL FASTCALL Removal(const DWORD *cdb); // PREVENT/ALLOW MEDIUM REMOVAL command
int FASTCALL ReadCapacity(const DWORD *cdb, BYTE *buf); // READ CAPACITY command
BOOL FASTCALL Verify(const DWORD *cdb); // VERIFY command
virtual int FASTCALL ReadToc(const DWORD *cdb, BYTE *buf); // READ TOC command
virtual BOOL FASTCALL PlayAudio(const DWORD *cdb); // PLAY AUDIO command
virtual BOOL FASTCALL PlayAudioMSF(const DWORD *cdb); // PLAY AUDIO MSF command
virtual BOOL FASTCALL PlayAudioTrack(const DWORD *cdb); // PLAY AUDIO TRACK command
virtual int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor);// INQUIRY command
virtual int RequestSense(const DWORD *cdb, BYTE *buf); // REQUEST SENSE command
int SelectCheck(const DWORD *cdb); // SELECT check
int SelectCheck10(const DWORD *cdb); // SELECT(10) check
virtual BOOL ModeSelect(const DWORD *cdb, const BYTE *buf, int length);// MODE SELECT command
virtual int ModeSense(const DWORD *cdb, BYTE *buf); // MODE SENSE command
virtual int ModeSense10(const DWORD *cdb, BYTE *buf); // MODE SENSE(10) command
int ReadDefectData10(const DWORD *cdb, BYTE *buf); // READ DEFECT DATA(10) command
virtual BOOL TestUnitReady(const DWORD *cdb); // TEST UNIT READY command
BOOL Rezero(const DWORD *cdb); // REZERO command
BOOL Format(const DWORD *cdb); // FORMAT UNIT command
BOOL Reassign(const DWORD *cdb); // REASSIGN UNIT command
virtual int Read(const DWORD *cdb, BYTE *buf, DWORD block); // READ command
virtual int WriteCheck(DWORD block); // WRITE check
virtual BOOL Write(const DWORD *cdb, const BYTE *buf, DWORD block); // WRITE command
BOOL Seek(const DWORD *cdb); // SEEK command
BOOL Assign(const DWORD *cdb); // ASSIGN command
BOOL Specify(const DWORD *cdb); // SPECIFY command
BOOL StartStop(const DWORD *cdb); // START STOP UNIT command
BOOL SendDiag(const DWORD *cdb); // SEND DIAGNOSTIC command
BOOL Removal(const DWORD *cdb); // PREVENT/ALLOW MEDIUM REMOVAL command
int ReadCapacity(const DWORD *cdb, BYTE *buf); // READ CAPACITY command
BOOL Verify(const DWORD *cdb); // VERIFY command
virtual int ReadToc(const DWORD *cdb, BYTE *buf); // READ TOC command
virtual BOOL PlayAudio(const DWORD *cdb); // PLAY AUDIO command
virtual BOOL PlayAudioMSF(const DWORD *cdb); // PLAY AUDIO MSF command
virtual BOOL PlayAudioTrack(const DWORD *cdb); // PLAY AUDIO TRACK command
// Other
bool FASTCALL IsCacheWB(); // Get cache writeback mode
void FASTCALL SetCacheWB(BOOL enable); // Set cache writeback mode
bool IsCacheWB(); // Get cache writeback mode
void SetCacheWB(BOOL enable); // Set cache writeback mode
protected:
// Internal processing
virtual int FASTCALL AddError(BOOL change, BYTE *buf); // Add error
virtual int FASTCALL AddFormat(BOOL change, BYTE *buf); // Add format
virtual int FASTCALL AddDrive(BOOL change, BYTE *buf); // Add drive
int FASTCALL AddOpt(BOOL change, BYTE *buf); // Add optical
int FASTCALL AddCache(BOOL change, BYTE *buf); // Add cache
int FASTCALL AddCDROM(BOOL change, BYTE *buf); // Add CD-ROM
int FASTCALL AddCDDA(BOOL change, BYTE *buf); // Add CD_DA
virtual int FASTCALL AddVendor(int page, BOOL change, BYTE *buf); // Add vendor special info
BOOL FASTCALL CheckReady(); // Check if ready
virtual int AddError(BOOL change, BYTE *buf); // Add error
virtual int AddFormat(BOOL change, BYTE *buf); // Add format
virtual int AddDrive(BOOL change, BYTE *buf); // Add drive
int AddOpt(BOOL change, BYTE *buf); // Add optical
int AddCache(BOOL change, BYTE *buf); // Add cache
int AddCDROM(BOOL change, BYTE *buf); // Add CD-ROM
int AddCDDA(BOOL change, BYTE *buf); // Add CD_DA
virtual int AddVendor(int page, BOOL change, BYTE *buf); // Add vendor special info
BOOL CheckReady(); // Check if ready
// Internal data
disk_t disk; // Internal disk data

48
src/raspberrypi/devices/sasihd.cpp
View File

@ -29,34 +29,32 @@
// Constructor
//
//---------------------------------------------------------------------------
SASIHD::SASIHD() : Disk()
SASIHD::SASIHD() : Disk("SAHD")
{
// SASI ハードディスク
disk.id = "SAHD";
}
//---------------------------------------------------------------------------
//
// リセット
// Reset
//
//---------------------------------------------------------------------------
void FASTCALL SASIHD::Reset()
void SASIHD::Reset()
{
// ロック状態解除、アテンション解除
// Unlock, clear attention
disk.lock = FALSE;
disk.attn = FALSE;
// Resetなし、コードをクリア
// Reset, clear the code
disk.reset = FALSE;
disk.code = 0x00;
}
//---------------------------------------------------------------------------
//
// オープン
// Open
//
//---------------------------------------------------------------------------
BOOL FASTCALL SASIHD::Open(const Filepath& path, BOOL /*attn*/)
BOOL SASIHD::Open(const Filepath& path, BOOL /*attn*/)
{
ASSERT(!disk.ready);
@ -71,10 +69,10 @@ BOOL FASTCALL SASIHD::Open(const Filepath& path, BOOL /*attn*/)
fio.Close();
#if defined(USE_MZ1F23_1024_SUPPORT)
// MZ-2500/MZ-2800用 MZ-1F23(SASI 20M/セクタサイズ1024)専用
// For MZ-2500 / MZ-2800 MZ-1F23 (SASI 20M / sector size 1024) only
// 20M(22437888 BS=1024 C=21912)
if (size == 0x1566000) {
// セクタサイズとブロック数
// Sector size and number of blocks
disk.size = 10;
disk.blocks = (DWORD)(size >> 10);
@ -84,42 +82,42 @@ BOOL FASTCALL SASIHD::Open(const Filepath& path, BOOL /*attn*/)
#endif // USE_MZ1F23_1024_SUPPORT
#if defined(REMOVE_FIXED_SASIHD_SIZE)
// 256バイト単位であること
// Must be in 256-byte units
if (size & 0xff) {
return FALSE;
}
// 10MB以上
// 10MB or more
if (size < 0x9f5400) {
return FALSE;
}
// 512MB程度に制限しておく
// Limit to about 512MB
if (size > 512 * 1024 * 1024) {
return FALSE;
}
#else
// 10MB, 20MB, 40MBのみ
switch (size) {
// 10MB(10441728 BS=256 C=40788)
// 10MB (10441728 BS=256 C=40788)
case 0x9f5400:
break;
// 20MB(20748288 BS=256 C=81048)
// 20MB (20748288 BS=256 C=81048)
case 0x13c9800:
break;
// 40MB(41496576 BS=256 C=162096)
// 40MB (41496576 BS=256 C=162096)
case 0x2793000:
break;
// Other(サポートしない)
// Other (Not supported )
default:
return FALSE;
}
#endif // REMOVE_FIXED_SASIHD_SIZE
// セクタサイズとブロック数
// Sector size and number of blocks
disk.size = 8;
disk.blocks = (DWORD)(size >> 8);
@ -132,26 +130,26 @@ BOOL FASTCALL SASIHD::Open(const Filepath& path, BOOL /*attn*/)
// REQUEST SENSE
//
//---------------------------------------------------------------------------
int FASTCALL SASIHD::RequestSense(const DWORD *cdb, BYTE *buf)
int SASIHD::RequestSense(const DWORD *cdb, BYTE *buf)
{
ASSERT(cdb);
ASSERT(buf);
// サイズ決定
// Size decision
int size = (int)cdb[4];
ASSERT((size >= 0) && (size < 0x100));
ASSERT(size >= 0 && size < 0x100);
// サイズ0のときに4バイト転送する(Shugart Associates System Interface仕様)
// Transfer 4 bytes when size 0 (Shugart Associates System Interface specification)
if (size == 0) {
size = 4;
}
// SASIは非拡張フォーマットに固定
// SASI fixed to non-extended format
memset(buf, 0, size);
buf[0] = (BYTE)(disk.code >> 16);
buf[1] = (BYTE)(disk.lun << 5);
// コードをクリア
// Clear the code
disk.code = 0x00;
return size;

6
src/raspberrypi/devices/sasihd.h
View File

@ -29,9 +29,9 @@ class SASIHD : public Disk
public:
// Basic Functions
SASIHD(); // Constructor
void FASTCALL Reset(); // Reset
BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); // Open
void Reset(); // Reset
BOOL Open(const Filepath& path, BOOL attn = TRUE); // Open
// commands
int FASTCALL RequestSense(const DWORD *cdb, BYTE *buf); // REQUEST SENSE command
int RequestSense(const DWORD *cdb, BYTE *buf); // REQUEST SENSE command
};

26
src/raspberrypi/devices/scsi_daynaport.cpp
View File

@ -47,12 +47,8 @@ const BYTE SCSIDaynaPort::m_apple_talk_addr[6] = { 0x09, 0x00, 0x07, 0xff, 0xff,
// Constructor
//
//---------------------------------------------------------------------------
SCSIDaynaPort::SCSIDaynaPort() : Disk()
SCSIDaynaPort::SCSIDaynaPort() : Disk("SCDP")
{
LOGTRACE("SCSI DaynaPort Constructor");
// DaynaPort
disk.id = "SCDP";
#ifdef __linux__
// TAP Driver Generation
m_tap = new CTapDriver();
@ -106,7 +102,7 @@ SCSIDaynaPort::~SCSIDaynaPort()
}
}
BOOL FASTCALL SCSIDaynaPort::Open(const Filepath& path, BOOL attn)
BOOL SCSIDaynaPort::Open(const Filepath& path, BOOL attn)
{
LOGTRACE("SCSIDaynaPort Open");
return m_tap->OpenDump(path);
@ -117,7 +113,7 @@ BOOL FASTCALL SCSIDaynaPort::Open(const Filepath& path, BOOL attn)
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSIDaynaPort::Inquiry(const DWORD *cdb, BYTE *buffer, DWORD major, DWORD minor)
int SCSIDaynaPort::Inquiry(const DWORD *cdb, BYTE *buffer, DWORD major, DWORD minor)
{
// scsi_cdb_6_byte_t command;
// memcpy(&command,cdb,sizeof(command));
@ -169,7 +165,7 @@ int FASTCALL SCSIDaynaPort::Inquiry(const DWORD *cdb, BYTE *buffer, DWORD major,
// RequestSense
//
//---------------------------------------------------------------------------
int FASTCALL SCSIDaynaPort::RequestSense(const DWORD *cdb, BYTE *buffer)
int SCSIDaynaPort::RequestSense(const DWORD *cdb, BYTE *buffer)
{
// The DaynaPort RequestSense response will always be 9 bytes.
int size = 9;
@ -193,7 +189,7 @@ int FASTCALL SCSIDaynaPort::RequestSense(const DWORD *cdb, BYTE *buffer)
// READ
//
//---------------------------------------------------------------------------
int FASTCALL SCSIDaynaPort::Read(const DWORD *cdb, BYTE *buf, DWORD block)
int SCSIDaynaPort::Read(const DWORD *cdb, BYTE *buf, DWORD block)
{
WORD requested_length = 0;
int rx_packet_size = 0;
@ -329,7 +325,7 @@ int FASTCALL SCSIDaynaPort::Read(const DWORD *cdb, BYTE *buf, DWORD block)
// WRITE check
//
//---------------------------------------------------------------------------
int FASTCALL SCSIDaynaPort::WriteCheck(DWORD block)
int SCSIDaynaPort::WriteCheck(DWORD block)
{
LOGTRACE("%s block: %lu", __PRETTY_FUNCTION__, block);
@ -353,7 +349,7 @@ int FASTCALL SCSIDaynaPort::WriteCheck(DWORD block)
// Write
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIDaynaPort::Write(const DWORD *cdb, const BYTE *buf, DWORD block)
BOOL SCSIDaynaPort::Write(const DWORD *cdb, const BYTE *buf, DWORD block)
{
BYTE data_format;
WORD data_length;
@ -398,7 +394,7 @@ BOOL FASTCALL SCSIDaynaPort::Write(const DWORD *cdb, const BYTE *buf, DWORD bloc
// RetrieveStats
//
//---------------------------------------------------------------------------
int FASTCALL SCSIDaynaPort::RetrieveStats(const DWORD *cdb, BYTE *buffer)
int SCSIDaynaPort::RetrieveStats(const DWORD *cdb, BYTE *buffer)
{
DWORD response_size;
DWORD allocation_length;
@ -483,7 +479,7 @@ int FASTCALL SCSIDaynaPort::RetrieveStats(const DWORD *cdb, BYTE *buffer)
// Enable or Disable the interface
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIDaynaPort::EnableInterface(const DWORD *cdb)
BOOL SCSIDaynaPort::EnableInterface(const DWORD *cdb)
{
int result;
// scsi_cdb_6_byte_t *command = (scsi_cdb_6_byte_t*)cdb;
@ -520,7 +516,7 @@ BOOL FASTCALL SCSIDaynaPort::EnableInterface(const DWORD *cdb)
// TEST UNIT READY
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIDaynaPort::TestUnitReady(const DWORD* /*cdb*/)
BOOL SCSIDaynaPort::TestUnitReady(const DWORD* /*cdb*/)
{
LOGTRACE("%s", __PRETTY_FUNCTION__);
@ -534,7 +530,7 @@ BOOL FASTCALL SCSIDaynaPort::TestUnitReady(const DWORD* /*cdb*/)
// Set Mode - enable broadcast messages
//
//---------------------------------------------------------------------------
void FASTCALL SCSIDaynaPort::SetMode(const DWORD *cdb, BYTE *buffer)
void SCSIDaynaPort::SetMode(const DWORD *cdb, BYTE *buffer)
{
LOGTRACE("%s Setting mode", __PRETTY_FUNCTION__);

22
src/raspberrypi/devices/scsi_daynaport.h
View File

@ -46,31 +46,31 @@ public:
// Constructor
virtual ~SCSIDaynaPort();
// Destructor
BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE);
BOOL Open(const Filepath& path, BOOL attn = TRUE);
// Capture packets
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buffer, DWORD major, DWORD minor);
int Inquiry(const DWORD *cdb, BYTE *buffer, DWORD major, DWORD minor);
// INQUIRY command
BOOL FASTCALL TestUnitReady(const DWORD *cdb);
BOOL TestUnitReady(const DWORD *cdb);
// TEST UNIT READY command
int FASTCALL Read(const DWORD *cdb, BYTE *buf, DWORD block) override;
int Read(const DWORD *cdb, BYTE *buf, DWORD block) override;
// READ command
BOOL FASTCALL Write(const DWORD *cdb, const BYTE *buf, DWORD block) override;
BOOL Write(const DWORD *cdb, const BYTE *buf, DWORD block) override;
// WRITE command
int FASTCALL WriteCheck(DWORD block) override;
int WriteCheck(DWORD block) override;
// WRITE check
int FASTCALL RetrieveStats(const DWORD *cdb, BYTE *buffer);
int RetrieveStats(const DWORD *cdb, BYTE *buffer);
// Retrieve DaynaPort statistics
BOOL FASTCALL EnableInterface(const DWORD *cdb);
BOOL EnableInterface(const DWORD *cdb);
// Enable/Disable Interface command
void FASTCALL SetMacAddr(const DWORD *cdb, BYTE *buffer);
void SetMacAddr(const DWORD *cdb, BYTE *buffer);
// Set MAC address
void FASTCALL SetMode(const DWORD *cdb, BYTE *buffer);
void SetMode(const DWORD *cdb, BYTE *buffer);
// Set the mode: whether broadcast traffic is enabled or not
int FASTCALL RequestSense(const DWORD *cdb, BYTE *buf) override;
int RequestSense(const DWORD *cdb, BYTE *buf) override;
static const BYTE CMD_SCSILINK_STATS = 0x09;
static const BYTE CMD_SCSILINK_ENABLE = 0x0E;

83
src/raspberrypi/devices/scsi_host_bridge.cpp
View File

@ -32,16 +32,13 @@
// Constructor
//
//---------------------------------------------------------------------------
SCSIBR::SCSIBR() : Disk()
SCSIBR::SCSIBR() : Disk("SCBR")
{
fsoptlen = 0;
fsoutlen = 0;
fsresult = 0;
packet_len = 0;
// Host Bridge
disk.id = "SCBR";
#ifdef __linux__
// TAP Driver Generation
tap = new CTapDriver();
@ -88,7 +85,7 @@ SCSIBR::~SCSIBR()
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSIBR::Inquiry(
int SCSIBR::Inquiry(
const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor)
{
char rev[32];
@ -163,7 +160,7 @@ int FASTCALL SCSIBR::Inquiry(
// TEST UNIT READY
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIBR::TestUnitReady(const DWORD* /*cdb*/)
BOOL SCSIBR::TestUnitReady(const DWORD* /*cdb*/)
{
// TEST UNIT READY Success
disk.code = DISK_NOERROR;
@ -175,7 +172,7 @@ BOOL FASTCALL SCSIBR::TestUnitReady(const DWORD* /*cdb*/)
// GET MESSAGE(10)
//
//---------------------------------------------------------------------------
int FASTCALL SCSIBR::GetMessage10(const DWORD *cdb, BYTE *buf)
int SCSIBR::GetMessage10(const DWORD *cdb, BYTE *buf)
{
int func;
int total_len;
@ -264,7 +261,7 @@ int FASTCALL SCSIBR::GetMessage10(const DWORD *cdb, BYTE *buf)
// SEND MESSAGE(10)
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIBR::SendMessage10(const DWORD *cdb, BYTE *buf)
BOOL SCSIBR::SendMessage10(const DWORD *cdb, BYTE *buf)
{
ASSERT(cdb);
ASSERT(buf);
@ -326,7 +323,7 @@ BOOL FASTCALL SCSIBR::SendMessage10(const DWORD *cdb, BYTE *buf)
// Get MAC Address
//
//---------------------------------------------------------------------------
int FASTCALL SCSIBR::GetMacAddr(BYTE *mac)
int SCSIBR::GetMacAddr(BYTE *mac)
{
ASSERT(mac);
@ -339,7 +336,7 @@ int FASTCALL SCSIBR::GetMacAddr(BYTE *mac)
// Set MAC Address
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::SetMacAddr(BYTE *mac)
void SCSIBR::SetMacAddr(BYTE *mac)
{
ASSERT(mac);
@ -351,7 +348,7 @@ void FASTCALL SCSIBR::SetMacAddr(BYTE *mac)
// Receive Packet
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::ReceivePacket()
void SCSIBR::ReceivePacket()
{
static const BYTE bcast_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
@ -390,7 +387,7 @@ void FASTCALL SCSIBR::ReceivePacket()
// Get Packet
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::GetPacketBuf(BYTE *buf)
void SCSIBR::GetPacketBuf(BYTE *buf)
{
ASSERT(tap);
ASSERT(buf);
@ -413,7 +410,7 @@ void FASTCALL SCSIBR::GetPacketBuf(BYTE *buf)
// Send Packet
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::SendPacket(BYTE *buf, int len)
void SCSIBR::SendPacket(BYTE *buf, int len)
{
ASSERT(tap);
ASSERT(buf);
@ -426,7 +423,7 @@ void FASTCALL SCSIBR::SendPacket(BYTE *buf, int len)
// $40 - Device Boot
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_InitDevice(BYTE *buf)
void SCSIBR::FS_InitDevice(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -440,7 +437,7 @@ void FASTCALL SCSIBR::FS_InitDevice(BYTE *buf)
// $41 - Directory Check
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_CheckDir(BYTE *buf)
void SCSIBR::FS_CheckDir(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -461,7 +458,7 @@ void FASTCALL SCSIBR::FS_CheckDir(BYTE *buf)
// $42 - Create Directory
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_MakeDir(BYTE *buf)
void SCSIBR::FS_MakeDir(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -482,7 +479,7 @@ void FASTCALL SCSIBR::FS_MakeDir(BYTE *buf)
// $43 - Remove Directory
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_RemoveDir(BYTE *buf)
void SCSIBR::FS_RemoveDir(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -503,7 +500,7 @@ void FASTCALL SCSIBR::FS_RemoveDir(BYTE *buf)
// $44 - Rename
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Rename(BYTE *buf)
void SCSIBR::FS_Rename(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -527,7 +524,7 @@ void FASTCALL SCSIBR::FS_Rename(BYTE *buf)
// $45 - Delete File
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Delete(BYTE *buf)
void SCSIBR::FS_Delete(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -548,7 +545,7 @@ void FASTCALL SCSIBR::FS_Delete(BYTE *buf)
// $46 - Get / Set file attributes
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Attribute(BYTE *buf)
void SCSIBR::FS_Attribute(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -573,7 +570,7 @@ void FASTCALL SCSIBR::FS_Attribute(BYTE *buf)
// $47 - File Search
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Files(BYTE *buf)
void SCSIBR::FS_Files(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -619,7 +616,7 @@ void FASTCALL SCSIBR::FS_Files(BYTE *buf)
// $48 - File next search
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_NFiles(BYTE *buf)
void SCSIBR::FS_NFiles(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -662,7 +659,7 @@ void FASTCALL SCSIBR::FS_NFiles(BYTE *buf)
// $49 - File Creation
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Create(BYTE *buf)
void SCSIBR::FS_Create(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -716,7 +713,7 @@ void FASTCALL SCSIBR::FS_Create(BYTE *buf)
// $4A - Open File
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Open(BYTE *buf)
void SCSIBR::FS_Open(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -762,7 +759,7 @@ void FASTCALL SCSIBR::FS_Open(BYTE *buf)
// $4B - Close File
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Close(BYTE *buf)
void SCSIBR::FS_Close(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -805,7 +802,7 @@ void FASTCALL SCSIBR::FS_Close(BYTE *buf)
// $4C - Read File
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Read(BYTE *buf)
void SCSIBR::FS_Read(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -850,7 +847,7 @@ void FASTCALL SCSIBR::FS_Read(BYTE *buf)
// $4D - Write file
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Write(BYTE *buf)
void SCSIBR::FS_Write(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -893,7 +890,7 @@ void FASTCALL SCSIBR::FS_Write(BYTE *buf)
// $4E - Seek file
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Seek(BYTE *buf)
void SCSIBR::FS_Seek(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -940,7 +937,7 @@ void FASTCALL SCSIBR::FS_Seek(BYTE *buf)
// $4F - File Timestamp Get / Set
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_TimeStamp(BYTE *buf)
void SCSIBR::FS_TimeStamp(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -987,7 +984,7 @@ void FASTCALL SCSIBR::FS_TimeStamp(BYTE *buf)
// $50 - Get Capacity
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_GetCapacity(BYTE *buf)
void SCSIBR::FS_GetCapacity(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1014,7 +1011,7 @@ void FASTCALL SCSIBR::FS_GetCapacity(BYTE *buf)
// $51 - Drive status inspection/control
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_CtrlDrive(BYTE *buf)
void SCSIBR::FS_CtrlDrive(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1038,7 +1035,7 @@ void FASTCALL SCSIBR::FS_CtrlDrive(BYTE *buf)
// $52 - Get DPB
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_GetDPB(BYTE *buf)
void SCSIBR::FS_GetDPB(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1067,7 +1064,7 @@ void FASTCALL SCSIBR::FS_GetDPB(BYTE *buf)
// $53 - Read Sector
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_DiskRead(BYTE *buf)
void SCSIBR::FS_DiskRead(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1094,7 +1091,7 @@ void FASTCALL SCSIBR::FS_DiskRead(BYTE *buf)
// $54 - Write Sector
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_DiskWrite(BYTE *buf)
void SCSIBR::FS_DiskWrite(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1112,7 +1109,7 @@ void FASTCALL SCSIBR::FS_DiskWrite(BYTE *buf)
// $55 - IOCTRL
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Ioctrl(BYTE *buf)
void SCSIBR::FS_Ioctrl(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1159,7 +1156,7 @@ void FASTCALL SCSIBR::FS_Ioctrl(BYTE *buf)
// $56 - Flush
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Flush(BYTE *buf)
void SCSIBR::FS_Flush(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1177,7 +1174,7 @@ void FASTCALL SCSIBR::FS_Flush(BYTE *buf)
// $57 - Check Media
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_CheckMedia(BYTE *buf)
void SCSIBR::FS_CheckMedia(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1195,7 +1192,7 @@ void FASTCALL SCSIBR::FS_CheckMedia(BYTE *buf)
// $58 - Lock
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::FS_Lock(BYTE *buf)
void SCSIBR::FS_Lock(BYTE *buf)
{
ASSERT(fs);
ASSERT(buf);
@ -1213,7 +1210,7 @@ void FASTCALL SCSIBR::FS_Lock(BYTE *buf)
// Read Filesystem (result code)
//
//---------------------------------------------------------------------------
int FASTCALL SCSIBR::ReadFsResult(BYTE *buf)
int SCSIBR::ReadFsResult(BYTE *buf)
{
ASSERT(buf);
@ -1227,7 +1224,7 @@ int FASTCALL SCSIBR::ReadFsResult(BYTE *buf)
// Read Filesystem (return data)
//
//---------------------------------------------------------------------------
int FASTCALL SCSIBR::ReadFsOut(BYTE *buf)
int SCSIBR::ReadFsOut(BYTE *buf)
{
ASSERT(buf);
@ -1240,7 +1237,7 @@ int FASTCALL SCSIBR::ReadFsOut(BYTE *buf)
// Read file system (return option data)
//
//---------------------------------------------------------------------------
int FASTCALL SCSIBR::ReadFsOpt(BYTE *buf)
int SCSIBR::ReadFsOpt(BYTE *buf)
{
ASSERT(buf);
@ -1253,7 +1250,7 @@ int FASTCALL SCSIBR::ReadFsOpt(BYTE *buf)
// Write Filesystem
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::WriteFs(int func, BYTE *buf)
void SCSIBR::WriteFs(int func, BYTE *buf)
{
ASSERT(buf);
@ -1297,7 +1294,7 @@ void FASTCALL SCSIBR::WriteFs(int func, BYTE *buf)
// File system write (input option data)
//
//---------------------------------------------------------------------------
void FASTCALL SCSIBR::WriteFsOpt(BYTE *buf, int num)
void SCSIBR::WriteFsOpt(BYTE *buf, int num)
{
memcpy(fsopt, buf, num);
}

78
src/raspberrypi/devices/scsi_host_bridge.h
View File

@ -36,17 +36,17 @@ public:
virtual ~SCSIBR(); // Destructor
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
BOOL FASTCALL TestUnitReady(const DWORD *cdb); // TEST UNIT READY command
int FASTCALL GetMessage10(const DWORD *cdb, BYTE *buf); // GET MESSAGE10 command
BOOL FASTCALL SendMessage10(const DWORD *cdb, BYTE *buf); // SEND MESSAGE10 command
int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
BOOL TestUnitReady(const DWORD *cdb); // TEST UNIT READY command
int GetMessage10(const DWORD *cdb, BYTE *buf); // GET MESSAGE10 command
BOOL SendMessage10(const DWORD *cdb, BYTE *buf); // SEND MESSAGE10 command
private:
int FASTCALL GetMacAddr(BYTE *buf); // Get MAC address
void FASTCALL SetMacAddr(BYTE *buf); // Set MAC address
void FASTCALL ReceivePacket(); // Receive a packet
void FASTCALL GetPacketBuf(BYTE *buf); // Get a packet
void FASTCALL SendPacket(BYTE *buf, int len); // Send a packet
int GetMacAddr(BYTE *buf); // Get MAC address
void SetMacAddr(BYTE *buf); // Set MAC address
void ReceivePacket(); // Receive a packet
void GetPacketBuf(BYTE *buf); // Get a packet
void SendPacket(BYTE *buf, int len); // Send a packet
CTapDriver *tap; // TAP driver
BOOL m_bTapEnable; // TAP valid flag
@ -55,38 +55,38 @@ private:
BYTE packet_buf[0x1000]; // Receive packet buffer
BOOL packet_enable; // Received packet valid
int FASTCALL ReadFsResult(BYTE *buf); // Read filesystem (result code)
int FASTCALL ReadFsOut(BYTE *buf); // Read filesystem (return data)
int FASTCALL ReadFsOpt(BYTE *buf); // Read file system (optional data)
void FASTCALL WriteFs(int func, BYTE *buf); // File system write (execute)
void FASTCALL WriteFsOpt(BYTE *buf, int len); // File system write (optional data)
int ReadFsResult(BYTE *buf); // Read filesystem (result code)
int ReadFsOut(BYTE *buf); // Read filesystem (return data)
int ReadFsOpt(BYTE *buf); // Read file system (optional data)
void WriteFs(int func, BYTE *buf); // File system write (execute)
void WriteFsOpt(BYTE *buf, int len); // File system write (optional data)
// Command handlers
void FASTCALL FS_InitDevice(BYTE *buf); // $40 - boot
void FASTCALL FS_CheckDir(BYTE *buf); // $41 - directory check
void FASTCALL FS_MakeDir(BYTE *buf); // $42 - create directory
void FASTCALL FS_RemoveDir(BYTE *buf); // $43 - delete directory
void FASTCALL FS_Rename(BYTE *buf); // $44 - change filename
void FASTCALL FS_Delete(BYTE *buf); // $45 - delete file
void FASTCALL FS_Attribute(BYTE *buf); // $46 - get/set file attributes
void FASTCALL FS_Files(BYTE *buf); // $47 - file search
void FASTCALL FS_NFiles(BYTE *buf); // $48 - find next file
void FASTCALL FS_Create(BYTE *buf); // $49 - create file
void FASTCALL FS_Open(BYTE *buf); // $4A - open file
void FASTCALL FS_Close(BYTE *buf); // $4B - close file
void FASTCALL FS_Read(BYTE *buf); // $4C - read file
void FASTCALL FS_Write(BYTE *buf); // $4D - write file
void FASTCALL FS_Seek(BYTE *buf); // $4E - seek file
void FASTCALL FS_TimeStamp(BYTE *buf); // $4F - get/set file time
void FASTCALL FS_GetCapacity(BYTE *buf); // $50 - get capacity
void FASTCALL FS_CtrlDrive(BYTE *buf); // $51 - drive status check/control
void FASTCALL FS_GetDPB(BYTE *buf); // $52 - get DPB
void FASTCALL FS_DiskRead(BYTE *buf); // $53 - read sector
void FASTCALL FS_DiskWrite(BYTE *buf); // $54 - write sector
void FASTCALL FS_Ioctrl(BYTE *buf); // $55 - IOCTRL
void FASTCALL FS_Flush(BYTE *buf); // $56 - flush cache
void FASTCALL FS_CheckMedia(BYTE *buf); // $57 - check media
void FASTCALL FS_Lock(BYTE *buf); // $58 - get exclusive control
void FS_InitDevice(BYTE *buf); // $40 - boot
void FS_CheckDir(BYTE *buf); // $41 - directory check
void FS_MakeDir(BYTE *buf); // $42 - create directory
void FS_RemoveDir(BYTE *buf); // $43 - delete directory
void FS_Rename(BYTE *buf); // $44 - change filename
void FS_Delete(BYTE *buf); // $45 - delete file
void FS_Attribute(BYTE *buf); // $46 - get/set file attributes
void FS_Files(BYTE *buf); // $47 - file search
void FS_NFiles(BYTE *buf); // $48 - find next file
void FS_Create(BYTE *buf); // $49 - create file
void FS_Open(BYTE *buf); // $4A - open file
void FS_Close(BYTE *buf); // $4B - close file
void FS_Read(BYTE *buf); // $4C - read file
void FS_Write(BYTE *buf); // $4D - write file
void FS_Seek(BYTE *buf); // $4E - seek file
void FS_TimeStamp(BYTE *buf); // $4F - get/set file time
void FS_GetCapacity(BYTE *buf); // $50 - get capacity
void FS_CtrlDrive(BYTE *buf); // $51 - drive status check/control
void FS_GetDPB(BYTE *buf); // $52 - get DPB
void FS_DiskRead(BYTE *buf); // $53 - read sector
void FS_DiskWrite(BYTE *buf); // $54 - write sector
void FS_Ioctrl(BYTE *buf); // $55 - IOCTRL
void FS_Flush(BYTE *buf); // $56 - flush cache
void FS_CheckMedia(BYTE *buf); // $57 - check media
void FS_Lock(BYTE *buf); // $58 - get exclusive control
CFileSys *fs; // File system accessor
DWORD fsresult; // File system access result code

63
src/raspberrypi/devices/scsicd.cpp
View File

@ -61,7 +61,7 @@ CDTrack::~CDTrack()
// Init
//
//---------------------------------------------------------------------------
BOOL FASTCALL CDTrack::Init(int track, DWORD first, DWORD last)
BOOL CDTrack::Init(int track, DWORD first, DWORD last)
{
ASSERT(!valid);
ASSERT(track >= 1);
@ -83,7 +83,7 @@ BOOL FASTCALL CDTrack::Init(int track, DWORD first, DWORD last)
// Set Path
//
//---------------------------------------------------------------------------
void FASTCALL CDTrack::SetPath(BOOL cdda, const Filepath& path)
void CDTrack::SetPath(BOOL cdda, const Filepath& path)
{
ASSERT(valid);
@ -99,7 +99,7 @@ void FASTCALL CDTrack::SetPath(BOOL cdda, const Filepath& path)
// Get Path
//
//---------------------------------------------------------------------------
void FASTCALL CDTrack::GetPath(Filepath& path) const
void CDTrack::GetPath(Filepath& path) const
{
ASSERT(valid);
@ -112,7 +112,7 @@ void FASTCALL CDTrack::GetPath(Filepath& path) const
// Add Index
//
//---------------------------------------------------------------------------
void FASTCALL CDTrack::AddIndex(int index, DWORD lba)
void CDTrack::AddIndex(int index, DWORD lba)
{
ASSERT(valid);
ASSERT(index > 0);
@ -128,7 +128,7 @@ void FASTCALL CDTrack::AddIndex(int index, DWORD lba)
// Gets the start of LBA
//
//---------------------------------------------------------------------------
DWORD FASTCALL CDTrack::GetFirst() const
DWORD CDTrack::GetFirst() const
{
ASSERT(valid);
ASSERT(first_lba < last_lba);
@ -141,7 +141,7 @@ DWORD FASTCALL CDTrack::GetFirst() const
// Get the end of LBA
//
//---------------------------------------------------------------------------
DWORD FASTCALL CDTrack::GetLast() const
DWORD CDTrack::GetLast() const
{
ASSERT(valid);
ASSERT(first_lba < last_lba);
@ -154,7 +154,7 @@ DWORD FASTCALL CDTrack::GetLast() const
// Get the number of blocks
//
//---------------------------------------------------------------------------
DWORD FASTCALL CDTrack::GetBlocks() const
DWORD CDTrack::GetBlocks() const
{
ASSERT(valid);
ASSERT(first_lba < last_lba);
@ -168,7 +168,7 @@ DWORD FASTCALL CDTrack::GetBlocks() const
// Get track number
//
//---------------------------------------------------------------------------
int FASTCALL CDTrack::GetTrackNo() const
int CDTrack::GetTrackNo() const
{
ASSERT(valid);
ASSERT(track_no >= 1);
@ -181,7 +181,7 @@ int FASTCALL CDTrack::GetTrackNo() const
// Is valid block
//
//---------------------------------------------------------------------------
BOOL FASTCALL CDTrack::IsValid(DWORD lba) const
BOOL CDTrack::IsValid(DWORD lba) const
{
// FALSE if the track itself is invalid
if (!valid) {
@ -207,7 +207,7 @@ BOOL FASTCALL CDTrack::IsValid(DWORD lba) const
// Is audio track
//
//---------------------------------------------------------------------------
BOOL FASTCALL CDTrack::IsAudio() const
BOOL CDTrack::IsAudio() const
{
ASSERT(valid);
@ -249,13 +249,8 @@ CDDABuf::~CDDABuf()
// Constructor
//
//---------------------------------------------------------------------------
SCSICD::SCSICD() : Disk()
SCSICD::SCSICD() : Disk("SCCD")
{
int i;
// SCSI CD-ROM
disk.id = "SCCD";
// removable, write protected
disk.removable = TRUE;
disk.writep = TRUE;
@ -267,7 +262,7 @@ SCSICD::SCSICD() : Disk()
frame = 0;
// Track initialization
for (i = 0; i < TrackMax; i++) {
for (int i = 0; i < TrackMax; i++) {
track[i] = NULL;
}
tracks = 0;
@ -291,7 +286,7 @@ SCSICD::~SCSICD()
// Open
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::Open(const Filepath& path, BOOL attn)
BOOL SCSICD::Open(const Filepath& path, BOOL attn)
{
Fileio fio;
off64_t size;
@ -372,7 +367,7 @@ BOOL FASTCALL SCSICD::Open(const Filepath& path, BOOL attn)
// Open (CUE)
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::OpenCue(const Filepath& /*path*/)
BOOL SCSICD::OpenCue(const Filepath& /*path*/)
{
// Always fail
return FALSE;
@ -380,10 +375,10 @@ BOOL FASTCALL SCSICD::OpenCue(const Filepath& /*path*/)
//---------------------------------------------------------------------------
//
// オープン(ISO)
// Open (ISO)
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::OpenIso(const Filepath& path)
BOOL SCSICD::OpenIso(const Filepath& path)
{
BYTE header[12];
BYTE sync[12];
@ -472,7 +467,7 @@ BOOL FASTCALL SCSICD::OpenIso(const Filepath& path)
// Open (Physical)
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::OpenPhysical(const Filepath& path)
BOOL SCSICD::OpenPhysical(const Filepath& path)
{
// Open as read-only
Fileio fio;
@ -518,7 +513,7 @@ BOOL FASTCALL SCSICD::OpenPhysical(const Filepath& path)
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSICD::Inquiry(
int SCSICD::Inquiry(
const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor)
{
char rev[32];
@ -606,7 +601,7 @@ int FASTCALL SCSICD::Inquiry(
// READ
//
//---------------------------------------------------------------------------
int FASTCALL SCSICD::Read(const DWORD *cdb, BYTE *buf, DWORD block)
int SCSICD::Read(const DWORD *cdb, BYTE *buf, DWORD block)
{
Filepath path;
@ -656,7 +651,7 @@ int FASTCALL SCSICD::Read(const DWORD *cdb, BYTE *buf, DWORD block)
// READ TOC
//
//---------------------------------------------------------------------------
int FASTCALL SCSICD::ReadToc(const DWORD *cdb, BYTE *buf)
int SCSICD::ReadToc(const DWORD *cdb, BYTE *buf)
{
int loop;
int i;
@ -781,7 +776,7 @@ int FASTCALL SCSICD::ReadToc(const DWORD *cdb, BYTE *buf)
// PLAY AUDIO
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::PlayAudio(const DWORD* /*cdb*/)
BOOL SCSICD::PlayAudio(const DWORD* /*cdb*/)
{
disk.code = DISK_INVALIDCDB;
return FALSE;
@ -792,7 +787,7 @@ BOOL FASTCALL SCSICD::PlayAudio(const DWORD* /*cdb*/)
// PLAY AUDIO MSF
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::PlayAudioMSF(const DWORD* /*cdb*/)
BOOL SCSICD::PlayAudioMSF(const DWORD* /*cdb*/)
{
disk.code = DISK_INVALIDCDB;
return FALSE;
@ -803,7 +798,7 @@ BOOL FASTCALL SCSICD::PlayAudioMSF(const DWORD* /*cdb*/)
// PLAY AUDIO TRACK
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::PlayAudioTrack(const DWORD* /*cdb*/)
BOOL SCSICD::PlayAudioTrack(const DWORD* /*cdb*/)
{
disk.code = DISK_INVALIDCDB;
return FALSE;
@ -814,7 +809,7 @@ BOOL FASTCALL SCSICD::PlayAudioTrack(const DWORD* /*cdb*/)
// LBA→MSF Conversion
//
//---------------------------------------------------------------------------
void FASTCALL SCSICD::LBAtoMSF(DWORD lba, BYTE *msf) const
void SCSICD::LBAtoMSF(DWORD lba, BYTE *msf) const
{
// 75 and 75*60 get the remainder
DWORD m = lba / (75 * 60);
@ -844,7 +839,7 @@ void FASTCALL SCSICD::LBAtoMSF(DWORD lba, BYTE *msf) const
// MSF→LBA Conversion
//
//---------------------------------------------------------------------------
DWORD FASTCALL SCSICD::MSFtoLBA(const BYTE *msf) const
DWORD SCSICD::MSFtoLBA(const BYTE *msf) const
{
ASSERT(msf[2] < 60);
ASSERT(msf[3] < 75);
@ -867,7 +862,7 @@ DWORD FASTCALL SCSICD::MSFtoLBA(const BYTE *msf) const
// Clear Track
//
//---------------------------------------------------------------------------
void FASTCALL SCSICD::ClearTrack()
void SCSICD::ClearTrack()
{
// delete the track object
for (int i = 0; i < TrackMax; i++) {
@ -891,7 +886,7 @@ void FASTCALL SCSICD::ClearTrack()
// * Returns -1 if not found
//
//---------------------------------------------------------------------------
int FASTCALL SCSICD::SearchTrack(DWORD lba) const
int SCSICD::SearchTrack(DWORD lba) const
{
// Track loop
for (int i = 0; i < tracks; i++) {
@ -911,7 +906,7 @@ int FASTCALL SCSICD::SearchTrack(DWORD lba) const
// Next Frame
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSICD::NextFrame()
BOOL SCSICD::NextFrame()
{
ASSERT((frame >= 0) && (frame < 75));
@ -931,7 +926,7 @@ BOOL FASTCALL SCSICD::NextFrame()
// Get CD-DA buffer
//
//---------------------------------------------------------------------------
void FASTCALL SCSICD::GetBuf(
void SCSICD::GetBuf(
DWORD* /*buffer*/, int /*samples*/, DWORD /*rate*/)
{
// TODO Missing implementation?

68
src/raspberrypi/devices/scsicd.h
View File

@ -38,18 +38,18 @@ public:
// Basic Functions
CDTrack(SCSICD *scsicd); // Constructor
virtual ~CDTrack(); // Destructor
BOOL FASTCALL Init(int track, DWORD first, DWORD last); // Initialization
BOOL Init(int track, DWORD first, DWORD last); // Initialization
// Properties
void FASTCALL SetPath(BOOL cdda, const Filepath& path); // Set the path
void FASTCALL GetPath(Filepath& path) const; // Get the path
void FASTCALL AddIndex(int index, DWORD lba); // Add index
DWORD FASTCALL GetFirst() const; // Get the start LBA
DWORD FASTCALL GetLast() const; // Get the last LBA
DWORD FASTCALL GetBlocks() const; // Get the number of blocks
int FASTCALL GetTrackNo() const; // Get the track number
BOOL FASTCALL IsValid(DWORD lba) const; // Is this a valid LBA?
BOOL FASTCALL IsAudio() const; // Is this an audio track?
void SetPath(BOOL cdda, const Filepath& path); // Set the path
void GetPath(Filepath& path) const; // Get the path
void AddIndex(int index, DWORD lba); // Add index
DWORD GetFirst() const; // Get the start LBA
DWORD GetLast() const; // Get the last LBA
DWORD GetBlocks() const; // Get the number of blocks
int GetTrackNo() const; // Get the track number
BOOL IsValid(DWORD lba) const; // Is this a valid LBA?
BOOL IsAudio() const; // Is this an audio track?
private:
SCSICD *cdrom; // Parent device
@ -75,16 +75,16 @@ public:
virtual ~CDDABuf(); // Destructor
#if 0
BOOL Init(); // Initialization
BOOL FASTCALL Load(const Filepath& path); // Load
BOOL FASTCALL Save(const Filepath& path); // Save
BOOL Load(const Filepath& path); // Load
BOOL Save(const Filepath& path); // Save
// API
void FASTCALL Clear(); // Clear the buffer
BOOL FASTCALL Open(Filepath& path); // File specification
BOOL FASTCALL GetBuf(DWORD *buffer, int frames); // Get the buffer
BOOL FASTCALL IsValid(); // Check if Valid
BOOL FASTCALL ReadReq(); // Read Request
BOOL FASTCALL IsEnd() const; // Finish check
void Clear(); // Clear the buffer
BOOL Open(Filepath& path); // File specification
BOOL GetBuf(DWORD *buffer, int frames); // Get the buffer
BOOL IsValid(); // Check if Valid
BOOL ReadReq(); // Read Request
BOOL IsEnd() const; // Finish check
private:
Filepath wavepath; // Wave path
@ -114,34 +114,34 @@ public:
// Basic Functions
SCSICD(); // Constructor
virtual ~SCSICD(); // Destructor
BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); // Open
BOOL Open(const Filepath& path, BOOL attn = TRUE); // Open
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
int FASTCALL Read(const DWORD *cdb, BYTE *buf, DWORD block) override; // READ command
int FASTCALL ReadToc(const DWORD *cdb, BYTE *buf); // READ TOC command
BOOL FASTCALL PlayAudio(const DWORD *cdb); // PLAY AUDIO command
BOOL FASTCALL PlayAudioMSF(const DWORD *cdb); // PLAY AUDIO MSF command
BOOL FASTCALL PlayAudioTrack(const DWORD *cdb); // PLAY AUDIO TRACK command
int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
int Read(const DWORD *cdb, BYTE *buf, DWORD block) override; // READ command
int ReadToc(const DWORD *cdb, BYTE *buf); // READ TOC command
BOOL PlayAudio(const DWORD *cdb); // PLAY AUDIO command
BOOL PlayAudioMSF(const DWORD *cdb); // PLAY AUDIO MSF command
BOOL PlayAudioTrack(const DWORD *cdb); // PLAY AUDIO TRACK command
// CD-DA
BOOL FASTCALL NextFrame(); // Frame notification
void FASTCALL GetBuf(DWORD *buffer, int samples, DWORD rate); // Get CD-DA buffer
BOOL NextFrame(); // Frame notification
void GetBuf(DWORD *buffer, int samples, DWORD rate); // Get CD-DA buffer
// LBA-MSF変換
void FASTCALL LBAtoMSF(DWORD lba, BYTE *msf) const; // LBA→MSF conversion
DWORD FASTCALL MSFtoLBA(const BYTE *msf) const; // MSF→LBA conversion
void LBAtoMSF(DWORD lba, BYTE *msf) const; // LBA→MSF conversion
DWORD MSFtoLBA(const BYTE *msf) const; // MSF→LBA conversion
private:
// Open
BOOL FASTCALL OpenCue(const Filepath& path); // Open(CUE)
BOOL FASTCALL OpenIso(const Filepath& path); // Open(ISO)
BOOL FASTCALL OpenPhysical(const Filepath& path); // Open(Physical)
BOOL OpenCue(const Filepath& path); // Open(CUE)
BOOL OpenIso(const Filepath& path); // Open(ISO)
BOOL OpenPhysical(const Filepath& path); // Open(Physical)
BOOL rawfile; // RAW flag
// Track management
void FASTCALL ClearTrack(); // Clear the track
int FASTCALL SearchTrack(DWORD lba) const; // Track search
void ClearTrack(); // Clear the track
int SearchTrack(DWORD lba) const; // Track search
CDTrack* track[TrackMax]; // Track opbject references
int tracks; // Effective number of track objects
int dataindex; // Current data track

12
src/raspberrypi/devices/scsihd.cpp
View File

@ -28,10 +28,8 @@
// Constructor
//
//---------------------------------------------------------------------------
SCSIHD::SCSIHD() : Disk()
SCSIHD::SCSIHD() : Disk("SCHD")
{
// SCSI Hard Disk
disk.id = "SCHD";
}
//---------------------------------------------------------------------------
@ -39,7 +37,7 @@ SCSIHD::SCSIHD() : Disk()
// Reset
//
//---------------------------------------------------------------------------
void FASTCALL SCSIHD::Reset()
void SCSIHD::Reset()
{
// Unlock and release attention
disk.lock = FALSE;
@ -55,7 +53,7 @@ void FASTCALL SCSIHD::Reset()
// Open
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIHD::Open(const Filepath& path, BOOL /*attn*/)
BOOL SCSIHD::Open(const Filepath& path, BOOL /*attn*/)
{
ASSERT(!disk.ready);
@ -93,7 +91,7 @@ BOOL FASTCALL SCSIHD::Open(const Filepath& path, BOOL /*attn*/)
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD:: Inquiry(
int SCSIHD:: Inquiry(
const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor)
{
char vendor[32];
@ -181,7 +179,7 @@ int FASTCALL SCSIHD:: Inquiry(
// *Not affected by disk.code
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIHD::ModeSelect(const DWORD *cdb, const BYTE *buf, int length)
BOOL SCSIHD::ModeSelect(const DWORD *cdb, const BYTE *buf, int length)
{
BYTE page;
int size;

8
src/raspberrypi/devices/scsihd.h
View File

@ -29,10 +29,10 @@ class SCSIHD : public Disk
public:
// Basic Functions
SCSIHD(); // Constructor
void FASTCALL Reset(); // Reset
BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); // Open
void Reset(); // Reset
BOOL Open(const Filepath& path, BOOL attn = TRUE); // Open
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
BOOL FASTCALL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); // MODE SELECT(6) command
int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
BOOL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); // MODE SELECT(6) command
};

4
src/raspberrypi/devices/scsihd_apple.cpp
View File

@ -36,7 +36,7 @@ SCSIHD_APPLE::SCSIHD_APPLE() : SCSIHD()
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD_APPLE::Inquiry(
int SCSIHD_APPLE::Inquiry(
const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor)
{
char vendor[32];
@ -66,7 +66,7 @@ int FASTCALL SCSIHD_APPLE::Inquiry(
// Add Vendor special page
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD_APPLE::AddVendor(int page, BOOL change, BYTE *buf)
int SCSIHD_APPLE::AddVendor(int page, BOOL change, BYTE *buf)
{
ASSERT(buf);

4
src/raspberrypi/devices/scsihd_apple.h
View File

@ -28,8 +28,8 @@ public:
// Basic Functions
SCSIHD_APPLE(); // Constructor
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
// Internal processing
int FASTCALL AddVendor(int page, BOOL change, BYTE *buf); // Add vendor special page
int AddVendor(int page, BOOL change, BYTE *buf); // Add vendor special page
};

67
src/raspberrypi/devices/scsihd_nec.cpp
View File

@ -30,7 +30,7 @@
//---------------------------------------------------------------------------
SCSIHD_NEC::SCSIHD_NEC() : SCSIHD()
{
// ワーク初期化
// Work initialization
cylinders = 0;
heads = 0;
sectors = 0;
@ -41,7 +41,7 @@ SCSIHD_NEC::SCSIHD_NEC() : SCSIHD()
//---------------------------------------------------------------------------
//
// リトルエンディアンと想定したワードを取り出す
// Extract words that are supposed to be little endian
//
//---------------------------------------------------------------------------
static inline WORD getWordLE(const BYTE *b)
@ -51,7 +51,7 @@ static inline WORD getWordLE(const BYTE *b)
//---------------------------------------------------------------------------
//
// リトルエンディアンと想定したロングワードを取り出す
// Extract longwords assumed to be little endian
//
//---------------------------------------------------------------------------
static inline DWORD getDwordLE(const BYTE *b)
@ -62,10 +62,10 @@ static inline DWORD getDwordLE(const BYTE *b)
//---------------------------------------------------------------------------
//
// オープン
// Open
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
BOOL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
{
Fileio fio;
off64_t size;
@ -82,7 +82,7 @@ BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
// Get file size
size = fio.GetFileSize();
// ヘッダー読み込み
// Read header
if (size >= (off64_t)sizeof(hdr)) {
if (!fio.Read(hdr, sizeof(hdr))) {
fio.Close();
@ -91,25 +91,24 @@ BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
}
fio.Close();
// 512バイト単位であること
// Must be in 512 byte units
if (size & 0x1ff) {
return FALSE;
}
// 10MB以上
// 10MB or more
if (size < 0x9f5400) {
return FALSE;
}
// xm6iに準じて2TB
// よく似たものが wxw/wxw_cfg.cpp にもある
// 2TB according to xm6i
if (size > 2LL * 1024 * 1024 * 1024 * 1024) {
return FALSE;
}
// 拡張子別にパラメータを決定
// Determine parameters by extension
ext = path.GetFileExt();
if (xstrcasecmp(ext, _T(".HDN")) == 0) {
// デフォルト設定としてセクタサイズ512,セクタ数25,ヘッド数8を想定
// Assuming sector size 512, number of sectors 25, number of heads 8 as default settings
imgoffset = 0;
imgsize = size;
sectorsize = 512;
@ -135,17 +134,17 @@ BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
imgsize = (off64_t)cylinders * heads * sectors * sectorsize;
}
// セクタサイズは256または512をサポート
// Supports 256 or 512 sector sizes
if (sectorsize != 256 && sectorsize != 512) {
return FALSE;
}
// イメージサイズの整合性チェック
// Image size consistency check
if (imgoffset + imgsize > size || (imgsize % sectorsize != 0)) {
return FALSE;
}
// セクタサイズ
// Sector size
for(disk.size = 16; disk.size > 0; --(disk.size)) {
if ((1 << disk.size) == sectorsize)
break;
@ -154,7 +153,7 @@ BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
return FALSE;
}
// ブロック数
// Number of blocks
disk.blocks = (DWORD)(imgsize >> disk.size);
disk.imgoffset = imgoffset;
@ -167,20 +166,20 @@ BOOL FASTCALL SCSIHD_NEC::Open(const Filepath& path, BOOL /*attn*/)
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD_NEC::Inquiry(
int SCSIHD_NEC::Inquiry(
const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor)
{
int size;
// 基底クラス
// Base class
size = SCSIHD::Inquiry(cdb, buf, major, minor);
// 基底クラスでエラーなら終了
// Exit if there is an error in the base class
if (size == 0) {
return 0;
}
// SCSI1相当に変更
// Changed to equivalent to SCSI-1
buf[2] = 0x01;
buf[3] = 0x01;
@ -194,10 +193,10 @@ int FASTCALL SCSIHD_NEC::Inquiry(
//---------------------------------------------------------------------------
//
// エラーページ追加
// Error page added
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD_NEC::AddError(BOOL change, BYTE *buf)
int SCSIHD_NEC::AddError(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -210,16 +209,16 @@ int FASTCALL SCSIHD_NEC::AddError(BOOL change, BYTE *buf)
return 8;
}
// リトライカウントは0、リミットタイムは装置内部のデフォルト値を使用
// The retry count is 0, and the limit time uses the default value inside the device.
return 8;
}
//---------------------------------------------------------------------------
//
// フォーマットページ追加
// Format page added
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD_NEC::AddFormat(BOOL change, BYTE *buf)
int SCSIHD_NEC::AddFormat(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -227,7 +226,7 @@ int FASTCALL SCSIHD_NEC::AddFormat(BOOL change, BYTE *buf)
buf[0] = 0x80 | 0x03;
buf[1] = 0x16;
// 物理セクタのバイト数は変更可能に見せる(実際には変更できないが)
// Make the number of bytes in the physical sector appear mutable (although it cannot actually be)
if (change) {
buf[0xc] = 0xff;
buf[0xd] = 0xff;
@ -235,21 +234,21 @@ int FASTCALL SCSIHD_NEC::AddFormat(BOOL change, BYTE *buf)
}
if (disk.ready) {
// 1ゾーンのトラック数を設定(PC-9801-55はこの値を見ているようだ)
// Set the number of tracks in one zone (PC-9801-55 seems to see this value)
buf[0x2] = (BYTE)(heads >> 8);
buf[0x3] = (BYTE)heads;
// 1トラックのセクタ数を設定
// Set the number of sectors per track
buf[0xa] = (BYTE)(sectors >> 8);
buf[0xb] = (BYTE)sectors;
// 物理セクタのバイト数を設定
// Set the number of bytes in the physical sector
int size = 1 << disk.size;
buf[0xc] = (BYTE)(size >> 8);
buf[0xd] = (BYTE)size;
}
// リムーバブル属性を設定(昔の名残)
// Set removable attributes (remains of the old days)
if (disk.removable) {
buf[20] = 0x20;
}
@ -259,10 +258,10 @@ int FASTCALL SCSIHD_NEC::AddFormat(BOOL change, BYTE *buf)
//---------------------------------------------------------------------------
//
// ドライブページ追加
// Drive page added
//
//---------------------------------------------------------------------------
int FASTCALL SCSIHD_NEC::AddDrive(BOOL change, BYTE *buf)
int SCSIHD_NEC::AddDrive(BOOL change, BYTE *buf)
{
ASSERT(buf);
@ -276,12 +275,12 @@ int FASTCALL SCSIHD_NEC::AddDrive(BOOL change, BYTE *buf)
}
if (disk.ready) {
// シリンダ数を設定
// Set the number of cylinders
buf[0x2] = (BYTE)(cylinders >> 16);
buf[0x3] = (BYTE)(cylinders >> 8);
buf[0x4] = (BYTE)cylinders;
// ヘッド数を設定
// Set the number of heads
buf[0x5] = (BYTE)heads;
}

10
src/raspberrypi/devices/scsihd_nec.h
View File

@ -27,15 +27,15 @@ class SCSIHD_NEC : public SCSIHD
public:
// Basic Functions
SCSIHD_NEC(); // Constructor
BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); // Open
BOOL Open(const Filepath& path, BOOL attn = TRUE); // Open
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
// Internal processing
int FASTCALL AddError(BOOL change, BYTE *buf); // Add error
int FASTCALL AddFormat(BOOL change, BYTE *buf); // Add format
int FASTCALL AddDrive(BOOL change, BYTE *buf); // Add drive
int AddError(BOOL change, BYTE *buf); // Add error
int AddFormat(BOOL change, BYTE *buf); // Add format
int AddDrive(BOOL change, BYTE *buf); // Add drive
private:
int cylinders; // Number of cylinders

15
src/raspberrypi/devices/scsimo.cpp
View File

@ -29,11 +29,8 @@
// Constructor
//
//---------------------------------------------------------------------------
SCSIMO::SCSIMO() : Disk()
SCSIMO::SCSIMO() : Disk("SCMO")
{
// SCSI magneto-optical disk
disk.id = "SCMO";
// Set as removable
disk.removable = TRUE;
}
@ -43,7 +40,7 @@ SCSIMO::SCSIMO() : Disk()
// Open
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIMO::Open(const Filepath& path, BOOL attn)
BOOL SCSIMO::Open(const Filepath& path, BOOL attn)
{
ASSERT(!disk.ready);
@ -103,7 +100,7 @@ BOOL FASTCALL SCSIMO::Open(const Filepath& path, BOOL attn)
// INQUIRY
//
//---------------------------------------------------------------------------
int FASTCALL SCSIMO::Inquiry(
int SCSIMO::Inquiry(
const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor)
{
int size;
@ -119,7 +116,7 @@ int FASTCALL SCSIMO::Inquiry(
return FALSE;
}
// 基本データ
// Basic data
// buf[0] ... Optical Memory Device
// buf[1] ... Removable
// buf[2] ... SCSI-2 compliant command system
@ -171,7 +168,7 @@ int FASTCALL SCSIMO::Inquiry(
// *Not affected by disk.code
//
//---------------------------------------------------------------------------
BOOL FASTCALL SCSIMO::ModeSelect(const DWORD *cdb, const BYTE *buf, int length)
BOOL SCSIMO::ModeSelect(const DWORD *cdb, const BYTE *buf, int length)
{
int page;
int size;
@ -240,7 +237,7 @@ BOOL FASTCALL SCSIMO::ModeSelect(const DWORD *cdb, const BYTE *buf, int length)
// Vendor Unique Format Page 20h (MO)
//
//---------------------------------------------------------------------------
int FASTCALL SCSIMO::AddVendor(int page, BOOL change, BYTE *buf)
int SCSIMO::AddVendor(int page, BOOL change, BYTE *buf)
{
ASSERT(buf);

8
src/raspberrypi/devices/scsimo.h
View File

@ -29,12 +29,12 @@ class SCSIMO : public Disk
public:
// Basic Functions
SCSIMO(); // Constructor
BOOL FASTCALL Open(const Filepath& path, BOOL attn = TRUE); // Open
BOOL Open(const Filepath& path, BOOL attn = TRUE); // Open
// commands
int FASTCALL Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
BOOL FASTCALL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); // MODE SELECT(6) command
int Inquiry(const DWORD *cdb, BYTE *buf, DWORD major, DWORD minor); // INQUIRY command
BOOL ModeSelect(const DWORD *cdb, const BYTE *buf, int length); // MODE SELECT(6) command
// Internal processing
int FASTCALL AddVendor(int page, BOOL change, BYTE *buf); // Add vendor special page
int AddVendor(int page, BOOL change, BYTE *buf); // Add vendor special page
};

26
src/raspberrypi/fileio.cpp
View File

@ -48,7 +48,7 @@ Fileio::~Fileio()
// ロード
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Load(const Filepath& path, void *buffer, int size)
BOOL Fileio::Load(const Filepath& path, void *buffer, int size)
{
ASSERT(buffer);
ASSERT(size > 0);
@ -76,7 +76,7 @@ BOOL FASTCALL Fileio::Load(const Filepath& path, void *buffer, int size)
// セーブ
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Save(const Filepath& path, void *buffer, int size)
BOOL Fileio::Save(const Filepath& path, void *buffer, int size)
{
ASSERT(buffer);
ASSERT(size > 0);
@ -104,7 +104,7 @@ BOOL FASTCALL Fileio::Save(const Filepath& path, void *buffer, int size)
// オープン
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Open(LPCTSTR fname, OpenMode mode, BOOL directIO)
BOOL Fileio::Open(LPCTSTR fname, OpenMode mode, BOOL directIO)
{
mode_t omode;
@ -166,7 +166,7 @@ BOOL FASTCALL Fileio::Open(LPCTSTR fname, OpenMode mode, BOOL directIO)
// オープン
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Open(LPCTSTR fname, OpenMode mode)
BOOL Fileio::Open(LPCTSTR fname, OpenMode mode)
{
return Open(fname, mode, FALSE);
@ -177,7 +177,7 @@ BOOL FASTCALL Fileio::Open(LPCTSTR fname, OpenMode mode)
// オープン
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Open(const Filepath& path, OpenMode mode)
BOOL Fileio::Open(const Filepath& path, OpenMode mode)
{
return Open(path.GetPath(), mode);
@ -188,7 +188,7 @@ BOOL FASTCALL Fileio::Open(const Filepath& path, OpenMode mode)
// オープン
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::OpenDIO(LPCTSTR fname, OpenMode mode)
BOOL Fileio::OpenDIO(LPCTSTR fname, OpenMode mode)
{
// O_DIRECT付きでオープン
@ -205,7 +205,7 @@ BOOL FASTCALL Fileio::OpenDIO(LPCTSTR fname, OpenMode mode)
// オープン
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::OpenDIO(const Filepath& path, OpenMode mode)
BOOL Fileio::OpenDIO(const Filepath& path, OpenMode mode)
{
return OpenDIO(path.GetPath(), mode);
@ -216,7 +216,7 @@ BOOL FASTCALL Fileio::OpenDIO(const Filepath& path, OpenMode mode)
// 読み込み
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Read(void *buffer, int size)
BOOL Fileio::Read(void *buffer, int size)
{
int count;
@ -238,7 +238,7 @@ BOOL FASTCALL Fileio::Read(void *buffer, int size)
// 書き込み
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Write(const void *buffer, int size)
BOOL Fileio::Write(const void *buffer, int size)
{
int count;
@ -260,7 +260,7 @@ BOOL FASTCALL Fileio::Write(const void *buffer, int size)
// シーク
//
//---------------------------------------------------------------------------
BOOL FASTCALL Fileio::Seek(off64_t offset, BOOL relative)
BOOL Fileio::Seek(off64_t offset, BOOL relative)
{
ASSERT(handle >= 0);
ASSERT(offset >= 0);
@ -282,7 +282,7 @@ BOOL FASTCALL Fileio::Seek(off64_t offset, BOOL relative)
// ファイルサイズ取得
//
//---------------------------------------------------------------------------
off64_t FASTCALL Fileio::GetFileSize()
off64_t Fileio::GetFileSize()
{
off64_t cur;
off64_t end;
@ -306,7 +306,7 @@ off64_t FASTCALL Fileio::GetFileSize()
// ファイル位置取得
//
//---------------------------------------------------------------------------
off64_t FASTCALL Fileio::GetFilePos() const
off64_t Fileio::GetFilePos() const
{
off64_t pos;
@ -323,7 +323,7 @@ off64_t FASTCALL Fileio::GetFilePos() const
// クローズ
//
//---------------------------------------------------------------------------
void FASTCALL Fileio::Close()
void Fileio::Close()
{
if (handle != -1) {

28
src/raspberrypi/fileio.h
View File

@ -48,36 +48,36 @@ public:
// コンストラクタ
virtual ~Fileio();
// デストラクタ
BOOL FASTCALL Load(const Filepath& path, void *buffer, int size);
BOOL Load(const Filepath& path, void *buffer, int size);
// ROM,RAMロード
BOOL FASTCALL Save(const Filepath& path, void *buffer, int size);
BOOL Save(const Filepath& path, void *buffer, int size);
// RAMセーブ
BOOL FASTCALL Open(LPCTSTR fname, OpenMode mode);
BOOL Open(LPCTSTR fname, OpenMode mode);
// オープン
BOOL FASTCALL Open(const Filepath& path, OpenMode mode);
BOOL Open(const Filepath& path, OpenMode mode);
// オープン
BOOL FASTCALL OpenDIO(LPCTSTR fname, OpenMode mode);
BOOL OpenDIO(LPCTSTR fname, OpenMode mode);
// オープン
BOOL FASTCALL OpenDIO(const Filepath& path, OpenMode mode);
BOOL OpenDIO(const Filepath& path, OpenMode mode);
// オープン
BOOL FASTCALL Seek(off64_t offset, BOOL relative = FALSE);
BOOL Seek(off64_t offset, BOOL relative = FALSE);
// シーク
BOOL FASTCALL Read(void *buffer, int size);
BOOL Read(void *buffer, int size);
// 読み込み
BOOL FASTCALL Write(const void *buffer, int size);
BOOL Write(const void *buffer, int size);
// 書き込み
off64_t FASTCALL GetFileSize();
off64_t GetFileSize();
// ファイルサイズ取得
off64_t FASTCALL GetFilePos() const;
off64_t GetFilePos() const;
// ファイル位置取得
void FASTCALL Close();
void Close();
// クローズ
BOOL FASTCALL IsValid() const { return (BOOL)(handle != -1); }
BOOL IsValid() const { return (BOOL)(handle != -1); }
// 有効チェック
private:
BOOL FASTCALL Open(LPCTSTR fname, OpenMode mode, BOOL directIO);
BOOL Open(LPCTSTR fname, OpenMode mode, BOOL directIO);
// オープン
int handle; // ファイルハンドル

12
src/raspberrypi/filepath.cpp
View File

@ -57,7 +57,7 @@ Filepath& Filepath::operator=(const Filepath& path)
// Clear
//
//---------------------------------------------------------------------------
void FASTCALL Filepath::Clear()
void Filepath::Clear()
{
// Clear the path and each part
@ -72,7 +72,7 @@ void FASTCALL Filepath::Clear()
// ファイル設定(ユーザ) MBCS用
//
//---------------------------------------------------------------------------
void FASTCALL Filepath::SetPath(LPCSTR path)
void Filepath::SetPath(LPCSTR path)
{
ASSERT(path);
ASSERT(strlen(path) < _MAX_PATH);
@ -89,7 +89,7 @@ void FASTCALL Filepath::SetPath(LPCSTR path)
// パス分離
//
//---------------------------------------------------------------------------
void FASTCALL Filepath::Split()
void Filepath::Split()
{
LPTSTR pDir;
LPTSTR pDirName;
@ -135,7 +135,7 @@ void FASTCALL Filepath::Split()
// The returned pointer is temporary. Copy immediately.
//
//---------------------------------------------------------------------------
LPCTSTR FASTCALL Filepath::GetFileExt() const
LPCTSTR Filepath::GetFileExt() const
{
// 固定バッファへ合成
@ -150,7 +150,7 @@ LPCTSTR FASTCALL Filepath::GetFileExt() const
// Save
//
//---------------------------------------------------------------------------
BOOL FASTCALL Filepath::Save(Fileio *fio, int /*ver*/)
BOOL Filepath::Save(Fileio *fio, int /*ver*/)
{
ASSERT(fio);
@ -162,7 +162,7 @@ BOOL FASTCALL Filepath::Save(Fileio *fio, int /*ver*/)
// Load
//
//---------------------------------------------------------------------------
BOOL FASTCALL Filepath::Load(Fileio *fio, int /*ver*/)
BOOL Filepath::Load(Fileio *fio, int /*ver*/)
{
ASSERT(fio);

14
src/raspberrypi/filepath.h
View File

@ -36,21 +36,21 @@ public:
Filepath& operator=(const Filepath& path);
// 代入
void FASTCALL Clear();
void Clear();
// クリア
void FASTCALL SetPath(LPCSTR path);
void SetPath(LPCSTR path);
// ファイル設定(ユーザ) MBCS用
LPCTSTR FASTCALL GetPath() const { return m_szPath; }
LPCTSTR GetPath() const { return m_szPath; }
// パス名取得
LPCTSTR FASTCALL GetFileExt() const;
LPCTSTR GetFileExt() const;
// ショート名取得(LPCTSTR)
BOOL FASTCALL Save(Fileio *fio, int ver);
BOOL Save(Fileio *fio, int ver);
// セーブ
BOOL FASTCALL Load(Fileio *fio, int ver);
BOOL Load(Fileio *fio, int ver);
// ロード
private:
void FASTCALL Split();
void Split();
// パス分割
TCHAR m_szPath[_MAX_PATH];
// ファイルパス

100
src/raspberrypi/gpiobus.cpp
View File

@ -103,7 +103,7 @@ GPIOBUS::~GPIOBUS()
// 初期化
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::Init(mode_e mode)
BOOL GPIOBUS::Init(mode_e mode)
{
#if defined(__x86_64__) || defined(__X86__)
// When we're running on x86, there is no hardware to talk to, so just return.
@ -331,7 +331,7 @@ BOOL FASTCALL GPIOBUS::Init(mode_e mode)
// Cleanup
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::Cleanup()
void GPIOBUS::Cleanup()
{
#if defined(__x86_64__) || defined(__X86__)
return;
@ -373,7 +373,7 @@ void FASTCALL GPIOBUS::Cleanup()
// Reset
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::Reset()
void GPIOBUS::Reset()
{
#if defined(__x86_64__) || defined(__X86__)
return;
@ -464,7 +464,7 @@ void FASTCALL GPIOBUS::Reset()
// ENB signal setting
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetENB(BOOL ast)
void GPIOBUS::SetENB(BOOL ast)
{
PinSetSignal(PIN_ENB, ast ? ENB_ON : ENB_OFF);
}
@ -474,7 +474,7 @@ void FASTCALL GPIOBUS::SetENB(BOOL ast)
// Get BSY signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetBSY()
BOOL GPIOBUS::GetBSY()
{
return GetSignal(PIN_BSY);
}
@ -484,7 +484,7 @@ BOOL FASTCALL GPIOBUS::GetBSY()
// Set BSY signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetBSY(BOOL ast)
void GPIOBUS::SetBSY(BOOL ast)
{
// Set BSY signal
SetSignal(PIN_BSY, ast);
@ -523,7 +523,7 @@ void FASTCALL GPIOBUS::SetBSY(BOOL ast)
// Get SEL signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetSEL()
BOOL GPIOBUS::GetSEL()
{
return GetSignal(PIN_SEL);
}
@ -533,7 +533,7 @@ BOOL FASTCALL GPIOBUS::GetSEL()
// Set SEL signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetSEL(BOOL ast)
void GPIOBUS::SetSEL(BOOL ast)
{
if (actmode == INITIATOR && ast) {
// Turn on ACTIVE signal
@ -549,7 +549,7 @@ void FASTCALL GPIOBUS::SetSEL(BOOL ast)
// Get ATN signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetATN()
BOOL GPIOBUS::GetATN()
{
return GetSignal(PIN_ATN);
}
@ -559,7 +559,7 @@ BOOL FASTCALL GPIOBUS::GetATN()
// Get ATN signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetATN(BOOL ast)
void GPIOBUS::SetATN(BOOL ast)
{
SetSignal(PIN_ATN, ast);
}
@ -569,7 +569,7 @@ void FASTCALL GPIOBUS::SetATN(BOOL ast)
// Get ACK signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetACK()
BOOL GPIOBUS::GetACK()
{
return GetSignal(PIN_ACK);
}
@ -579,7 +579,7 @@ BOOL FASTCALL GPIOBUS::GetACK()
// Set ACK signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetACK(BOOL ast)
void GPIOBUS::SetACK(BOOL ast)
{
SetSignal(PIN_ACK, ast);
}
@ -589,7 +589,7 @@ void FASTCALL GPIOBUS::SetACK(BOOL ast)
// Get ACK signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetACT()
BOOL GPIOBUS::GetACT()
{
return GetSignal(PIN_ACT);
}
@ -599,7 +599,7 @@ BOOL FASTCALL GPIOBUS::GetACT()
// Set ACK signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetACT(BOOL ast)
void GPIOBUS::SetACT(BOOL ast)
{
SetSignal(PIN_ACT, ast);
}
@ -609,7 +609,7 @@ void FASTCALL GPIOBUS::SetACT(BOOL ast)
// Get RST signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetRST()
BOOL GPIOBUS::GetRST()
{
return GetSignal(PIN_RST);
}
@ -619,7 +619,7 @@ BOOL FASTCALL GPIOBUS::GetRST()
// Set RST signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetRST(BOOL ast)
void GPIOBUS::SetRST(BOOL ast)
{
SetSignal(PIN_RST, ast);
}
@ -629,7 +629,7 @@ void FASTCALL GPIOBUS::SetRST(BOOL ast)
// Get MSG signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetMSG()
BOOL GPIOBUS::GetMSG()
{
return GetSignal(PIN_MSG);
}
@ -639,7 +639,7 @@ BOOL FASTCALL GPIOBUS::GetMSG()
// Set MSG signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetMSG(BOOL ast)
void GPIOBUS::SetMSG(BOOL ast)
{
SetSignal(PIN_MSG, ast);
}
@ -649,7 +649,7 @@ void FASTCALL GPIOBUS::SetMSG(BOOL ast)
// Get CD signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetCD()
BOOL GPIOBUS::GetCD()
{
return GetSignal(PIN_CD);
}
@ -659,7 +659,7 @@ BOOL FASTCALL GPIOBUS::GetCD()
// Set CD Signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetCD(BOOL ast)
void GPIOBUS::SetCD(BOOL ast)
{
SetSignal(PIN_CD, ast);
}
@ -669,7 +669,7 @@ void FASTCALL GPIOBUS::SetCD(BOOL ast)
// Get IO Signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetIO()
BOOL GPIOBUS::GetIO()
{
BOOL ast;
ast = GetSignal(PIN_IO);
@ -709,7 +709,7 @@ BOOL FASTCALL GPIOBUS::GetIO()
// Set IO signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetIO(BOOL ast)
void GPIOBUS::SetIO(BOOL ast)
{
SetSignal(PIN_IO, ast);
@ -747,7 +747,7 @@ void FASTCALL GPIOBUS::SetIO(BOOL ast)
// Get REQ signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetREQ()
BOOL GPIOBUS::GetREQ()
{
return GetSignal(PIN_REQ);
}
@ -757,7 +757,7 @@ BOOL FASTCALL GPIOBUS::GetREQ()
// Set REQ signal
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetREQ(BOOL ast)
void GPIOBUS::SetREQ(BOOL ast)
{
SetSignal(PIN_REQ, ast);
}
@ -767,7 +767,7 @@ void FASTCALL GPIOBUS::SetREQ(BOOL ast)
// Get data signals
//
//---------------------------------------------------------------------------
BYTE FASTCALL GPIOBUS::GetDAT()
BYTE GPIOBUS::GetDAT()
{
DWORD data;
@ -790,7 +790,7 @@ BYTE FASTCALL GPIOBUS::GetDAT()
// Set data signals
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetDAT(BYTE dat)
void GPIOBUS::SetDAT(BYTE dat)
{
// Write to port
#if SIGNAL_CONTROL_MODE == 0
@ -830,7 +830,7 @@ void FASTCALL GPIOBUS::SetDAT(BYTE dat)
// Get data parity signal
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetDP()
BOOL GPIOBUS::GetDP()
{
return GetSignal(PIN_DP);
}
@ -840,7 +840,7 @@ BOOL FASTCALL GPIOBUS::GetDP()
// Receive command handshake
//
//---------------------------------------------------------------------------
int FASTCALL GPIOBUS::CommandHandShake(BYTE *buf)
int GPIOBUS::CommandHandShake(BYTE *buf)
{
int i;
BOOL ret;
@ -941,7 +941,7 @@ irq_enable_exit:
// Data reception handshake
//
//---------------------------------------------------------------------------
int FASTCALL GPIOBUS::ReceiveHandShake(BYTE *buf, int count)
int GPIOBUS::ReceiveHandShake(BYTE *buf, int count)
{
int i;
BOOL ret;
@ -1043,7 +1043,7 @@ int FASTCALL GPIOBUS::ReceiveHandShake(BYTE *buf, int count)
// Data transmission handshake
//
//---------------------------------------------------------------------------
int FASTCALL GPIOBUS::SendHandShake(BYTE *buf, int count, int delay_after_bytes)
int GPIOBUS::SendHandShake(BYTE *buf, int count, int delay_after_bytes)
{
int i;
BOOL ret;
@ -1157,7 +1157,7 @@ int FASTCALL GPIOBUS::SendHandShake(BYTE *buf, int count, int delay_after_bytes)
// SEL signal event polling
//
//---------------------------------------------------------------------------
int FASTCALL GPIOBUS::PollSelectEvent()
int GPIOBUS::PollSelectEvent()
{
// clear errno
errno = 0;
@ -1182,7 +1182,7 @@ int FASTCALL GPIOBUS::PollSelectEvent()
// Cancel SEL signal event
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::ClearSelectEvent()
void GPIOBUS::ClearSelectEvent()
{
}
#endif // USE_SEL_EVENT_ENABLE
@ -1205,7 +1205,7 @@ const int GPIOBUS::SignalTable[19] = {
// Create work table
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::MakeTable(void)
void GPIOBUS::MakeTable(void)
{
const int pintbl[] = {
PIN_DT0, PIN_DT1, PIN_DT2, PIN_DT3, PIN_DT4,
@ -1308,7 +1308,7 @@ void FASTCALL GPIOBUS::MakeTable(void)
// Control signal setting
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetControl(int pin, BOOL ast)
void GPIOBUS::SetControl(int pin, BOOL ast)
{
PinSetSignal(pin, ast);
}
@ -1318,7 +1318,7 @@ void FASTCALL GPIOBUS::SetControl(int pin, BOOL ast)
// Input/output mode setting
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetMode(int pin, int mode)
void GPIOBUS::SetMode(int pin, int mode)
{
int index;
int shift;
@ -1346,7 +1346,7 @@ void FASTCALL GPIOBUS::SetMode(int pin, int mode)
// Get input signal value
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::GetSignal(int pin)
BOOL GPIOBUS::GetSignal(int pin)
{
return (signals >> pin) & 1;
}
@ -1356,7 +1356,7 @@ BOOL FASTCALL GPIOBUS::GetSignal(int pin)
// Set output signal value
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::SetSignal(int pin, BOOL ast)
void GPIOBUS::SetSignal(int pin, BOOL ast)
{
#if SIGNAL_CONTROL_MODE == 0
int index;
@ -1393,7 +1393,7 @@ void FASTCALL GPIOBUS::SetSignal(int pin, BOOL ast)
// Wait for signal change
//
//---------------------------------------------------------------------------
BOOL FASTCALL GPIOBUS::WaitSignal(int pin, BOOL ast)
BOOL GPIOBUS::WaitSignal(int pin, BOOL ast)
{
DWORD now;
DWORD timeout;
@ -1427,7 +1427,7 @@ BOOL FASTCALL GPIOBUS::WaitSignal(int pin, BOOL ast)
// Disable IRQ
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::DisableIRQ()
void GPIOBUS::DisableIRQ()
{
if (rpitype == 4) {
// RPI4 is disabled by GICC
@ -1450,7 +1450,7 @@ void FASTCALL GPIOBUS::DisableIRQ()
// Enable IRQ
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::EnableIRQ()
void GPIOBUS::EnableIRQ()
{
if (rpitype == 4) {
// RPI4 enables interrupts via the GICC
@ -1469,7 +1469,7 @@ void FASTCALL GPIOBUS::EnableIRQ()
// Pin direction setting (input/output)
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::PinConfig(int pin, int mode)
void GPIOBUS::PinConfig(int pin, int mode)
{
int index;
DWORD mask;
@ -1489,7 +1489,7 @@ void FASTCALL GPIOBUS::PinConfig(int pin, int mode)
// Pin pull-up/pull-down setting
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::PullConfig(int pin, int mode)
void GPIOBUS::PullConfig(int pin, int mode)
{
int shift;
DWORD bits;
@ -1537,7 +1537,7 @@ void FASTCALL GPIOBUS::PullConfig(int pin, int mode)
// Set output pin
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::PinSetSignal(int pin, BOOL ast)
void GPIOBUS::PinSetSignal(int pin, BOOL ast)
{
// Check for invalid pin
if (pin < 0) {
@ -1556,7 +1556,7 @@ void FASTCALL GPIOBUS::PinSetSignal(int pin, BOOL ast)
// Set the signal drive strength
//
//---------------------------------------------------------------------------
void FASTCALL GPIOBUS::DrvConfig(DWORD drive)
void GPIOBUS::DrvConfig(DWORD drive)
{
DWORD data;
@ -1570,7 +1570,7 @@ void FASTCALL GPIOBUS::DrvConfig(DWORD drive)
// Generic Phase Acquisition (Doesn't read GPIO)
//
//---------------------------------------------------------------------------
BUS::phase_t FASTCALL GPIOBUS::GetPhaseRaw(DWORD raw_data)
BUS::phase_t GPIOBUS::GetPhaseRaw(DWORD raw_data)
{
DWORD mci;
@ -1623,7 +1623,7 @@ volatile DWORD SysTimer::corefreq;
// Initialize the system timer
//
//---------------------------------------------------------------------------
void FASTCALL SysTimer::Init(DWORD *syst, DWORD *armt)
void SysTimer::Init(DWORD *syst, DWORD *armt)
{
// RPI Mailbox property interface
// Get max clock rate
@ -1661,7 +1661,7 @@ void FASTCALL SysTimer::Init(DWORD *syst, DWORD *armt)
// Get system timer low byte
//
//---------------------------------------------------------------------------
DWORD FASTCALL SysTimer::GetTimerLow() {
DWORD SysTimer::GetTimerLow() {
return systaddr[SYST_CLO];
}
@ -1670,7 +1670,7 @@ DWORD FASTCALL SysTimer::GetTimerLow() {
// Get system timer high byte
//
//---------------------------------------------------------------------------
DWORD FASTCALL SysTimer::GetTimerHigh() {
DWORD SysTimer::GetTimerHigh() {
return systaddr[SYST_CHI];
}
@ -1679,7 +1679,7 @@ DWORD FASTCALL SysTimer::GetTimerHigh() {
// Sleep in nanoseconds
//
//---------------------------------------------------------------------------
void FASTCALL SysTimer::SleepNsec(DWORD nsec)
void SysTimer::SleepNsec(DWORD nsec)
{
DWORD diff;
DWORD start;
@ -1709,7 +1709,7 @@ void FASTCALL SysTimer::SleepNsec(DWORD nsec)
// Sleep in microseconds
//
//---------------------------------------------------------------------------
void FASTCALL SysTimer::SleepUsec(DWORD usec)
void SysTimer::SleepUsec(DWORD usec)
{
DWORD now;

100
src/raspberrypi/gpiobus.h
View File

@ -476,11 +476,11 @@ public:
// Constructor
virtual ~GPIOBUS();
// Destructor
BOOL FASTCALL Init(mode_e mode = TARGET);
BOOL Init(mode_e mode = TARGET);
// Initialization
void FASTCALL Reset();
void Reset();
// Reset
void FASTCALL Cleanup();
void Cleanup();
// Cleanup
//---------------------------------------------------------------------------
@ -506,111 +506,111 @@ public:
#endif // ifdef __x86_64__ || __X86__
}
void FASTCALL SetENB(BOOL ast);
void SetENB(BOOL ast);
// Set ENB signal
BOOL FASTCALL GetBSY();
BOOL GetBSY();
// Get BSY signal
void FASTCALL SetBSY(BOOL ast);
void SetBSY(BOOL ast);
// Set BSY signal
BOOL FASTCALL GetSEL();
BOOL GetSEL();
// Get SEL signal
void FASTCALL SetSEL(BOOL ast);
void SetSEL(BOOL ast);
// Set SEL signal
BOOL FASTCALL GetATN();
BOOL GetATN();
// Get ATN signal
void FASTCALL SetATN(BOOL ast);
void SetATN(BOOL ast);
// Set ATN signal
BOOL FASTCALL GetACK();
BOOL GetACK();
// Get ACK signal
void FASTCALL SetACK(BOOL ast);
void SetACK(BOOL ast);
// Set ACK signal
BOOL FASTCALL GetACT();
BOOL GetACT();
// Get ACT signal
void FASTCALL SetACT(BOOL ast);
void SetACT(BOOL ast);
// Set ACT signal
BOOL FASTCALL GetRST();
BOOL GetRST();
// Get RST signal
void FASTCALL SetRST(BOOL ast);
void SetRST(BOOL ast);
// Set RST signal
BOOL FASTCALL GetMSG();
BOOL GetMSG();
// Get MSG signal
void FASTCALL SetMSG(BOOL ast);
void SetMSG(BOOL ast);
// Set MSG signal
BOOL FASTCALL GetCD();
BOOL GetCD();
// Get CD signal
void FASTCALL SetCD(BOOL ast);
void SetCD(BOOL ast);
// Set CD signal
BOOL FASTCALL GetIO();
BOOL GetIO();
// Get IO signal
void FASTCALL SetIO(BOOL ast);
void SetIO(BOOL ast);
// Set IO signal
BOOL FASTCALL GetREQ();
BOOL GetREQ();
// Get REQ signal
void FASTCALL SetREQ(BOOL ast);
void SetREQ(BOOL ast);
// Set REQ signal
BYTE FASTCALL GetDAT();
BYTE GetDAT();
// Get DAT signal
void FASTCALL SetDAT(BYTE dat);
void SetDAT(BYTE dat);
// Set DAT signal
BOOL FASTCALL GetDP();
BOOL GetDP();
// Get Data parity signal
int FASTCALL CommandHandShake(BYTE *buf);
int CommandHandShake(BYTE *buf);
// Command receive handshake
int FASTCALL ReceiveHandShake(BYTE *buf, int count);
int ReceiveHandShake(BYTE *buf, int count);
// Data receive handshake
int FASTCALL SendHandShake(BYTE *buf, int count, int delay_after_bytes);
int SendHandShake(BYTE *buf, int count, int delay_after_bytes);
// Data transmission handshake
static BUS::phase_t FASTCALL GetPhaseRaw(DWORD raw_data);
static BUS::phase_t GetPhaseRaw(DWORD raw_data);
// Get the phase based on raw data
#ifdef USE_SEL_EVENT_ENABLE
// SEL signal interrupt
int FASTCALL PollSelectEvent();
int PollSelectEvent();
// SEL signal event polling
void FASTCALL ClearSelectEvent();
void ClearSelectEvent();
// Clear SEL signal event
#endif // USE_SEL_EVENT_ENABLE
private:
// SCSI I/O signal control
void FASTCALL MakeTable();
void MakeTable();
// Create work data
void FASTCALL SetControl(int pin, BOOL ast);
void SetControl(int pin, BOOL ast);
// Set Control Signal
void FASTCALL SetMode(int pin, int mode);
void SetMode(int pin, int mode);
// Set SCSI I/O mode
BOOL FASTCALL GetSignal(int pin);
BOOL GetSignal(int pin);
// Get SCSI input signal value
void FASTCALL SetSignal(int pin, BOOL ast);
void SetSignal(int pin, BOOL ast);
// Set SCSI output signal value
BOOL FASTCALL WaitSignal(int pin, BOOL ast);
BOOL WaitSignal(int pin, BOOL ast);
// Wait for a signal to change
// Interrupt control
void FASTCALL DisableIRQ();
void DisableIRQ();
// IRQ Disabled
void FASTCALL EnableIRQ();
void EnableIRQ();
// IRQ Enabled
// GPIO pin functionality settings
void FASTCALL PinConfig(int pin, int mode);
void PinConfig(int pin, int mode);
// GPIO pin direction setting
void FASTCALL PullConfig(int pin, int mode);
void PullConfig(int pin, int mode);
// GPIO pin pull up/down resistor setting
void FASTCALL PinSetSignal(int pin, BOOL ast);
void PinSetSignal(int pin, BOOL ast);
// Set GPIO output signal
void FASTCALL DrvConfig(DWORD drive);
void DrvConfig(DWORD drive);
// Set GPIO drive strength
@ -674,15 +674,15 @@ private:
class SysTimer
{
public:
static void FASTCALL Init(DWORD *syst, DWORD *armt);
static void Init(DWORD *syst, DWORD *armt);
// Initialization
static DWORD FASTCALL GetTimerLow();
static DWORD GetTimerLow();
// Get system timer low byte
static DWORD FASTCALL GetTimerHigh();
static DWORD GetTimerHigh();
// Get system timer high byte
static void FASTCALL SleepNsec(DWORD nsec);
static void SleepNsec(DWORD nsec);
// Sleep for N nanoseconds
static void FASTCALL SleepUsec(DWORD usec);
static void SleepUsec(DWORD usec);
// Sleep for N microseconds
private:

9
src/raspberrypi/os.h
View File

@ -82,15 +82,6 @@
// Basic Macros
//
//---------------------------------------------------------------------------
#undef FASTCALL
#define FASTCALL
#undef CDECL
#define CDECL
#undef INLINE
#define INLINE
#if !defined(ASSERT)
#if !defined(NDEBUG)
#define ASSERT(cond) assert(cond)

4
src/raspberrypi/rascsi.cpp
View File

@ -263,7 +263,7 @@ PbDevices GetDevices() {
for (int i = 0; i < CtrlMax * UnitNum; i++) {
// skip if unit does not exist or null disk
Disk *pUnit = disk[i];
if (!pUnit || pUnit->IsNULL()) {
if (!pUnit) {
continue;
}
@ -730,7 +730,7 @@ bool ParseArgument(int argc, char* argv[], int& port)
if (id < 0) {
cerr << optarg << ": ID not specified" << endl;
return false;
} else if (disk[id] && !disk[id]->IsNULL()) {
} else if (disk[id]) {
cerr << id << ": duplicate ID" << endl;
return false;
}

4
src/raspberrypi/scsi.cpp
View File

@ -18,7 +18,7 @@
// Phase Acquisition
//
//---------------------------------------------------------------------------
BUS::phase_t FASTCALL BUS::GetPhase()
BUS::phase_t BUS::GetPhase()
{
// Selection Phase
if (GetSEL()) {
@ -42,7 +42,7 @@ BUS::phase_t FASTCALL BUS::GetPhase()
// Determine Phase String phase enum
//
//---------------------------------------------------------------------------
const char* FASTCALL BUS::GetPhaseStrRaw(phase_t current_phase){
const char* BUS::GetPhaseStrRaw(phase_t current_phase){
if(current_phase <= phase_t::reserved){
return phase_str_table[current_phase];
}

64
src/raspberrypi/scsi.h
View File

@ -83,22 +83,22 @@ public:
// Basic Functions
// 基本ファンクション
virtual BOOL FASTCALL Init(mode_e mode) = 0;
virtual BOOL Init(mode_e mode) = 0;
// 初期化
virtual void FASTCALL Reset() = 0;
virtual void Reset() = 0;
// リセット
virtual void FASTCALL Cleanup() = 0;
virtual void Cleanup() = 0;
// クリーンアップ
phase_t FASTCALL GetPhase();
phase_t GetPhase();
// フェーズ取得
static phase_t FASTCALL GetPhase(DWORD mci)
static phase_t GetPhase(DWORD mci)
{
return phase_table[mci];
}
// フェーズ取得
static const char* FASTCALL GetPhaseStrRaw(phase_t current_phase);
static const char* GetPhaseStrRaw(phase_t current_phase);
// Get the string phase name, based upon the raw data
// Extract as specific pin field from a raw data capture
@ -107,69 +107,69 @@ public:
return ((raw_data >> pin_num) & 1);
}
virtual BOOL FASTCALL GetBSY() = 0;
virtual BOOL GetBSY() = 0;
// BSYシグナル取得
virtual void FASTCALL SetBSY(BOOL ast) = 0;
virtual void SetBSY(BOOL ast) = 0;
// BSYシグナル設定
virtual BOOL FASTCALL GetSEL() = 0;
virtual BOOL GetSEL() = 0;
// SELシグナル取得
virtual void FASTCALL SetSEL(BOOL ast) = 0;
virtual void SetSEL(BOOL ast) = 0;
// SELシグナル設定
virtual BOOL FASTCALL GetATN() = 0;
virtual BOOL GetATN() = 0;
// ATNシグナル取得
virtual void FASTCALL SetATN(BOOL ast) = 0;
virtual void SetATN(BOOL ast) = 0;
// ATNシグナル設定
virtual BOOL FASTCALL GetACK() = 0;
virtual BOOL GetACK() = 0;
// ACKシグナル取得
virtual void FASTCALL SetACK(BOOL ast) = 0;
virtual void SetACK(BOOL ast) = 0;
// ACKシグナル設定
virtual BOOL FASTCALL GetRST() = 0;
virtual BOOL GetRST() = 0;
// RSTシグナル取得
virtual void FASTCALL SetRST(BOOL ast) = 0;
virtual void SetRST(BOOL ast) = 0;
// RSTシグナル設定
virtual BOOL FASTCALL GetMSG() = 0;
virtual BOOL GetMSG() = 0;
// MSGシグナル取得
virtual void FASTCALL SetMSG(BOOL ast) = 0;
virtual void SetMSG(BOOL ast) = 0;
// MSGシグナル設定
virtual BOOL FASTCALL GetCD() = 0;
virtual BOOL GetCD() = 0;
// CDシグナル取得
virtual void FASTCALL SetCD(BOOL ast) = 0;
virtual void SetCD(BOOL ast) = 0;
// CDシグナル設定
virtual BOOL FASTCALL GetIO() = 0;
virtual BOOL GetIO() = 0;
// IOシグナル取得
virtual void FASTCALL SetIO(BOOL ast) = 0;
virtual void SetIO(BOOL ast) = 0;
// IOシグナル設定
virtual BOOL FASTCALL GetREQ() = 0;
virtual BOOL GetREQ() = 0;
// REQシグナル取得
virtual void FASTCALL SetREQ(BOOL ast) = 0;
virtual void SetREQ(BOOL ast) = 0;
// REQシグナル設定
virtual BYTE FASTCALL GetDAT() = 0;
virtual BYTE GetDAT() = 0;
// データシグナル取得
virtual void FASTCALL SetDAT(BYTE dat) = 0;
virtual void SetDAT(BYTE dat) = 0;
// データシグナル設定
virtual BOOL FASTCALL GetDP() = 0;
virtual BOOL GetDP() = 0;
// パリティシグナル取得
virtual int FASTCALL CommandHandShake(BYTE *buf) = 0;
virtual int CommandHandShake(BYTE *buf) = 0;
// コマンド受信ハンドシェイク
virtual int FASTCALL ReceiveHandShake(BYTE *buf, int count) = 0;
virtual int ReceiveHandShake(BYTE *buf, int count) = 0;
// データ受信ハンドシェイク
virtual int FASTCALL SendHandShake(BYTE *buf, int count, int delay_after_bytes) = 0;
virtual int SendHandShake(BYTE *buf, int count, int delay_after_bytes) = 0;
// データ送信ハンドシェイク
virtual BOOL FASTCALL GetSignal(int pin) = 0;
virtual BOOL GetSignal(int pin) = 0;
// Get SCSI input signal value
virtual void FASTCALL SetSignal(int pin, BOOL ast) = 0;
virtual void SetSignal(int pin, BOOL ast) = 0;
// Set SCSI output signal value
static const int SEND_NO_DELAY = -1;
// Passed into SendHandShake when we don't want to delay