mirror of
https://github.com/akuker/RASCSI.git
synced 2024-09-27 15:57:52 +00:00
41c3405b99
* Fixed clang warnings * Removed obsolete logging * Collection usage cleanup * Use sorted collections * Updated sorting, added comments * Improved locality of code * Simplified vector initialization * Fixed typo * Collection usage cleanup * Removed useless comments and assertions * Removed useless comments, removed code inconsistencies * Removed useless comments, renaming * Replaced cast by a more explicit logical operation * Removed target with hard-coded paths * Include file cleanup * Use more standard includes * Fixed log level name * Updated switch * Fixed typo * Improvoded locality of code, removed useless comments
747 lines
13 KiB
C++
747 lines
13 KiB
C++
//---------------------------------------------------------------------------
|
|
//
|
|
// SCSI Target Emulator RaSCSI (*^..^*)
|
|
// for Raspberry Pi
|
|
//
|
|
// Powered by XM6 TypeG Technology.
|
|
// Copyright (C) 2016-2020 GIMONS
|
|
// [ HDD dump utility (Initiator mode/SASI Version) ]
|
|
//
|
|
// SASI IMAGE EXAMPLE
|
|
// X68000
|
|
// 10MB(10441728 BS=256 C=40788)
|
|
// 20MB(20748288 BS=256 C=81048)
|
|
// 40MB(41496576 BS=256 C=162096)
|
|
//
|
|
// MZ-2500/MZ-2800 MZ-1F23
|
|
// 20MB(22437888 BS=1024 C=21912)
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
#include <cerrno>
|
|
#include "os.h"
|
|
#include "fileio.h"
|
|
#include "filepath.h"
|
|
#include "gpiobus.h"
|
|
#include "rascsi.h"
|
|
#include "rascsi_version.h"
|
|
|
|
#define BUFSIZE 1024 * 64 // Maybe around 64KB?
|
|
|
|
GPIOBUS bus;
|
|
int targetid;
|
|
int unitid;
|
|
int bsiz; // Block size
|
|
int bnum; // Number of blocks
|
|
Filepath hdffile; // HDF file
|
|
bool restore; // Restore flag
|
|
BYTE buffer[BUFSIZE]; // Work buffer
|
|
int result; // Result code
|
|
|
|
void Cleanup();
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Signal processing
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
void KillHandler(int sig)
|
|
{
|
|
// Stop instruction
|
|
Cleanup();
|
|
exit(0);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Banner output
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
bool Banner(int argc, char* argv[])
|
|
{
|
|
printf("RaSCSI hard disk dump utility (SASI HDD) ");
|
|
printf("version %s (%s, %s)\n",
|
|
rascsi_get_version_string(),
|
|
__DATE__,
|
|
__TIME__);
|
|
|
|
if (argc < 2 || strcmp(argv[1], "-h") == 0) {
|
|
printf("Usage: %s -i ID [-u UT] [-b BSIZE] -c COUNT -f FILE [-r]\n", argv[0]);
|
|
printf(" ID is target device SASI ID {0|1|2|3|4|5|6|7}.\n");
|
|
printf(" UT is target unit ID {0|1}. Default is 0.\n");
|
|
printf(" BSIZE is block size {256|512|1024}. Default is 256.\n");
|
|
printf(" COUNT is block count.\n");
|
|
printf(" FILE is HDF file path.\n");
|
|
printf(" -r is restore operation.\n");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Init()
|
|
{
|
|
// Interrupt handler settings
|
|
if (signal(SIGINT, KillHandler) == SIG_ERR) {
|
|
return false;
|
|
}
|
|
if (signal(SIGHUP, KillHandler) == SIG_ERR) {
|
|
return false;
|
|
}
|
|
if (signal(SIGTERM, KillHandler) == SIG_ERR) {
|
|
return false;
|
|
}
|
|
|
|
// GPIO initialization
|
|
if (!bus.Init(BUS::INITIATOR)) {
|
|
return false;
|
|
}
|
|
|
|
// Work initialization
|
|
targetid = -1;
|
|
unitid = 0;
|
|
bsiz = 256;
|
|
bnum = -1;
|
|
restore = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void Cleanup()
|
|
{
|
|
bus.Cleanup();
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
// Reset bus signal line
|
|
bus.Reset();
|
|
}
|
|
|
|
bool ParseArgument(int argc, char* argv[])
|
|
{
|
|
int opt;
|
|
char *file;
|
|
|
|
// Initialization
|
|
file = NULL;
|
|
|
|
// Argument parsing
|
|
opterr = 0;
|
|
while ((opt = getopt(argc, argv, "i:u:b:c:f:r")) != -1) {
|
|
switch (opt) {
|
|
case 'i':
|
|
targetid = optarg[0] - '0';
|
|
break;
|
|
|
|
case 'u':
|
|
unitid = optarg[0] - '0';
|
|
break;
|
|
|
|
case 'b':
|
|
bsiz = atoi(optarg);
|
|
break;
|
|
|
|
case 'c':
|
|
bnum = atoi(optarg);
|
|
break;
|
|
|
|
case 'f':
|
|
file = optarg;
|
|
break;
|
|
|
|
case 'r':
|
|
restore = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// TARGET ID check
|
|
if (targetid < 0 || targetid > 7) {
|
|
fprintf(stderr,
|
|
"Error : Invalid target id range\n");
|
|
return false;
|
|
}
|
|
|
|
// UNIT ID check
|
|
if (unitid < 0 || unitid > 1) {
|
|
fprintf(stderr,
|
|
"Error : Invalid unit id range\n");
|
|
return false;
|
|
}
|
|
|
|
// BSIZ check
|
|
if (bsiz != 256 && bsiz != 512 && bsiz != 1024) {
|
|
fprintf(stderr,
|
|
"Error : Invalid block size\n");
|
|
return false;
|
|
}
|
|
|
|
// BNUM check
|
|
if (bnum < 0) {
|
|
fprintf(stderr,
|
|
"Error : Invalid block count\n");
|
|
return false;
|
|
}
|
|
|
|
// File check
|
|
if (!file) {
|
|
fprintf(stderr,
|
|
"Error : Invalid file path\n");
|
|
return false;
|
|
}
|
|
|
|
hdffile.SetPath(file);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool WaitPhase(BUS::phase_t phase)
|
|
{
|
|
DWORD now;
|
|
|
|
// Timeout (3000ms)
|
|
now = SysTimer::GetTimerLow();
|
|
while ((SysTimer::GetTimerLow() - now) < 3 * 1000 * 1000) {
|
|
bus.Aquire();
|
|
if (bus.GetREQ() && bus.GetPhase() == phase) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Bus free phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
void BusFree()
|
|
{
|
|
bus.Reset();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Selection phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
bool Selection(int id)
|
|
{
|
|
BYTE data;
|
|
int count;
|
|
|
|
// ID setting and SEL assertion
|
|
data = 0;
|
|
data |= (1 << id);
|
|
bus.SetDAT(data);
|
|
bus.SetSEL(TRUE);
|
|
|
|
// Wait for BSY
|
|
count = 10000;
|
|
do {
|
|
usleep(20);
|
|
bus.Aquire();
|
|
if (bus.GetBSY()) {
|
|
break;
|
|
}
|
|
} while (count--);
|
|
|
|
// SEL negate
|
|
bus.SetSEL(FALSE);
|
|
|
|
// Return true if target is busy
|
|
return bus.GetBSY();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Command phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
bool Command(BYTE *buf, int length)
|
|
{
|
|
int count;
|
|
|
|
// Wait for phase
|
|
if (!WaitPhase(BUS::command)) {
|
|
return false;
|
|
}
|
|
|
|
// Send command
|
|
count = bus.SendHandShake(buf, length, BUS::SEND_NO_DELAY);
|
|
|
|
// Return true is send results match number of requests
|
|
if (count == length) {
|
|
return true;
|
|
}
|
|
|
|
// Send error
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Data in phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int DataIn(BYTE *buf, int length)
|
|
{
|
|
// Wait for phase
|
|
if (!WaitPhase(BUS::datain)) {
|
|
return -1;
|
|
}
|
|
|
|
// Receive data
|
|
return bus.ReceiveHandShake(buf, length);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Data out phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int DataOut(BYTE *buf, int length)
|
|
{
|
|
// Wait for phase
|
|
if (!WaitPhase(BUS::dataout)) {
|
|
return -1;
|
|
}
|
|
|
|
// Receive data
|
|
return bus.SendHandShake(buf, length, BUS::SEND_NO_DELAY);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Status phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int Status()
|
|
{
|
|
BYTE buf[256];
|
|
|
|
// Wait for phase
|
|
if (!WaitPhase(BUS::status)) {
|
|
return -2;
|
|
}
|
|
|
|
// Receive data
|
|
if (bus.ReceiveHandShake(buf, 1) == 1) {
|
|
return (int)buf[0];
|
|
}
|
|
|
|
// Receive error
|
|
return -1;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Message in phase execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int MessageIn()
|
|
{
|
|
BYTE buf[256];
|
|
|
|
// Wait for phase
|
|
if (!WaitPhase(BUS::msgin)) {
|
|
return -2;
|
|
}
|
|
|
|
// Receive data
|
|
if (bus.ReceiveHandShake(buf, 1) == 1) {
|
|
return (int)buf[0];
|
|
}
|
|
|
|
// Receive error
|
|
return -1;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// TEST UNIT READY execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int TestUnitReady(int id)
|
|
{
|
|
BYTE cmd[256];
|
|
|
|
// Initialize result code
|
|
result = 0;
|
|
|
|
if (!Selection(id)) {
|
|
result = -1;
|
|
goto exit;
|
|
}
|
|
|
|
memset(cmd, 0x00, 6);
|
|
cmd[0] = 0x00;
|
|
cmd[1] = unitid << 5;
|
|
if (!Command(cmd, 6)) {
|
|
result = -2;
|
|
goto exit;
|
|
}
|
|
|
|
if (Status() < 0) {
|
|
result = -4;
|
|
goto exit;
|
|
}
|
|
|
|
if (MessageIn() < 0) {
|
|
result = -5;
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
BusFree();
|
|
|
|
return result;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// REQUEST SENSE execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int RequestSense(int id, BYTE *buf)
|
|
{
|
|
BYTE cmd[256];
|
|
int count;
|
|
|
|
// Initialize result codes
|
|
result = 0;
|
|
count = 0;
|
|
|
|
if (!Selection(id)) {
|
|
result = -1;
|
|
goto exit;
|
|
}
|
|
|
|
memset(cmd, 0x00, 6);
|
|
cmd[0] = 0x03;
|
|
cmd[1] = unitid << 5;
|
|
cmd[4] = 4;
|
|
if (!Command(cmd, 6)) {
|
|
result = -2;
|
|
goto exit;
|
|
}
|
|
|
|
memset(buf, 0x00, 256);
|
|
count = DataIn(buf, 256);
|
|
if (count <= 0) {
|
|
result = -3;
|
|
goto exit;
|
|
}
|
|
|
|
if (Status() < 0) {
|
|
result = -4;
|
|
goto exit;
|
|
}
|
|
|
|
if (MessageIn() < 0) {
|
|
result = -5;
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
BusFree();
|
|
|
|
// If successful, return number of transfers
|
|
if (result == 0) {
|
|
return count;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// READ6 execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int Read6(int id, DWORD bstart, DWORD blength, DWORD length, BYTE *buf)
|
|
{
|
|
BYTE cmd[256];
|
|
int count;
|
|
|
|
// Initialize result codes
|
|
result = 0;
|
|
count = 0;
|
|
|
|
if (!Selection(id)) {
|
|
result = -1;
|
|
goto exit;
|
|
}
|
|
|
|
memset(cmd, 0x00, 10);
|
|
cmd[0] = 0x8;
|
|
cmd[1] = (BYTE)(bstart >> 16);
|
|
cmd[1] &= 0x1f;
|
|
cmd[1] = unitid << 5;
|
|
cmd[2] = (BYTE)(bstart >> 8);
|
|
cmd[3] = (BYTE)bstart;
|
|
cmd[4] = (BYTE)blength;
|
|
if (!Command(cmd, 6)) {
|
|
result = -2;
|
|
goto exit;
|
|
}
|
|
|
|
count = DataIn(buf, length);
|
|
if (count <= 0) {
|
|
result = -3;
|
|
goto exit;
|
|
}
|
|
|
|
if (Status() < 0) {
|
|
result = -4;
|
|
goto exit;
|
|
}
|
|
|
|
if (MessageIn() < 0) {
|
|
result = -5;
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
BusFree();
|
|
|
|
// If successful, return number of transfers
|
|
if (result == 0) {
|
|
return count;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// WRITE6 execution
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int Write6(int id, DWORD bstart, DWORD blength, DWORD length, BYTE *buf)
|
|
{
|
|
BYTE cmd[256];
|
|
int count;
|
|
|
|
// Initialize result codes
|
|
result = 0;
|
|
count = 0;
|
|
|
|
if (!Selection(id)) {
|
|
result = -1;
|
|
goto exit;
|
|
}
|
|
|
|
memset(cmd, 0x00, 10);
|
|
cmd[0] = 0xa;
|
|
cmd[1] = (BYTE)(bstart >> 16);
|
|
cmd[1] &= 0x1f;
|
|
cmd[1] = unitid << 5;
|
|
cmd[2] = (BYTE)(bstart >> 8);
|
|
cmd[3] = (BYTE)bstart;
|
|
cmd[4] = (BYTE)blength;
|
|
if (!Command(cmd, 6)) {
|
|
result = -2;
|
|
goto exit;
|
|
}
|
|
|
|
count = DataOut(buf, length);
|
|
if (count <= 0) {
|
|
result = -3;
|
|
goto exit;
|
|
}
|
|
|
|
if (Status() < 0) {
|
|
result = -4;
|
|
goto exit;
|
|
}
|
|
|
|
if (MessageIn() < 0) {
|
|
result = -5;
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
BusFree();
|
|
|
|
// If successful, return number of transfers
|
|
if (result == 0) {
|
|
return count;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Main processing
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
int main(int argc, char* argv[])
|
|
{
|
|
int i;
|
|
int count;
|
|
DWORD duni;
|
|
DWORD dsiz;
|
|
DWORD dnum;
|
|
Fileio fio;
|
|
Fileio::OpenMode omode;
|
|
off_t size;
|
|
|
|
// Output banner
|
|
if (!Banner(argc, argv)) {
|
|
exit(0);
|
|
}
|
|
|
|
if (!Init()) {
|
|
fprintf(stderr, "Error : Initializing\n");
|
|
|
|
// Probably not executing as root?
|
|
exit(EPERM);
|
|
}
|
|
|
|
if (!ParseArgument(argc, argv)) {
|
|
Cleanup();
|
|
|
|
// Exit with argument error
|
|
exit(EINVAL);
|
|
}
|
|
|
|
Reset();
|
|
|
|
// Open file
|
|
if (restore) {
|
|
omode = Fileio::ReadOnly;
|
|
} else {
|
|
omode = Fileio::WriteOnly;
|
|
}
|
|
if (!fio.Open(hdffile.GetPath(), omode)) {
|
|
fprintf(stderr, "Error : Can't open hdf file\n");
|
|
|
|
Cleanup();
|
|
exit(EPERM);
|
|
}
|
|
|
|
BusFree();
|
|
|
|
// Execute RESET signal
|
|
bus.SetRST(TRUE);
|
|
usleep(1000);
|
|
bus.SetRST(FALSE);
|
|
|
|
// Start dump
|
|
printf("TARGET ID : %d\n", targetid);
|
|
printf("UNIT ID : %d\n", unitid);
|
|
|
|
// TEST UNIT READY
|
|
count = TestUnitReady(targetid);
|
|
if (count < 0) {
|
|
fprintf(stderr, "TEST UNIT READY ERROR %d\n", count);
|
|
goto cleanup_exit;
|
|
}
|
|
|
|
// REQUEST SENSE (for CHECK CONDITION)
|
|
count = RequestSense(targetid, buffer);
|
|
if (count < 0) {
|
|
fprintf(stderr, "REQUEST SENSE ERROR %d\n", count);
|
|
goto cleanup_exit;
|
|
}
|
|
|
|
printf("Number of blocks : %d Blocks\n", bnum);
|
|
printf("Block length : %d Bytes\n", bsiz);
|
|
|
|
// Display data size
|
|
printf("Total length : %d MBytes %d Bytes\n",
|
|
(bsiz * bnum / 1024 / 1024),
|
|
(bsiz * bnum));
|
|
|
|
// Get restore file size
|
|
if (restore) {
|
|
size = fio.GetFileSize();
|
|
printf("Restore file size : %d bytes", (int)size);
|
|
if (size > (off_t)(bsiz * bnum)) {
|
|
printf("(WARNING : File size is larger than disk size)");
|
|
} else if (size < (off_t)(bsiz * bnum)) {
|
|
printf("(ERROR : File size is smaller than disk size)\n");
|
|
goto cleanup_exit;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
// Dump by buffer size
|
|
duni = BUFSIZE;
|
|
duni /= bsiz;
|
|
dsiz = BUFSIZE;
|
|
dnum = bnum * bsiz;
|
|
dnum /= BUFSIZE;
|
|
|
|
if (restore) {
|
|
printf("Restore progress : ");
|
|
} else {
|
|
printf("Dump progress : ");
|
|
}
|
|
|
|
for (i = 0; i < (int)dnum; i++) {
|
|
if (i > 0) {
|
|
printf("\033[21D");
|
|
printf("\033[0K");
|
|
}
|
|
printf("%3d%%(%7d/%7d)",
|
|
(int)((i + 1) * 100 / dnum),
|
|
(int)(i * duni),
|
|
bnum);
|
|
fflush(stdout);
|
|
|
|
if (restore) {
|
|
if (fio.Read(buffer, dsiz)) {
|
|
if (Write6(targetid, i * duni, duni, dsiz, buffer) >= 0) {
|
|
continue;
|
|
}
|
|
}
|
|
} else {
|
|
if (Read6(targetid, i * duni, duni, dsiz, buffer) >= 0) {
|
|
if (fio.Write(buffer, dsiz)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
printf("Error occured and aborted... %d\n", result);
|
|
goto cleanup_exit;
|
|
}
|
|
|
|
if (dnum > 0) {
|
|
printf("\033[21D");
|
|
printf("\033[0K");
|
|
}
|
|
|
|
// Rounding of capacity
|
|
dnum = bnum % duni;
|
|
dsiz = dnum * bsiz;
|
|
|
|
if (dnum > 0) {
|
|
if (restore) {
|
|
if (fio.Read(buffer, dsiz)) {
|
|
Write6(targetid, i * duni, dnum, dsiz, buffer);
|
|
}
|
|
} else {
|
|
if (Read6(targetid, i * duni, dnum, dsiz, buffer) >= 0) {
|
|
fio.Write(buffer, dsiz);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Completion message
|
|
printf("%3d%%(%7d/%7d)\n", 100, bnum, bnum);
|
|
|
|
cleanup_exit:
|
|
fio.Close();
|
|
|
|
Cleanup();
|
|
|
|
exit(0);
|
|
}
|