From: beeanyew Date: Wed, 3 Feb 2021 11:26:19 +0000 (+0100) Subject: Fix PiSCSI device selection bug X-Git-Url: https://git.sesse.net/?a=commitdiff_plain;h=ed138fbd47db1ffd8bdd8494053d60111d8f3d86;p=pistorm Fix PiSCSI device selection bug --- diff --git a/README.md b/README.md index 0753d3b..522176c 100644 --- a/README.md +++ b/README.md @@ -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 : diff --git a/platforms/amiga/amiga-platform.c b/platforms/amiga/amiga-platform.c index da302ac..6404695 100644 --- a/platforms/amiga/amiga-platform.c +++ b/platforms/amiga/amiga-platform.c @@ -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); } diff --git a/platforms/amiga/piscsi/device_driver_amiga/2nd.scsi.device b/platforms/amiga/piscsi/device_driver_amiga/2nd.scsi.device index 3454d1b..6358127 100644 Binary files a/platforms/amiga/piscsi/device_driver_amiga/2nd.scsi.device and b/platforms/amiga/piscsi/device_driver_amiga/2nd.scsi.device differ diff --git a/platforms/amiga/piscsi/device_driver_amiga/bootrom b/platforms/amiga/piscsi/device_driver_amiga/bootrom index 15361d1..1bfe546 100644 Binary files a/platforms/amiga/piscsi/device_driver_amiga/bootrom and b/platforms/amiga/piscsi/device_driver_amiga/bootrom differ diff --git a/platforms/amiga/piscsi/device_driver_amiga/bootrom.s b/platforms/amiga/piscsi/device_driver_amiga/bootrom.s index a8e8a5a..10ffdd4 100644 --- a/platforms/amiga/piscsi/device_driver_amiga/bootrom.s +++ b/platforms/amiga/piscsi/device_driver_amiga/bootrom.s @@ -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 - 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. ; - rts + 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 - ; Rest of your position-independent device code goes here. + moveq.l #1,d0 ; indicate "success" + rts END diff --git a/platforms/amiga/piscsi/device_driver_amiga/pi-scsi.device b/platforms/amiga/piscsi/device_driver_amiga/pi-scsi.device index fdf0587..cf48268 100644 Binary files a/platforms/amiga/piscsi/device_driver_amiga/pi-scsi.device and b/platforms/amiga/piscsi/device_driver_amiga/pi-scsi.device differ diff --git a/platforms/amiga/piscsi/device_driver_amiga/piscsi-amiga.c b/platforms/amiga/piscsi/device_driver_amiga/piscsi-amiga.c index 6b387be..be3738e 100644 --- a/platforms/amiga/piscsi/device_driver_amiga/piscsi-amiga.c +++ b/platforms/amiga/piscsi/device_driver_amiga/piscsi-amiga.c @@ -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; } diff --git a/platforms/amiga/piscsi/device_driver_amiga/scsi.device b/platforms/amiga/piscsi/device_driver_amiga/scsi.device index d148877..fdc4381 100644 Binary files a/platforms/amiga/piscsi/device_driver_amiga/scsi.device and b/platforms/amiga/piscsi/device_driver_amiga/scsi.device differ diff --git a/platforms/amiga/piscsi/piscsi-enums.h b/platforms/amiga/piscsi/piscsi-enums.h index ae6ee64..04dfa18 100644 --- a/platforms/amiga/piscsi/piscsi-enums.h +++ b/platforms/amiga/piscsi/piscsi-enums.h @@ -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, -}; \ No newline at end of file +}; + +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, +}; diff --git a/platforms/amiga/piscsi/piscsi.c b/platforms/amiga/piscsi/piscsi.c index f24fddf..9f9500b 100644 --- a/platforms/amiga/piscsi/piscsi.c +++ b/platforms/amiga/piscsi/piscsi.c @@ -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) {} -} diff --git a/platforms/amiga/piscsi/piscsi.h b/platforms/amiga/piscsi/piscsi.h index b0148e2..562b81f 100644 --- a/platforms/amiga/piscsi/piscsi.h +++ b/platforms/amiga/piscsi/piscsi.h @@ -11,4 +11,5 @@ struct piscsi_dev { uint16_t h, s; uint64_t fs; int32_t fd; + uint32_t lba; }; diff --git a/platforms/amiga/piscsi/piscsi.rom b/platforms/amiga/piscsi/piscsi.rom index 96db6f6..1f2bb2d 100644 Binary files a/platforms/amiga/piscsi/piscsi.rom and b/platforms/amiga/piscsi/piscsi.rom differ