github.com/captain-amygdala.pistorm
1
0
Fork 0
mirror of https://github.com/captain-amygdala/pistorm.git synced 2026-02-05 15:54:52 +00:00
Code Issues Projects Releases Wiki Activity

Fix PiSCSI device selection bug

Browse Source
This commit is contained in:
beeanyew
2021-02-03 12:26:19 +01:00
parent 1439d00b57
commit ed138fbd47
12 changed files with 275 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
README.md
View File

@@ -47,15 +47,12 @@ Simple quickstart
to start the pistorm emulator
run : `./run.sh`
run : `sudo ./emulator`
to exit emulation
`ctrl+c`
`ctrl+c` or pressing `q` on the keyboard connected to the Raspberry Pi.
If you want to use the minimal hdd image you need to unpack it :
run : `tar xvfz hd0.tar.gz`
**Currently the emulation is a bit buggy on IDE Interrupts, so it takes ages to boot from the emulated HDD. This will be fixed soon :)
The IDE emulation can take both hard drive images generated using `makedisk` in the `ide` directory (these have a 1KB header) or headerless RDSK/RDB images created for instance in WinUAE or as empty files. The IDE emulation currently has a quirk that may require you to reduce/increase the size of the image file by 2MB in order for it to work.
** FPGA bitstream update :

2
platforms/amiga/amiga-platform.c
View File

@@ -45,7 +45,6 @@ extern unsigned char cdtv_sram[32 * SIZE_KILO];
static uint8_t rtg_enabled = 0, piscsi_enabled = 0, pinet_enabled = 0;
extern uint32_t piscsi_base;
extern uint8_t piscsi_diag_read;
extern void stop_cpu_emulation(uint8_t disasm_cur);
@@ -398,7 +397,6 @@ void handle_reset_amiga(struct emulator_config *cfg) {
ac_z2_done = 0;
ac_z2_current_pic = 0;
ac_z3_current_pic = 0;
piscsi_diag_read = 0;
adjust_ranges_amiga(cfg);
}

BIN
platforms/amiga/piscsi/device_driver_amiga/2nd.scsi.device
View File

Binary file not shown.

BIN
platforms/amiga/piscsi/device_driver_amiga/bootrom
View File

Binary file not shown.

67
platforms/amiga/piscsi/device_driver_amiga/bootrom.s
View File

@@ -24,7 +24,7 @@
XREF _LVOFindResident
ROMINFO EQU 0
ROMOFFS EQU $0
ROMOFFS EQU $4000
* ROMINFO defines whether you want the AUTOCONFIG information in
* the beginning of your ROM (set to 0 if you instead have PALS
@@ -92,8 +92,8 @@ rt_Init: dc.l Init-RomStart ; APTR RT_INIT
******* Strings referenced in Diag Copy area ************************
DevName: dc.b '2nd.scsi.device',0 ; Name string
IdString dc.b 'PISCSI ',48+VERSION,'.',48+REVISION ; Id string
DevName: dc.b 'PiSCSI Snake Controller',0 ; Name string
IdString dc.b 'PISCSI v0.1',0 ; Id string
DosName: dc.b 'dos.library',0 ; DOS library name
@@ -121,28 +121,12 @@ DiagEntry:
nop
nop
move.l #1,$80000020
movea.l 4,a6
move.l #$40000,d0
moveq #0,d1
jsr AllocMem(a6)
nop
nop
move.l d0,$80000040
move.l d0,a1
move.l #0,d1
movea.l 4,a6
add.l #$16e,a1
nop
nop
nop
jsr -102(a6)
nop
nop
bra.s endpatches
nop
lea patchTable-RomStart(a0),a1 ; find patch table
adda.l #ROMOFFS,a1 ; adjusting for ROMOFFS
@@ -180,7 +164,15 @@ endpatches:
******* BootEntry **************************************************
**********************************************************************
BootEntry: lea DosName(PC),a1 ; 'dos.library',0
BootEntry:
move.l #2,$80000020
nop
nop
nop
nop
nop
lea DosName(PC),a1 ; 'dos.library',0
jsr _LVOFindResident(a6) ; find the DOS resident tag
move.l d0,a0 ; in order to bootstrap
move.l RT_INIT(A0),a0 ; set vector to DOS INIT
@@ -221,8 +213,35 @@ Init: ; After Diag patching, our romtag will point to this
; initialization routine, but will MakeDosNode then set up a
; BootNode, and Enqueue() on eb_MountList.
;
move.l #3,$80000020
nop
nop
nop
nop
move.l #4,$80000020
movea.l 4,a6
move.l #$40000,d0
moveq #0,d1
jsr AllocMem(a6)
move.l d0,$80000040
nop
nop
move.l d0,a1
move.l #0,d1
movea.l 4,a6
add.l #$16e,a1
move.l #5,$80000020
nop
nop
nop
jsr -102(a6)
nop
nop
moveq.l #1,d0 ; indicate "success"
rts
; Rest of your position-independent device code goes here.
END

BIN
platforms/amiga/piscsi/device_driver_amiga/pi-scsi.device
View File

Binary file not shown.

59
platforms/amiga/piscsi/device_driver_amiga/piscsi-amiga.c
View File

@@ -102,6 +102,10 @@ struct WBStartup *_WBenchMsg = NULL;
//#define exit(...)
//#define debug(...)
#define KPrintF(...)
#define debug(...)
#define debugval(...)
//#define debug(c, v) WRITESHORT(c, v)
//#define debugval(c, v) WRITELONG(c, v)
//#define bug(x,args...) KPrintF(x ,##args);
//#define debug(x,args...) bug("%s:%ld " x "\n", __func__, (unsigned long)__LINE__ ,##args)
@@ -117,6 +121,7 @@ uint32_t __UserDevInit(struct Device* dev) {
SysBase = *(struct ExecBase **)4L;
KPrintF("Initializing devices.\n");
debug(PISCSI_DBG_MSG, DBG_INIT);
dev_base = AllocMem(sizeof(struct piscsi_base), MEMF_PUBLIC | MEMF_CLEAR);
dev_base->pi_dev = dev;
@@ -135,6 +140,11 @@ uint32_t __UserDevInit(struct Device* dev) {
READSHORT(PISCSI_CMD_HEADS, dev_base->units[i].h);
READSHORT(PISCSI_CMD_SECS, dev_base->units[i].s);
KPrintF("C/H/S: %ld / %ld / %ld\n", dev_base->units[i].c, dev_base->units[i].h, dev_base->units[i].s);
debugval(PISCSI_DBG_VAL1, dev_base->units[i].c);
debugval(PISCSI_DBG_VAL2, dev_base->units[i].h);
debugval(PISCSI_DBG_VAL3, dev_base->units[i].s);
debug(PISCSI_DBG_MSG, DBG_CHS);
}
dev_base->units[i].change_num++;
// Send any reset signal to the "SCSI" device here.
@@ -145,6 +155,7 @@ uint32_t __UserDevInit(struct Device* dev) {
uint32_t __UserDevCleanup(void) {
KPrintF("Cleaning up.\n");
debug(PISCSI_DBG_MSG, DBG_CLEANUP);
FreeMem(dev_base, sizeof(struct piscsi_base));
return 0;
}
@@ -159,6 +170,10 @@ uint32_t __UserDevOpen(struct IOExtTD *iotd, uint32_t num, uint32_t flags) {
WRITELONG(PISCSI_CMD_DRVNUM, num);
READLONG(PISCSI_CMD_DRVNUM, unit_num);
debugval(PISCSI_DBG_VAL1, unit_num);
debugval(PISCSI_DBG_VAL2, flags);
debugval(PISCSI_DBG_VAL3, num);
debug(PISCSI_DBG_MSG, DBG_OPENDEV);
KPrintF("Opening device %ld Flags: %ld (%lx)\n", unit_num, flags, flags);
if (iotd && unit_num < NUM_UNITS) {
@@ -194,6 +209,10 @@ void __BeginIO(struct IORequest *io) {
if (node == NULL || u == NULL)
return;
debugval(PISCSI_DBG_VAL1, io->io_Command);
debugval(PISCSI_DBG_VAL2, io->io_Flags);
debugval(PISCSI_DBG_VAL3, (io->io_Flags & IOF_QUICK));
debug(PISCSI_DBG_MSG, DBG_BEGINIO);
KPrintF("io_Command = %ld, io_Flags = 0x%lx quick = %lx\n", io->io_Command, io->io_Flags, (io->io_Flags & IOF_QUICK));
io->io_Error = piscsi_perform_io(u, io);
@@ -204,6 +223,7 @@ void __BeginIO(struct IORequest *io) {
ADDTABL_1(__AbortIO,a1);
void __AbortIO(struct IORequest* io) {
debug(PISCSI_DBG_MSG, DBG_ABORTIO);
KPrintF("AbortIO!\n");
if (!io) return;
io->io_Error = IOERR_ABORTED;
@@ -244,13 +264,13 @@ uint8_t piscsi_rw(struct piscsi_unit *u, struct IORequest *io, uint32_t offset,
WRITELONG(PISCSI_CMD_ADDR1, (offset >> 9));
WRITELONG(PISCSI_CMD_ADDR2, len);
WRITELONG(PISCSI_CMD_ADDR3, (uint32_t)data);
WRITESHORT(PISCSI_CMD_WRITE, 1);
WRITESHORT(PISCSI_CMD_WRITE, u->unit_num);
} else {
//KPrintF("read %lx %lx -> %lx\n", offset, len, (uint32_t)data);
WRITELONG(PISCSI_CMD_ADDR1, (offset >> 9));
WRITELONG(PISCSI_CMD_ADDR2, len);
WRITELONG(PISCSI_CMD_ADDR3, (uint32_t)data);
WRITESHORT(PISCSI_CMD_READ, 1);
WRITESHORT(PISCSI_CMD_READ, u->unit_num);
}
if (sderr) {
@@ -295,6 +315,13 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
scsi->scsi_Command[1], scsi->scsi_Command[2],
scsi->scsi_CmdLength);
debugval(PISCSI_DBG_VAL1, iostd->io_Length);
debugval(PISCSI_DBG_VAL2, scsi->scsi_Command[0]);
debugval(PISCSI_DBG_VAL3, scsi->scsi_Command[1]);
debugval(PISCSI_DBG_VAL4, scsi->scsi_Command[2]);
debugval(PISCSI_DBG_VAL5, scsi->scsi_CmdLength);
debug(PISCSI_DBG_MSG, DBG_SCSICMD);
//maxblocks = u->s * u->c * u->h;
if (scsi->scsi_CmdLength < 6) {
@@ -312,12 +339,10 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
switch (scsi->scsi_Command[0]) {
case 0x00: // TEST_UNIT_READY
KPrintF("SCSI command: Test Unit Ready.\n");
err = 0;
break;
case 0x12: // INQUIRY
KPrintF("SCSI command: Inquiry.\n");
for (i = 0; i < scsi->scsi_Length; i++) {
uint8_t val = 0;
@@ -373,19 +398,19 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
if (scsi->scsi_Command[0] == 0x08) {
//KPrintF("scsi_read %lx %lx\n",block,blocks);
KPrintF("SCSI read %lx %lx -> %lx\n", block, blocks, (uint32_t)data);
//KPrintF("SCSI read %lx %lx -> %lx\n", block, blocks, (uint32_t)data);
WRITELONG(PISCSI_CMD_ADDR2, block);
WRITELONG(PISCSI_CMD_ADDR2, (blocks << 9));
WRITELONG(PISCSI_CMD_ADDR3, (uint32_t)data);
WRITESHORT(PISCSI_CMD_READ, 1);
WRITESHORT(PISCSI_CMD_READ, u->unit_num);
}
else {
//KPrintF("scsi_write %lx %lx\n",block,blocks);
KPrintF("SCSI write %lx -> %lx %lx\n", (uint32_t)data, block, blocks);
//KPrintF("SCSI write %lx -> %lx %lx\n", (uint32_t)data, block, blocks);
WRITELONG(PISCSI_CMD_ADDR2, block);
WRITELONG(PISCSI_CMD_ADDR2, (blocks << 9));
WRITELONG(PISCSI_CMD_ADDR3, (uint32_t)data);
WRITESHORT(PISCSI_CMD_WRITE, 1);
WRITESHORT(PISCSI_CMD_WRITE, u->unit_num);
}
scsi->scsi_Actual = scsi->scsi_Length;
@@ -393,7 +418,7 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
break;
case 0x25: // READ CAPACITY (10)
KPrintF("SCSI command: Read Capacity.\n");
//KPrintF("SCSI command: Read Capacity.\n");
if (scsi->scsi_CmdLength < 10) {
err = HFERR_BadStatus;
break;
@@ -422,7 +447,7 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
break;
case 0x1a: // MODE SENSE (6)
KPrintF("SCSI command: Mode Sense.\n");
//KPrintF("SCSI command: Mode Sense.\n");
data[0] = 3 + 8 + 0x16;
data[1] = 0; // MEDIUM TYPE
data[2] = 0;
@@ -437,6 +462,7 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
switch (((UWORD)scsi->scsi_Command[2] << 8) | scsi->scsi_Command[3]) {
case 0x0300: { // Format Device Mode
KPrintF("Grabbing SCSI format device mode data.\n");
debug(PISCSI_DBG_MSG, DBG_SCSI_FORMATDEVICE);
uint8_t *datext = data + 12;
datext[0] = 0x03;
datext[1] = 0x16;
@@ -457,6 +483,7 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
}
case 0x0400: // Rigid Drive Geometry
KPrintF("Grabbing SCSI rigid drive geometry.\n");
debug(PISCSI_DBG_MSG, DBG_SCSI_RDG);
uint8_t *datext = data + 12;
datext[0] = 0x04;
*((uint32_t *)&datext[1]) = u->c;
@@ -476,6 +503,8 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
default:
KPrintF("[WARN] Unhandled mode sense thing: %lx\n", ((UWORD)scsi->scsi_Command[2] << 8) | scsi->scsi_Command[3]);
debugval(PISCSI_DBG_VAL1, (((UWORD)scsi->scsi_Command[2] << 8) | scsi->scsi_Command[3]));
debug(PISCSI_DBG_MSG, DBG_SCSI_UNKNOWN_MODESENSE);
err = HFERR_BadStatus;
break;
}
@@ -486,12 +515,16 @@ uint8_t piscsi_scsi(struct piscsi_unit *u, struct IORequest *io)
break;
default:
debugval(PISCSI_DBG_VAL1, scsi->scsi_Command[0]);
debug(PISCSI_DBG_MSG, DBG_SCSI_UNKNOWN_COMMAND);
KPrintF("Unknown/unhandled SCSI command %lx.\n", scsi->scsi_Command[0]);
err = HFERR_BadStatus;
break;
}
if (err != 0) {
debugval(PISCSI_DBG_VAL1, err);
debug(PISCSI_DBG_MSG, DBG_SCSIERR);
KPrintF("Some SCSI error occured: %ld\n", err);
scsi->scsi_Actual = 0;
}
@@ -521,6 +554,10 @@ uint8_t piscsi_perform_io(struct piscsi_unit *u, struct IORequest *io) {
return io->io_Error;
}
debugval(PISCSI_DBG_VAL1, io->io_Command);
debugval(PISCSI_DBG_VAL2, io->io_Flags);
debugval(PISCSI_DBG_VAL3, iostd->io_Length);
debug(PISCSI_DBG_MSG, DBG_IOCMD);
//KPrintF("cmd: %s\n",cmd_name(io->io_Command));
//KPrintF("IO %lx Start, io_Flags = %ld, io_Command = %ld\n", io, io->io_Flags, io->io_Command);
@@ -569,7 +606,7 @@ uint8_t piscsi_perform_io(struct piscsi_unit *u, struct IORequest *io) {
break;
default: {
int cmd = io->io_Command;
KPrintF("Unknown IO command: %ld\n", cmd);
debug(PISCSI_DBG_MSG, DBG_IOCMD_UNHANDLED);
err = IOERR_NOCMD;
break;
}

BIN
platforms/amiga/piscsi/device_driver_amiga/scsi.device
View File

Binary file not shown.

29
platforms/amiga/piscsi/piscsi-enums.h
View File

@@ -32,5 +32,32 @@ enum piscsi_cmds {
PISCSI_CMD_ADDR4 = 0x1C,
PISCSI_CMD_DEBUGME = 0x20,
PISCSI_CMD_DRIVER = 0x40,
PISCSI_DBG_MSG = 0x1000,
PISCSI_DBG_VAL1 = 0x1010,
PISCSI_DBG_VAL2 = 0x1014,
PISCSI_DBG_VAL3 = 0x1018,
PISCSI_DBG_VAL4 = 0x101C,
PISCSI_DBG_VAL5 = 0x1020,
PISCSI_DBG_VAL6 = 0x1024,
PISCSI_DBG_VAL7 = 0x1028,
PISCSI_DBG_VAL8 = 0x102C,
PISCSI_CMD_ROM = 0x4000,
};
};
enum piscsi_dbg_msgs {
DBG_INIT,
DBG_OPENDEV,
DBG_CLOSEDEV,
DBG_CHS,
DBG_IOCMD,
DBG_CLEANUP,
DBG_BEGINIO,
DBG_ABORTIO,
DBG_SCSICMD,
DBG_SCSI_FORMATDEVICE,
DBG_SCSI_RDG,
DBG_SCSI_UNKNOWN_MODESENSE,
DBG_SCSI_UNKNOWN_COMMAND,
DBG_SCSIERR,
DBG_IOCMD_UNHANDLED,
};

222
platforms/amiga/piscsi/piscsi.c
View File

@@ -16,6 +16,7 @@
struct piscsi_dev devs[8];
uint8_t piscsi_cur_drive = 0;
uint32_t piscsi_u32[4];
uint32_t piscsi_dbg[8];
uint32_t piscsi_rom_size = 0;
uint8_t *piscsi_rom_ptr;
@@ -31,6 +32,7 @@ static const char *op_type_names[4] = {
void piscsi_init() {
for (int i = 0; i < 8; i++) {
devs[i].fd = -1;
devs[i].lba = 0;
devs[i].c = devs[i].h = devs[i].s = 0;
}
@@ -85,6 +87,136 @@ void piscsi_unmap_drive(uint8_t index) {
}
}
#define TDF_EXTCOM (1<<15)
#define CMD_INVALID 0
#define CMD_RESET 1
#define CMD_READ 2
#define CMD_WRITE 3
#define CMD_UPDATE 4
#define CMD_CLEAR 5
#define CMD_STOP 6
#define CMD_START 7
#define CMD_FLUSH 8
#define CMD_NONSTD 9
#define TD_MOTOR (CMD_NONSTD+0)
#define TD_SEEK (CMD_NONSTD+1)
#define TD_FORMAT (CMD_NONSTD+2)
#define TD_REMOVE (CMD_NONSTD+3)
#define TD_CHANGENUM (CMD_NONSTD+4)
#define TD_CHANGESTATE (CMD_NONSTD+5)
#define TD_PROTSTATUS (CMD_NONSTD+6)
#define TD_RAWREAD (CMD_NONSTD+7)
#define TD_RAWWRITE (CMD_NONSTD+8)
#define TD_GETDRIVETYPE (CMD_NONSTD+9)
#define TD_GETNUMTRACKS (CMD_NONSTD+10)
#define TD_ADDCHANGEINT (CMD_NONSTD+11)
#define TD_REMCHANGEINT (CMD_NONSTD+12)
#define TD_GETGEOMETRY (CMD_NONSTD+13)
#define TD_EJECT (CMD_NONSTD+14)
#define TD_LASTCOMM (CMD_NONSTD+15)
#define ETD_WRITE (CMD_WRITE|TDF_EXTCOM)
#define ETD_READ (CMD_READ|TDF_EXTCOM)
#define ETD_MOTOR (TD_MOTOR|TDF_EXTCOM)
#define ETD_SEEK (TD_SEEK|TDF_EXTCOM)
#define ETD_FORMAT (TD_FORMAT|TDF_EXTCOM)
#define ETD_UPDATE (CMD_UPDATE|TDF_EXTCOM)
#define ETD_CLEAR (CMD_CLEAR|TDF_EXTCOM)
#define ETD_RAWREAD (TD_RAWREAD|TDF_EXTCOM)
#define ETD_RAWWRITE (TD_RAWWRITE|TDF_EXTCOM)
#define HD_SCSICMD 28
char *io_cmd_name(int index) {
switch (index) {
case CMD_INVALID: return "INVALID";
case CMD_RESET: return "RESET";
case CMD_READ: return "READ";
case CMD_WRITE: return "WRITE";
case CMD_UPDATE: return "UPDATE";
case CMD_CLEAR: return "CLEAR";
case CMD_STOP: return "STOP";
case CMD_START: return "START";
case CMD_FLUSH: return "FLUSH";
case TD_MOTOR: return "TD_MOTOR";
case TD_SEEK: return "SEEK";
case TD_FORMAT: return "FORMAT";
case TD_REMOVE: return "REMOVE";
case TD_CHANGENUM: return "CHANGENUM";
case TD_CHANGESTATE: return "CHANGESTATE";
case TD_PROTSTATUS: return "PROTSTATUS";
case TD_RAWREAD: return "RAWREAD";
case TD_RAWWRITE: return "RAWWRITE";
case TD_GETDRIVETYPE: return "GETDRIVETYPE";
case TD_GETNUMTRACKS: return "GETNUMTRACKS";
case TD_ADDCHANGEINT: return "ADDCHANGEINT";
case TD_REMCHANGEINT: return "REMCHANGEINT";
case TD_GETGEOMETRY: return "GETGEOMETRY";
case TD_EJECT: return "EJECT";
case TD_LASTCOMM: return "LASTCOMM";
case HD_SCSICMD: return "HD_SCSICMD";
default:
return "!!!Unhandled IO command";
}
}
char *scsi_cmd_name(int index) {
switch(index) {
case 0x00: return "TEST UNIT READY";
case 0x12: return "INQUIRY";
case 0x08: return "READ";
case 0x0A: return "WRITE";
case 0x25: return "READ CAPACITY";
case 0x1A: return "MODE SENSE";
case 0x37: return "READ DEFECT DATA";
default:
return "!!!Unhandled SCSI command";
}
}
void print_piscsi_debug_message(int index) {
switch (index) {
case DBG_INIT:
printf("[PISCSI] Initializing devices.\n");
break;
case DBG_OPENDEV:
printf("[PISCSI] Opening device %d (%d). Flags: %d (%.2X)\n", piscsi_dbg[0], piscsi_dbg[1], piscsi_dbg[2], piscsi_dbg[2]);
break;
case DBG_CLEANUP:
printf("[PISCSI] Cleaning up.\n");
break;
case DBG_CHS:
printf("[PISCSI] C/H/S: %d / %d / %d\n", piscsi_dbg[0], piscsi_dbg[1], piscsi_dbg[2]);
break;
case DBG_BEGINIO:
printf("[PISCSI] BeginIO: io_Command: %d - io_Flags = %d - quick: %d\n", piscsi_dbg[0], piscsi_dbg[1], piscsi_dbg[2]);
break;
case DBG_ABORTIO:
printf("[PISCSI] AbortIO!\n");
break;
case DBG_SCSICMD:
printf("[PISCSI] SCSI Command %d (%s)\n", piscsi_dbg[1], scsi_cmd_name(piscsi_dbg[1]));
printf("Len: %d - %.2X %.2X %.2X - Command Length: %d\n", piscsi_dbg[0], piscsi_dbg[1], piscsi_dbg[2], piscsi_dbg[3], piscsi_dbg[4]);
break;
case DBG_SCSI_UNKNOWN_MODESENSE:
printf("SCSI: Unknown modesense %.4X\n", piscsi_dbg[0]);
break;
case DBG_SCSI_UNKNOWN_COMMAND:
printf("SCSI: Unknown command %.4X\n", piscsi_dbg[0]);
break;
case DBG_SCSIERR:
printf("SCSI: An error occured: %.4X\n", piscsi_dbg[0]);
break;
case DBG_IOCMD:
printf("[PISCSI] IO Command %d (%s)\n", piscsi_dbg[0], io_cmd_name(piscsi_dbg[0]));
break;
case DBG_IOCMD_UNHANDLED:
printf("[PISCSI] WARN: IO command %d (%s) is unhandled by driver.\n", piscsi_dbg[0], io_cmd_name(piscsi_dbg[0]));
}
}
extern struct emulator_config *cfg;
extern void stop_cpu_emulation(uint8_t disasm_cur);
@@ -95,11 +227,13 @@ void handle_piscsi_write(uint32_t addr, uint32_t val, uint8_t type) {
switch (addr & 0xFFFF) {
case PISCSI_CMD_READ:
d = &devs[val];
if (d->fd == -1) {
printf ("[PISCSI] BUG: Attempted read from unmapped drive %d.\n", piscsi_cur_drive);
break;
}
printf("[PISCSI] %d byte READ from block %d to address %.8X\n", piscsi_u32[1], piscsi_u32[0], piscsi_u32[2]);
d->lba = piscsi_u32[0];
r = get_mapped_item_by_address(cfg, piscsi_u32[2]);
if (r != -1 && cfg->map_type[r] == MAPTYPE_RAM) {
printf("[PISCSI] \"DMA\" Read goes to mapped range %d.\n", r);
@@ -119,11 +253,13 @@ void handle_piscsi_write(uint32_t addr, uint32_t val, uint8_t type) {
}
break;
case PISCSI_CMD_WRITE:
d = &devs[val];
if (d->fd == -1) {
printf ("[PISCSI] BUG: Attempted write to unmapped drive %d.\n", piscsi_cur_drive);
break;
}
printf("[PISCSI] %d byte WRITE to block %d to address %.8X\n", piscsi_u32[1], piscsi_u32[0], piscsi_u32[2]);
d->lba = piscsi_u32[0];
printf("[PISCSI] %d byte WRITE to block %d from address %.8X\n", piscsi_u32[1], piscsi_u32[0], piscsi_u32[2]);
r = get_mapped_item_by_address(cfg, piscsi_u32[2]);
if (r != -1) {
printf("[PISCSI] \"DMA\" Write comes from mapped range %d.\n", r);
@@ -142,22 +278,11 @@ void handle_piscsi_write(uint32_t addr, uint32_t val, uint8_t type) {
}
}
break;
case PISCSI_CMD_ADDR1:
piscsi_u32[0] = val;
printf("[PISCSI] Write to ADDR1: %.8x\n", piscsi_u32[0]);
break;
case PISCSI_CMD_ADDR2:
piscsi_u32[1] = val;
printf("[PISCSI] Write to ADDR2: %.8x\n", piscsi_u32[1]);
break;
case PISCSI_CMD_ADDR3:
piscsi_u32[2] = val;
printf("[PISCSI] Write to ADDR3: %.8x\n", piscsi_u32[2]);
break;
case PISCSI_CMD_ADDR4:
piscsi_u32[3] = val;
printf("[PISCSI] Write to ADDR4: %.8x\n", piscsi_u32[3]);
case PISCSI_CMD_ADDR1: case PISCSI_CMD_ADDR2: case PISCSI_CMD_ADDR3: case PISCSI_CMD_ADDR4: {
int i = ((addr & 0xFFFF) - PISCSI_CMD_ADDR1) / 4;
piscsi_u32[i] = val;
break;
}
case PISCSI_CMD_DRVNUM:
if (val != 0) {
if (val < 10) // Kludge for GiggleDisk
@@ -172,7 +297,7 @@ void handle_piscsi_write(uint32_t addr, uint32_t val, uint8_t type) {
printf("[PISCSI] (%s) Drive number set to %d (%d)\n", op_type_names[type], piscsi_cur_drive, val);
break;
case PISCSI_CMD_DEBUGME:
printf("[PISCSI] DebugMe triggered.\n");
printf("[PISCSI] DebugMe triggered (%d).\n", val);
stop_cpu_emulation(1);
break;
case PISCSI_CMD_DRIVER: {
@@ -216,66 +341,28 @@ void handle_piscsi_write(uint32_t addr, uint32_t val, uint8_t type) {
}
break;
}
case PISCSI_DBG_VAL1: case PISCSI_DBG_VAL2: case PISCSI_DBG_VAL3: case PISCSI_DBG_VAL4:
case PISCSI_DBG_VAL5: case PISCSI_DBG_VAL6: case PISCSI_DBG_VAL7: case PISCSI_DBG_VAL8: {
int i = ((addr & 0xFFFF) - PISCSI_DBG_VAL1) / 4;
piscsi_dbg[i] = val;
break;
}
case PISCSI_DBG_MSG:
print_piscsi_debug_message(val);
break;
default:
printf("[PISCSI] Unhandled %s register write to %.8X: %d\n", op_type_names[type], addr, val);
printf("[PISCSI] WARN: Unhandled %s register write to %.8X: %d\n", op_type_names[type], addr, val);
break;
}
}
uint8_t piscsi_diag_area[] = {
0x90,
0x00,
0x00, 0x40,
0x2C, 0x00,
0x2C, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
};
uint8_t fastata_diag_area[] = {
0x90,
0x00,
0x00, 0x10,
0x9e, 0x08,
0x00, 0x00,
0x00, 0x00,
0x00, 0x02,
0x00, 0x00,
};
uint8_t piscsi_diag_read;
#define PIB 0x00
uint32_t handle_piscsi_read(uint32_t addr, uint8_t type) {
if (type) {}
uint8_t *diag_area = piscsi_diag_area;
if ((addr & 0xFFFF) >= PISCSI_CMD_ROM) {
uint32_t romoffs = (addr & 0xFFFF) - PISCSI_CMD_ROM;
/*if (romoffs < 14 && !piscsi_diag_read) {
printf("[PISCSI] %s read from DiagArea @$%.4X: ", op_type_names[type], romoffs);
uint32_t v = 0;
switch (type) {
case OP_TYPE_BYTE:
v = diag_area[romoffs];
printf("%.2X\n", v);
break;
case OP_TYPE_WORD:
v = *((uint16_t *)&diag_area[romoffs]);
printf("%.4X\n", v);
break;
case OP_TYPE_LONGWORD:
v = (*((uint16_t *)&diag_area[romoffs]) << 16) | *((uint16_t *)&diag_area[romoffs + 2]);
//v = *((uint32_t *)&diag_area[romoffs]);
printf("%.8X\n", v);
break;
}
if (romoffs == 0x0D)
piscsi_diag_read = 1;
return v;
}*/
if (romoffs < (piscsi_rom_size + PIB)) {
printf("[PISCSI] %s read from Boot ROM @$%.4X (%.8X): ", op_type_names[type], romoffs, addr);
uint32_t v = 0;
@@ -289,7 +376,6 @@ uint32_t handle_piscsi_read(uint32_t addr, uint8_t type) {
printf("%.4X\n", v);
break;
case OP_TYPE_LONGWORD:
//v = (*((uint16_t *)&piscsi_rom_ptr[romoffs - 14]) << 16) | *((uint16_t *)&piscsi_rom_ptr[romoffs - 12]);
v = be32toh(*((uint32_t *)&piscsi_rom_ptr[romoffs - PIB]));
printf("%.8X\n", v);
break;
@@ -337,7 +423,3 @@ uint32_t handle_piscsi_read(uint32_t addr, uint8_t type) {
return 0;
}
void piscsi_block_op(uint8_t type, uint8_t num, uint32_t dest, uint32_t len) {
if (type || num || dest || len) {}
}

1
platforms/amiga/piscsi/piscsi.h
View File

@@ -11,4 +11,5 @@ struct piscsi_dev {
uint16_t h, s;
uint64_t fs;
int32_t fd;
uint32_t lba;
};

BIN
platforms/amiga/piscsi/piscsi.rom
View File

Binary file not shown.