cdrom: cleanup, support errors, improve timing

[pcsx_rearmed.git] / libpcsxcore / cdrom.c

diff --git a/libpcsxcore/cdrom.c b/libpcsxcore/cdrom.c
index 95e1f05..ab56734 100644 (file)
--- a/libpcsxcore/cdrom.c
+++ b/libpcsxcore/cdrom.c
@@ -76,6 +76,7 @@ static unsigned char *pTransfer;
 #define CdlID          26
 #define CdlReadS       27
 #define CdlReset       28
 #define CdlID          26
 #define CdlReadS       27
 #define CdlReset       28

+#define CdlGetQ        29

 #define CdlReadToc     30
 
 char *CmdName[0x100]= {
 #define CdlReadToc     30
 
 char *CmdName[0x100]= {


@@ -124,6 +125,10 @@ unsigned char Test23[] = { 0x43, 0x58, 0x44, 0x32, 0x39 ,0x34, 0x30, 0x51 };
 #define STATUS_ROTATING  (1<<1) // 0x02
 #define STATUS_ERROR     (1<<0) // 0x01
 
 #define STATUS_ROTATING  (1<<1) // 0x02
 #define STATUS_ERROR     (1<<0) // 0x01
 

+/* Errors */
+#define ERROR_NOT_READY  (1<<7) // 0x80
+#define ERROR_INVALIDCMD (1<<6) // 0x40
+#define ERROR_INVALIDARG (1<<5) // 0x20

 
 // 1x = 75 sectors per second
 // PSXCLK = 1 sec in the ps
 
 // 1x = 75 sectors per second
 // PSXCLK = 1 sec in the ps


@@ -135,6 +140,7 @@ enum drive_state {
        DRIVESTATE_LID_OPEN,
        DRIVESTATE_RESCAN_CD,
        DRIVESTATE_PREPARE_CD,
        DRIVESTATE_LID_OPEN,
        DRIVESTATE_RESCAN_CD,
        DRIVESTATE_PREPARE_CD,

+       DRIVESTATE_STOPPED,

 };
 
 // for cdr.Seeked
 };
 
 // for cdr.Seeked


@@ -405,9 +411,16 @@ static void ReadTrack(const u8 *time) {
                cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
 }
 
                cdr.subq.Absolute[0], cdr.subq.Absolute[1], cdr.subq.Absolute[2]);
 }
 

-static void AddIrqQueue(unsigned char irq, unsigned long ecycle) {
-       if (cdr.Irq != 0)
+static void AddIrqQueue(unsigned short irq, unsigned long ecycle) {
+       if (cdr.Irq != 0) {
+               if (irq == cdr.Irq || irq + 0x100 == cdr.Irq) {
+                       cdr.IrqRepeated = 1;
+                       CDR_INT(ecycle);
+                       return;
+               }
+

                CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);
                CDR_LOG_I("cdr: override cmd %02x -> %02x\n", cdr.Irq, irq);

+       }

 
        cdr.Irq = irq;
        cdr.eCycle = ecycle;
 
        cdr.Irq = irq;
        cdr.eCycle = ecycle;


@@ -517,8 +530,11 @@ void cdrPlayInterrupt()
 }
 
 void cdrInterrupt() {
 }
 
 void cdrInterrupt() {

-       int i;
-       unsigned char Irq = cdr.Irq;
+       u16 Irq = cdr.Irq;
+       int no_busy_error = 0;
+       int start_rotating = 0;
+       int error = 0;
+       int delay;

 
        // Reschedule IRQ
        if (cdr.Stat) {
 
        // Reschedule IRQ
        if (cdr.Stat) {


@@ -527,32 +543,35 @@ void cdrInterrupt() {
                return;
        }
 
                return;
        }
 

-       cdr.Irq = 0;

        cdr.Ctrl &= ~0x80;
 
        cdr.Ctrl &= ~0x80;
 

+       // default response
+       SetResultSize(1);
+       cdr.Result[0] = cdr.StatP;
+       cdr.Stat = Acknowledge;
+
+       if (cdr.IrqRepeated) {
+               cdr.IrqRepeated = 0;
+               if (cdr.eCycle > psxRegs.cycle) {
+                       CDR_INT(cdr.eCycle);
+                       goto finish;
+               }
+       }
+
+       cdr.Irq = 0;
+

        switch (Irq) {
                case CdlSync:
        switch (Irq) {
                case CdlSync:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
+                       // TOOD: sometimes/always return error?

                        break;
 
                case CdlNop:
                        break;
 
                case CdlNop:

-                       SetResultSize(1);
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
-

                        if (cdr.DriveState != DRIVESTATE_LID_OPEN)
                                cdr.StatP &= ~STATUS_SHELLOPEN;
                        if (cdr.DriveState != DRIVESTATE_LID_OPEN)
                                cdr.StatP &= ~STATUS_SHELLOPEN;

+                       no_busy_error = 1;

                        break;
 
                case CdlSetloc:
                        break;
 
                case CdlSetloc:

-                       cdr.CmdProcess = 0;
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;

                        break;
 
                case CdlPlay:
                        break;
 
                case CdlPlay:


@@ -604,30 +623,21 @@ void cdrInterrupt() {
 
                        // Vib Ribbon: gameplay checks flag
                        cdr.StatP &= ~STATUS_SEEK;
 
                        // Vib Ribbon: gameplay checks flag
                        cdr.StatP &= ~STATUS_SEEK;

-
-                       cdr.CmdProcess = 0;
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;

                        cdr.Result[0] = cdr.StatP;
                        cdr.Result[0] = cdr.StatP;

-                       cdr.Stat = Acknowledge;

 
                        cdr.StatP |= STATUS_PLAY;
 
                        cdr.StatP |= STATUS_PLAY;

-

                        
                        // BIOS player - set flag again
                        cdr.Play = TRUE;
 
                        CDRMISC_INT( cdReadTime );
                        
                        // BIOS player - set flag again
                        cdr.Play = TRUE;
 
                        CDRMISC_INT( cdReadTime );

+                       start_rotating = 1;

                        break;
 
                case CdlForward:
                        break;
 
                case CdlForward:

-                       cdr.CmdProcess = 0;
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
+                       // TODO: error 80 if stopped

                        cdr.Stat = Complete;
 
                        cdr.Stat = Complete;
 

-

                        // GameShark CD Player: Calls 2x + Play 2x
                        if( cdr.FastForward == 0 ) cdr.FastForward = 2;
                        else cdr.FastForward++;
                        // GameShark CD Player: Calls 2x + Play 2x
                        if( cdr.FastForward == 0 ) cdr.FastForward = 2;
                        else cdr.FastForward++;


@@ -636,13 +646,8 @@ void cdrInterrupt() {
                        break;
 
                case CdlBackward:
                        break;
 
                case CdlBackward:

-                       cdr.CmdProcess = 0;
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;

                        cdr.Stat = Complete;
 
                        cdr.Stat = Complete;
 

-

                        // GameShark CD Player: Calls 2x + Play 2x
                        if( cdr.FastBackward == 0 ) cdr.FastBackward = 2;
                        else cdr.FastBackward++;
                        // GameShark CD Player: Calls 2x + Play 2x
                        if( cdr.FastBackward == 0 ) cdr.FastBackward = 2;
                        else cdr.FastBackward++;


@@ -651,27 +656,34 @@ void cdrInterrupt() {
                        break;
 
                case CdlStandby:
                        break;
 
                case CdlStandby:

-                       cdr.CmdProcess = 0;
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
+                       if (cdr.DriveState != DRIVESTATE_STOPPED) {
+                               error = ERROR_INVALIDARG;
+                               goto set_error;
+                       }
+                       AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2);
+                       start_rotating = 1;
+                       break;
+
+               case CdlStandby + 0x100:

                        cdr.Stat = Complete;
                        break;
 
                case CdlStop:
                        cdr.Stat = Complete;
                        break;
 
                case CdlStop:

-                       cdr.CmdProcess = 0;
-                       SetResultSize(1);
+                       delay = 0x800;
+                       if (cdr.DriveState == DRIVESTATE_STANDBY)
+                               delay = cdReadTime * 30 / 2;
+
+                       cdr.DriveState = DRIVESTATE_STOPPED;
+                       AddIrqQueue(CdlStop + 0x100, delay);
+                       break;
+
+               case CdlStop + 0x100:

                        cdr.StatP &= ~STATUS_ROTATING;
                        cdr.Result[0] = cdr.StatP;
                        cdr.Stat = Complete;
                        cdr.StatP &= ~STATUS_ROTATING;
                        cdr.Result[0] = cdr.StatP;
                        cdr.Stat = Complete;

-//                     cdr.Stat = Acknowledge;

                        break;
 
                case CdlPause:
                        break;
 
                case CdlPause:

-                       SetResultSize(1);
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
-

                        /*
                        Gundam Battle Assault 2: much slower (*)
                        - Fixes boot, gameplay
                        /*
                        Gundam Battle Assault 2: much slower (*)
                        - Fixes boot, gameplay


@@ -682,80 +694,52 @@ void cdrInterrupt() {
                        InuYasha - Feudal Fairy Tale: slower
                        - Fixes battles
                        */
                        InuYasha - Feudal Fairy Tale: slower
                        - Fixes battles
                        */

-                       AddIrqQueue(CdlPause + 0x20, cdReadTime * 3);
+                       AddIrqQueue(CdlPause + 0x100, cdReadTime * 3);

                        cdr.Ctrl |= 0x80;
                        break;
 
                        cdr.Ctrl |= 0x80;
                        break;
 

-               case CdlPause + 0x20:
-                       SetResultSize(1);
+               case CdlPause + 0x100:

                        cdr.StatP &= ~STATUS_READ;
                        cdr.StatP &= ~STATUS_READ;

-                       cdr.StatP |= STATUS_ROTATING;

                        cdr.Result[0] = cdr.StatP;
                        cdr.Stat = Complete;
                        break;
 
                case CdlInit:
                        cdr.Result[0] = cdr.StatP;
                        cdr.Stat = Complete;
                        break;
 
                case CdlInit:

-                       SetResultSize(1);
-                       cdr.StatP = STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
-//                     if (!cdr.Init) {
-                               AddIrqQueue(CdlInit + 0x20, 0x800);
-//                     }
-               break;
+                       AddIrqQueue(CdlInit + 0x100, cdReadTime * 6);
+                       no_busy_error = 1;
+                       start_rotating = 1;
+                       break;

 
 

-               case CdlInit + 0x20:
-                       SetResultSize(1);
-                       cdr.Result[0] = cdr.StatP;
+               case CdlInit + 0x100:

                        cdr.Stat = Complete;
                        cdr.Stat = Complete;

-                       cdr.Init = 1;

                        break;
 
                case CdlMute:
                        break;
 
                case CdlMute:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;

                        break;
 
                case CdlDemute:
                        break;
 
                case CdlDemute:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;

                        break;
 
                case CdlSetfilter:
                        break;
 
                case CdlSetfilter:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge; 

                        break;
 
                case CdlSetmode:
                        break;
 
                case CdlSetmode:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
+                       no_busy_error = 1;

                        break;
 
                case CdlGetmode:
                        SetResultSize(6);
                        break;
 
                case CdlGetmode:
                        SetResultSize(6);

-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;

                        cdr.Result[1] = cdr.Mode;
                        cdr.Result[2] = cdr.File;
                        cdr.Result[3] = cdr.Channel;
                        cdr.Result[4] = 0;
                        cdr.Result[5] = 0;
                        cdr.Result[1] = cdr.Mode;
                        cdr.Result[2] = cdr.File;
                        cdr.Result[3] = cdr.Channel;
                        cdr.Result[4] = 0;
                        cdr.Result[5] = 0;

-                       cdr.Stat = Acknowledge;
+                       no_busy_error = 1;

                        break;
 
                case CdlGetlocL:
                        SetResultSize(8);
                        break;
 
                case CdlGetlocL:
                        SetResultSize(8);

-                       for (i = 0; i < 8; i++)
-                               cdr.Result[i] = cdr.Transfer[i];
-                       cdr.Stat = Acknowledge;
+                       memcpy(cdr.Result, cdr.Transfer, 8);

                        break;
 
                case CdlGetlocP:
                        break;
 
                case CdlGetlocP:


@@ -764,15 +748,20 @@ void cdrInterrupt() {
 
                        if (!cdr.Play && !cdr.Reading)
                                cdr.Result[1] = 0; // HACK?
 
                        if (!cdr.Play && !cdr.Reading)
                                cdr.Result[1] = 0; // HACK?

+                       break;

 
 

-                       cdr.Stat = Acknowledge;
+               case CdlReadT: // SetSession?
+                       // really long
+                       AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4);
+                       start_rotating = 1;
+                       break;
+
+               case CdlReadT + 0x100:
+                       cdr.Stat = Complete;

                        break;
 
                case CdlGetTN:
                        break;
 
                case CdlGetTN:

-                       cdr.CmdProcess = 0;

                        SetResultSize(3);
                        SetResultSize(3);

-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;

                        if (CDR_getTN(cdr.ResultTN) == -1) {
                                cdr.Stat = DiskError;
                                cdr.Result[0] |= STATUS_ERROR;
                        if (CDR_getTN(cdr.ResultTN) == -1) {
                                cdr.Stat = DiskError;
                                cdr.Result[0] |= STATUS_ERROR;


@@ -784,10 +773,8 @@ void cdrInterrupt() {
                        break;
 
                case CdlGetTD:
                        break;
 
                case CdlGetTD:

-                       cdr.CmdProcess = 0;

                        cdr.Track = btoi(cdr.Param[0]);
                        SetResultSize(4);
                        cdr.Track = btoi(cdr.Param[0]);
                        SetResultSize(4);

-                       cdr.StatP |= STATUS_ROTATING;

                        if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
                                cdr.Stat = DiskError;
                                cdr.Result[0] |= STATUS_ERROR;
                        if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) {
                                cdr.Stat = DiskError;
                                cdr.Result[0] |= STATUS_ERROR;


@@ -802,11 +789,7 @@ void cdrInterrupt() {
 
                case CdlSeekL:
                case CdlSeekP:
 
                case CdlSeekL:
                case CdlSeekP:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;

                        cdr.StatP |= STATUS_SEEK;
                        cdr.StatP |= STATUS_SEEK;

-                       cdr.Stat = Acknowledge;

 
                        /*
                        Crusaders of Might and Magic = 0.5x-4x
 
                        /*
                        Crusaders of Might and Magic = 0.5x-4x


@@ -823,10 +806,10 @@ void cdrInterrupt() {
                        */
                        CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
                        cdr.Seeked = SEEK_PENDING;
                        */
                        CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4);
                        cdr.Seeked = SEEK_PENDING;

+                       start_rotating = 1;

                        break;
 
                case CdlTest:
                        break;
 
                case CdlTest:

-                       cdr.Stat = Acknowledge;

                        switch (cdr.Param[0]) {
                                case 0x20: // System Controller ROM Version
                                        SetResultSize(4);
                        switch (cdr.Param[0]) {
                                case 0x20: // System Controller ROM Version
                                        SetResultSize(4);


@@ -841,17 +824,14 @@ void cdrInterrupt() {
                                        memcpy(cdr.Result, Test23, 4);
                                        break;
                        }
                                        memcpy(cdr.Result, Test23, 4);
                                        break;
                        }

+                       no_busy_error = 1;

                        break;
 
                case CdlID:
                        break;
 
                case CdlID:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
-                       AddIrqQueue(CdlID + 0x20, 0x800);
+                       AddIrqQueue(CdlID + 0x100, 20480);

                        break;
 
                        break;
 

-               case CdlID + 0x20:
+               case CdlID + 0x100:

                        SetResultSize(8);
                        cdr.Result[0] = cdr.StatP;
                        cdr.Result[1] = 0;
                        SetResultSize(8);
                        cdr.Result[0] = cdr.StatP;
                        cdr.Result[1] = 0;


@@ -875,40 +855,28 @@ void cdrInterrupt() {
                        break;
 
                case CdlReset:
                        break;
 
                case CdlReset:

-                       SetResultSize(1);
-                       cdr.StatP = STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
+                       // yes, it really sets STATUS_SHELLOPEN
+                       cdr.StatP |= STATUS_SHELLOPEN;
+                       cdr.DriveState = DRIVESTATE_RESCAN_CD;
+                       CDRLID_INT(20480);
+                       no_busy_error = 1;
+                       start_rotating = 1;

                        break;
 
                        break;
 

-               case CdlReadT:
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
-                       AddIrqQueue(CdlReadT + 0x20, 0x800);
-                       break;
-
-               case CdlReadT + 0x20:
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Complete;
+               case CdlGetQ:
+                       // TODO?
+                       CDR_LOG_I("got CdlGetQ\n");

                        break;
 
                case CdlReadToc:
                        break;
 
                case CdlReadToc:

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
-                       cdr.Stat = Acknowledge;
-                       AddIrqQueue(CdlReadToc + 0x20, cdReadTime * 16);
+                       AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4);
+                       no_busy_error = 1;
+                       start_rotating = 1;

                        break;
 
                        break;
 

-               case CdlReadToc + 0x20:
-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;
-                       cdr.Result[0] = cdr.StatP;
+               case CdlReadToc + 0x100:

                        cdr.Stat = Complete;
                        cdr.Stat = Complete;

+                       no_busy_error = 1;

                        break;
 
                case CdlReadN:
                        break;
 
                case CdlReadN:


@@ -951,40 +919,54 @@ void cdrInterrupt() {
                                CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
                        }
 
                                CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1);
                        }
 

-                       SetResultSize(1);
-                       cdr.StatP |= STATUS_ROTATING;

                        cdr.Result[0] = cdr.StatP;
                        cdr.Result[0] = cdr.StatP;

-                       cdr.Stat = Acknowledge;
+                       start_rotating = 1;

                        break;
 
                default:
                        break;
 
                default:

-                       cdr.Stat = Complete;
+                       CDR_LOG_I("Invalid command: %02x\n", Irq);
+                       error = ERROR_INVALIDCMD;
+                       // FALLTHROUGH
+
+               set_error:
+                       SetResultSize(2);
+                       cdr.Result[0] = cdr.StatP | STATUS_ERROR;
+                       cdr.Result[1] = error;
+                       cdr.Stat = DiskError;

                        break;
        }
 
                        break;
        }
 

-       if (Irq != CdlNop) {
+       if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) {
+               cdr.DriveState = DRIVESTATE_STANDBY;
+               cdr.StatP |= STATUS_ROTATING;
+       }
+
+       if (!no_busy_error) {

                switch (cdr.DriveState) {
                case DRIVESTATE_LID_OPEN:
                case DRIVESTATE_RESCAN_CD:
                case DRIVESTATE_PREPARE_CD:
                        SetResultSize(2);
                        cdr.Result[0] = cdr.StatP | STATUS_ERROR;
                switch (cdr.DriveState) {
                case DRIVESTATE_LID_OPEN:
                case DRIVESTATE_RESCAN_CD:
                case DRIVESTATE_PREPARE_CD:
                        SetResultSize(2);
                        cdr.Result[0] = cdr.StatP | STATUS_ERROR;

-                       cdr.Result[1] = 0x80;
+                       cdr.Result[1] = ERROR_NOT_READY;

                        cdr.Stat = DiskError;
                        break;
                }
        }
 
                        cdr.Stat = DiskError;
                        break;
                }
        }
 

-       cdr.ParamC = 0;
-
+finish:

        setIrq();
        setIrq();

+       cdr.ParamC = 0;

 
 #ifdef CDR_LOG_CMD_IRQ
 
 #ifdef CDR_LOG_CMD_IRQ

-       SysPrintf("IRQ %d cmd %02x stat %02x: ",
-               !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
-       for (i = 0; i < cdr.ResultC; i++)
-               SysPrintf("%02x ", cdr.Result[i]);
-       SysPrintf("\n");
+       {
+               int i;
+               SysPrintf("CDR IRQ %d cmd %02x stat %02x: ",
+                       !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat);
+               for (i = 0; i < cdr.ResultC; i++)
+                       SysPrintf("%02x ", cdr.Result[i]);
+               SysPrintf("\n");
+       }

 #endif
 }
 
 #endif
 }