Refactor libpsxcd, add new CD-ROM APIs, fix SPU DMA read

13 files changed, 1436 insertions, 1529 deletions

diff --git a/libpsn00b/include/psxcd.h b/libpsn00b/include/psxcd.h
index 8150703..503bc83 100644
--- a/libpsn00b/include/psxcd.h
+++ b/libpsn00b/include/psxcd.h
@@ -1,6 +1,6 @@
 /*
- * PSn00bSDK CD-ROM drive library
- * (C) 2019-2022 Lameguy64, spicyjpeg - MPL licensed
+ * PSn00bSDK CD-ROM library
+ * (C) 2020-2022 Lameguy64, spicyjpeg - MPL licensed
  */
 
 /**
@@ -54,7 +54,9 @@ typedef enum _CdlCommand {
 	CdlTest			= 0x19,
 	CdlGetID		= 0x1a,
 	CdlReadS		= 0x1b,
-	CdlReset		= 0x1c
+	CdlReset		= 0x1c,
+	CdlGetQ			= 0x1d,
+	CdlReadTOC		= 0x1e
 } CdlCommand;
 
 typedef enum _CdlStatFlag {
@@ -90,6 +92,15 @@ typedef enum _CdlIntrResult {
 	CdlDiskError	= 5
 } CdlIntrResult;
 
+typedef enum _CdlRegionCode {
+	CdlRegionUnknown	= 0,
+	CdlRegionSCEI		= 1,	// Japan
+	CdlRegionSCEA		= 2,	// North America
+	CdlRegionSCEE		= 3,	// Europe
+	CdlRegionSCEW		= 4,	// Wordwide (Net Yaroze)
+	CdlRegionDebug		= 5		// DebuggingStation or test console
+} CdlRegionCode;
+
 typedef enum _CdlIsoError {
 	CdlIsoOkay		= 0,
 	CdlIsoSeekError	= 1,
@@ -99,51 +110,48 @@ typedef enum _CdlIsoError {
 } CdlIsoError;
 
 /**
- * @brief Translates a BCD format value to decimal
+ * @brief Translates a BCD value to decimal.
  *
- * @details Translates a specified value in BCD format (ie. 32/0x20 = 20) into
- * a decimal integer, as the CD-ROM controller returns integer values only in
- * BCD format.
+ * @details Translates the specified value in BCD format (in 0-99 range) into
+ * a decimal integer.
  */
-#define btoi(b) ((b)/16*10+(b)%16)
+#define btoi(b) (((b) / 16 * 10) + ((b) % 16))
 
 /**
- * @brief Translates a decimal value to BCD
+ * @brief Translates a decimal value to BCD.
  *
- * @details Translates a decimal integer into a BCD format value (ie.
- * 20 = 32/0x20), as the CD-ROM controller only accepts values in BCD format.
+ * @details Translates a decimal integer in 0-99 range into a BCD format value.
  */
-#define itob(i) ((i)/10*16+(i)%10)
+#define itob(i) (((i) / 10 * 16) | ((i) % 10))
 
 /* Structure and type definitions */
 
 /**
- * @brief CD-ROM positional coordinates
+ * @brief CD-ROM MSF positional coordinates.
+ *
+ * @details This structure is used to specify CD-ROM coordinates in
+ * minutes/seconds/frames format for some commands (see CdControl()). It can
+ * be converted from/to a logical logical sector number using CdIntToPos() and
+ * CdPosToInt() respectively.
  *
- * @details This structure is used to specify CD-ROM positional coordinates for
- * CdlSetloc, CdlReadN and CdlReadS CD-ROM commands. Use CdIntToPos() to set
- * parameters from a logical sector number.
+ * NOTE: the minute, second and sector fields are in BCD format. The track
+ * field is only returned by CdGetToc() and otherwise ignored by all commands.
  *
- * @see CdIntToPos(), CdControl()
+ * @see CdIntToPos(), CdPosToInt(), CdControl()
  */
 typedef struct _CdlLOC {
 	uint8_t minute;	// Minutes (BCD)
 	uint8_t second;	// Seconds (BCD)
 	uint8_t sector;	// Sector or frame (BCD)
-	uint8_t track;	// Track number (not used)
+	uint8_t track;	// Track number
 } CdlLOC;
 
 /**
- * @brief CD-ROM attenuation parameters
- *
- * @details This structure specifies parameters for the CD-ROM attenuation.
- * Values must be of range 0 to 127.
+ * @brief CD-ROM volume mixing matrix.
  *
- * The CD-ROM attenuation can be used to set the CD-ROM audio output to mono
- * (0x40, 0x40, 0x40, 0x40) or reversed stereo (0x00, 0x80, 0x00, 0x80). It can
- * also be used to play one of two stereo channels to both speakers.
- *
- * The CD-ROM attenuation affects CD-DA and CD-XA audio.
+ * @details This structure is used to change the CD-ROM drive's volume levels
+ * using CdMix(). Each field represents a volume level as a value in 0-255
+ * range, with 128 being 100% and values above 128 distorting the output.
  *
  * @see CdMix()
  */
@@ -155,27 +163,73 @@ typedef struct _CdlATV {
 } CdlATV;
 
 /**
- * @brief File entry structure
+ * @brief File entry structure.
  *
- * @details Used to store basic information of a file such as logical block
- * location and size. Currently, CdSearchFile() is the only function that uses
- * this struct but it will be used in directory listing functions that may be
- * implemented in the future.
+ * @details This structure is used to store basic metadata of a file such as
+ * its position and size. Currently, CdSearchFile() is the only function that
+ * uses this structure.
  *
  * @see CdSearchFile()
  */
 typedef struct _CdlFILE {
-	CdlLOC		pos;		// CD-ROM position coordinates of file
-	uint32_t	size;		// Size of file in bytes
-	char		name[16];	// File name
+	CdlLOC	pos;		// CD-ROM position coordinates of file
+	int		size;		// Size of file in bytes
+	char	name[16];	// File name
 } CdlFILE;
 
 /**
- * @brief Structure used to set CD-ROM XA filter
+ * @brief Current logical location information structure.
+ *
+ * @details This structure is returned by the CdlGetlocL command and contains
+ * information about the last data sector read by the drive head, including its
+ * location as well as mode and XA attributes if any.
+ *
+ * CdlGetlocL can only be issued while reading data sectors, as CD-DA data has
+ * no headers. Use CdlGetlocP instead to obtain the current drive position when
+ * playing CD-DA.
+ *
+ * @see CdControl()
+ */
+typedef struct _CdlLOCINFOL {
+	uint8_t minute;			// Minutes (BCD)
+	uint8_t second;			// Seconds (BCD)
+	uint8_t sector;			// Sector or frame (BCD)
+	uint8_t mode;			// Sector mode (usually 2)
+	uint8_t file;			// XA file number (usually 0 or 1)
+	uint8_t chan;			// XA channel number (0-31)
+	uint8_t submode;		// XA submode
+	uint8_t coding_info;	// XA coding information (ADPCM sectors only)
+} CdlLOCINFOL;
+
+/**
+ * @brief Current physical location information structure.
+ *
+ * @details This structure is returned by the CdlGetlocP command and contains
+ * information about the current location of the drive head relative to the
+ * entire CD as well as to the beginning of the track being played or read.
+ *
+ * This information is obtained by reading subchannel Q, so CdlGetlocP works on
+ * both data and CD-DA tracks (albeit with slightly lower precision on data
+ * tracks).
+ *
+ * @see CdControl()
+ */
+typedef struct _CdlLOCINFOP {
+	uint8_t track;			// Track number (BCD)
+	uint8_t index;			// Index number (BCD, usually 1)
+	uint8_t track_minute;	// Minutes relative to beginning of track (BCD)
+	uint8_t track_second;	// Seconds relative to beginning of track (BCD)
+	uint8_t track_sector;	// Sector or frame relative to beginning of track (BCD)
+	uint8_t minute;			// Minutes (BCD)
+	uint8_t second;			// Seconds (BCD)
+	uint8_t sector;			// Sector or frame (BCD)
+} CdlLOCINFOP;
+
+/**
+ * @brief CD-ROM XA filter structure.
  *
- * @details This structure is used to specify stream filter parameters for
- * CD-ROM XA audio streaming using the CdlSetfilter command. This only affects
- * CD-ROM XA audio streaming.
+ * @details This structure is used with the CdlSetfilter command to specify
+ * sector filter parameters for XA-ADPCM audio playback.
  *
  * CD-ROM XA audio is normally comprised of up to 8 or more ADPCM compressed
  * audio streams interleaved into one continuous stream of data. The data
@@ -191,13 +245,13 @@ typedef struct _CdlFILE {
  * @see CdControl()
  */
 typedef struct _CdlFILTER {
-	uint8_t		file;	// File number to fetch (usually 1)
-	uint8_t		chan;	// Channel number (0 through 7)
-	uint16_t	pad;	// Padding
+	uint8_t		file;	// XA file number (usually 1)
+	uint8_t		chan;	// XA channel number (0-31)
+	uint16_t	pad;
 } CdlFILTER;
 
 /**
- * @brief CD-ROM directory query context handle
+ * @brief CD-ROM directory query context handle.
  *
  * @details Used to store a directory context created by CdOpenDir(). An open
  * context can then be used with CdReadDir() and closed with CdCloseDir().
@@ -206,7 +260,7 @@ typedef struct _CdlFILTER {
  */
 typedef void *CdlDIR;
 
-typedef void (*CdlCB)(int, uint8_t *);
+typedef void (*CdlCB)(CdlIntrResult, uint8_t *);
 
 /* Public API */
 
@@ -215,190 +269,230 @@ extern "C" {
 #endif
 
 /**
- * @brief Initializes the CD-ROM library
+ * @brief Initializes the CD-ROM library.
  *
  * @details Initializes the CD-ROM subsystem which includes hooking the
  * required IRQ handler, sets up internal variables of the CD-ROM library and
  * attempts to initialize the CD-ROM controller. The mode parameter does
  * nothing but may be used in future updates of this library.
  *
- * This function must be called after ResetGraph and before any other CD-ROM
- * library function that interfaces with the CD-ROM controller. This function
- * may not be called twice as it may cause instability or would just crash.
+ * This function shall only be called once after ResetGraph() or
+ * ResetCallback(), and shall not be called on systems which are known not to
+ * be equipped with a CD drive such as most PS1-based arcade boards.
  *
- * @return Always 1. May change in the future.
+ * @return 1 if the drive is ready or 0 if an error occurred
  */
 int CdInit(void);
 
 /**
- * @brief Translates a logical sector number to CD-ROM positional coordinates
+ * @brief Translates an LBA to MSF coordinates.
  *
- * @details This function translates the logical sector number from i to CD-ROM
- * positional coordinates stored to a CdlLOC struct specified by p. The
- * translation takes the lead-in offset into account so the first logical
- * sector begins at 0 and the result will be offset by 150 sectors.
+ * @details Translates the provided logical sector number to CD-ROM positional
+ * coordinates in minutes/seconds/frames format, which are stored into the
+ * provided CdlLOC structure. The translation takes the lead-in offset into
+ * account, so LBA 0 is correctly translated to 00:02:00 rather than 00:00:00.
  *
- * @param i Logical sector number
+ * @param i Logical sector number minus the 150-sector lead-in
  * @param p Pointer to a CdlLOC structure
- * @return Pointer to the specified CdlLOC struct plus 150 sectors.
+ * @return Pointer to the specified CdlLOC structure
  */
 CdlLOC* CdIntToPos(int i, CdlLOC *p);
 
 /**
- * @brief Translates CD-ROM positional coordinates to a logical sector number
+ * @brief Translates MSF coordinates to an LBA.
  *
- * @details Translates the CD-ROM position parameters from a CdlLOC struct
- * specified by p to a logical sector number. The translation takes the lead-in
- * offset of 150 sectors into account so the logical sector number returned
- * would begin at zero.
+ * @details Translates the CD-ROM positional coordinates in
+ * minutes/seconds/frames format from the provided CdlLOC structure to a
+ * logical sector number. The translation takes the lead-in offset into account
+ * so 00:02:00 is correctly translated to LBA 0 rather than 150.
  *
- * @param p Pointer to a CdlLOC struct
- * @return Logical sector number minus the 150 sector lead-in.
+ * @param p Pointer to a CdlLOC structure
+ * @return Logical sector number minus the 150-sector lead-in
  */
 int CdPosToInt(const CdlLOC *p);
 
 /**
- * @brief Gets CD-ROM TOC information
+ * @brief Issues a command to the CD-ROM controller.
  *
- * @details Retrieves the track entries from a CD's table of contents (TOC). The
- * function can return up to 99 track entries, which is the maximum number of
- * audio tracks the CD standard supports.
+ * @details Sends a CD-ROM command specified by com to the CD-ROM controller,
+ * waits for an acknowledge interrupt (very fast) then returns. It will also
+ * issue parameters from param to the CD-ROM controller if the command accepts
+ * parameters. Any response from the controller is stored into the provided
+ * buffer asynchronously.
+ *
+ * Some commands (marked as blocking in the table below) will keep running in
+ * the background after being acknowledged. Use CdSync() to wait for these
+ * commands to finish, or CdSyncCallback() to register a callback to be
+ * executed once the drive is idle.
+ *
+ * This function requires interrupts to be enabled and cannot be used in a
+ * critical section or IRQ callback. Use CdControlF() in callbacks instead.
+ *
+ * The following commands are available:
+ *
+ * | Command       | Value | Parameter  | Blocking | Description                                                                                                       |
+ * | :------------ | ----: | :--------- | :------- | :---------------------------------------------------------------------------------------------------------------- |
+ * | CdlNop        |  0x01 |            | No       | Updates the current CD-ROM status and resets the CdlStatShellOpen flag, without doing anything else.              |
+ * | CdlSetloc     |  0x02 | CdlLOC     | No       | Sets the seek target location, but does not seek. Actual seeking begins upon issuing a seek or read command.      |
+ * | CdlPlay       |  0x03 | (uint8_t)  | No       | Begins CD-DA playback. Parameter specifies an optional track number to play (some emulators do not support it).   |
+ * | CdlForward    |  0x04 |            | No       | Starts fast-forwarding (CD-DA only). Issue CdlPlay to stop fast forwarding.                                       |
+ * | CdlBackward   |  0x05 |            | No       | Starts rewinding (CD-DA only). Issue CdlPlay to stop rewinding.                                                   |
+ * | CdlReadN      |  0x06 | (CdlLOC)   | No       | Begins reading data sectors with automatic retry. Used in conjunction with CdReadyCallback().                     |
+ * | CdlStandby    |  0x07 |            | Yes      | Starts the spindle motor if it was previously stopped.                                                            |
+ * | CdlStop       |  0x08 |            | Yes      | Stops playback or data reading and shuts down the spindle motor.                                                  |
+ * | CdlPause      |  0x09 |            | Yes      | Stops playback or data reading without stopping the spindle motor.                                                |
+ * | CdlInit       |  0x0a |            | Yes      | Initializes the CD-ROM controller and aborts any ongoing command.                                                 |
+ * | CdlMute       |  0x0b |            | No       | Mutes the drive's audio output (both CD-DA and XA).                                                               |
+ * | CdlDemute     |  0x0c |            | No       | Unmutes the drive's audio output (both CD-DA and XA).                                                             |
+ * | CdlSetfilter  |  0x0d | CdlFILTER  | No       | Configures the XA ADPCM sector filter.                                                                            |
+ * | CdlSetmode    |  0x0e | uint8_t    | No       | Sets the CD-ROM mode.                                                                                             |
+ * | CdlGetparam   |  0x0f |            | No       | Returns current CD-ROM mode and file/channel filter settings.                                                     |
+ * | CdlGetlocL    |  0x10 |            | No       | Returns current logical CD position, mode and XA filter parameters.                                               |
+ * | CdlGetlocP    |  0x11 |            | No       | Returns current physical CD position (using SubQ location data).                                                  |
+ * | CdlSetsession |  0x12 | uint8_t    | Yes      | Attempts to seek to the specified session on a multi-session disc.                                                |
+ * | CdlGetTN      |  0x13 |            | No       | Returns the number of tracks on the disc.                                                                         |
+ * | CdlGetTD      |  0x14 | uint8_t    | No       | Returns the starting location of the specified track number.                                                      |
+ * | CdlSeekL      |  0x15 | (CdlLOC)   | Yes      | Logical seek (using data sector headers) to target position, set by last CdlSetloc command.                       |
+ * | CdlSeekP      |  0x16 | (CdlLOC)   | Yes      | Physical seek (using subchannel Q) to target position, set by last CdlSetloc command.                             |
+ * | CdlTest       |  0x19 | (varies)   | Yes      | Executes a test subcommand (see nocash documentation). Shall be issued using CdCommand() rather than CdControl(). |
+ * | CdlGetID      |  0x1a |            | Yes      | Identifies the disc type and returns its license string if any.                                                   |
+ * | CdlReadS      |  0x1b | (CdlLOC)   | No       | Begins reading data sectors in real-time (without retry) mode. Intended for playing XA ADPCM or .STR files.       |
+ * | CdlReset      |  0x1c |            | No       | Resets the CD-ROM controller (similar behavior to manually opening and closing the door).                         |
+ * | CdlGetQ       |  0x1d | uint8_t[2] | Yes      | Reads up to 10 raw bytes of subchannel Q data directly from the table of contents.                                |
+ * | CdlReadTOC    |  0x1e |            | Yes      | Forces reinitialization of the disc's table of contents.                                                          |
+ *
+ * Most commands return the current CD-ROM status as result (which is
+ * automatically saved by the library and can be retrieved at any time using
+ * CdStatus()). The following commands also return additional data:
+ *
+ * | Command     | Return values                           |
+ * | :---------- | :-------------------------------------- |
+ * | CdlGetparam | uint8_t status, mode, _pad, file, chan  |
+ * | CdlGetlocL  | CdlLOCINFOL info                        |
+ * | CdlGetlocP  | CdlLOCINFOP info                        |
+ * | CdlGetTN    | uint8_t status, first_track, last_track |
+ * | CdlGetTD    | uint8_t status, minutes, seconds        |
+ *
+ * NOTE: Values are in BCD format. For some commands (CdlReadN, CdlReadS,
+ * CdlSeekL, CdlSeekP), if a CdlLOC parameter is passed, it will be sent to the
+ * controller as a separate CdlSetloc command.
+ *
+ * @param cmd
+ * @param param Pointer to command parameters
+ * @param result Optional pointer to buffer to store result into
+ * @return 1 if the command was issued successfully, 0 if a previously issued
+ * command has not yet finished processing or -1 if a parameter is required but
+ * was not specified
+ *
+ * @see CdSync(), CdControlF(), CdCommand()
+ */
+int CdControl(CdlCommand cmd, const void *param, uint8_t *result);
+
+/**
+ * @brief Issues a command to the CD-ROM controller and waits for it to
+ * complete.
  *
- * This function only retrieve the minutes and seconds of an audio track's
- * position as the CD-ROM controller only returns the minutes and seconds of a
- * track, which may result in the end of the previous track being played
- * instead of the intended track to be played. This can be remedied by having a
- * 2 second pregap on each audio track on your disc.
+ * @details Equivalent to CdControl() followed by CdSync(). If a blocking
+ * command is issued, this function blocks until said command has completed.
  *
- * @param toc Pointer to an array of CdlLOC entries
- * @return Number of tracks on the disc, zero on error.
+ * This function requires interrupts to be enabled and cannot be used in a
+ * critical section or IRQ callback. Use CdControlF() in callbacks instead.
  *
- * @see CdControl()
+ * @param cmd
+ * @param param Pointer to command parameters
+ * @param result Optional pointer to buffer to store result into
+ * @return 1 if the command was issued successfully, 0 if a previously issued
+ * command has not yet finished processing or -1 if a parameter is required but
+ * was not specified
+ *
+ * @see CdControl(), CdControlF()
  */
-int CdGetToc(CdlLOC *toc);
+int CdControlB(CdlCommand cmd, const void *param, uint8_t *result);
 
 /**
- * @brief Issues a control command to the CD-ROM controller
+ * @brief Issues a command to the CD-ROM controller (asynchronous).
  *
- * @details Sends a CD-ROM command specified by com to the CD-ROM controller,
- * waits for an acknowledge interrupt (very fast) then returns. It will also
- * issue parameters from param to the CD-ROM controller if the command accepts
- * parameters. Response data from the CD-ROM controller is stored to result on
- * commands that produce response data.
- *
- * Because this function waits for an acknowledge interrupt from the CD-ROM
- * controller, this function should not be used in a callback. Instead, use
- * CdControlF().
- *
- * Commands that are blocking require the use of CdSync() to wait for the
- * command to fully complete.
- *
- * CD-ROM control commands:
- *
- * | Command       | Value | Parameter | Blocking | Description                                                                                                        |
- * | :------------ | ----: | :-------- | :------- | :----------------------------------------------------------------------------------------------------------------- |
- * | CdlNop        |  0x01 |           | No       | Also known as Getstat. Normally used to query the CD-ROM status, which is retrieved using CdStatus().              |
- * | CdlSetloc     |  0x02 | CdlLOC    | No       | Sets the seek target location, but does not seek. Actual seeking begins upon issuing a seek or read command.       |
- * | CdlPlay       |  0x03 | uint8_t   | No       | Begins CD Audio playback. Parameter specifies an optional track number to play (some emulators do not support it). |
- * | CdlForward    |  0x04 |           | No       | Fast forward (CD Audio only), issue CdlPlay to stop fast forward.                                                  |
- * | CdlBackward   |  0x05 |           | No       | Rewind (CD Audio only), issue CdlPlay to stop rewind.                                                              |
- * | CdlReadN      |  0x06 | CdlLOC    | No       | Begin reading data sectors. Used in conjunction with CdReadCallback().                                             |
- * | CdlStandby    |  0x07 |           | Yes      | Also known as MotorOn, starts CD motor and remains idle.                                                           |
- * | CdlStop       |  0x08 |           | Yes      | Stops playback and the disc itself.                                                                                |
- * | CdlPause      |  0x09 |           | Yes      | Stops playback or data reading, but leaves the disc on standby.                                                    |
- * | CdlInit       |  0x0A |           | Yes      | Initialize the CD-ROM controller.                                                                                  |
- * | CdlMute       |  0x0B |           | No       | Mutes CD audio (both DA and XA).                                                                                   |
- * | CdlDemute     |  0x0C |           | No       | Unmutes CD audio (both DA and XA).                                                                                 |
- * | CdlSetfilter  |  0x0D | CdlFILTER | No       | Set XA audio filter.                                                                                               |
- * | CdlSetmode    |  0x0E | uint8_t   | No       | Set CD-ROM mode.                                                                                                   |
- * | CdlGetparam   |  0x0F |           | No       | Returns current CD-ROM mode and file/channel filter settings.                                                      |
- * | CdlGetlocL    |  0x10 |           | No       | Returns current logical CD position, mode and XA filter parameters.                                                |
- * | CdlGetlocP    |  0x11 |           | No       | Returns current physical CD position (using SubQ location data).                                                   |
- * | CdlSetsession |  0x12 | uint8_t   | Yes      | Seek to specified session on a multi-session disc.                                                                 |
- * | CdlGetTN      |  0x13 |           | No       | Get CD-ROM track count.                                                                                            |
- * | CdlGetTD      |  0x14 | uint8_t   | No       | Get specified track position.                                                                                      |
- * | CdlSeekL      |  0x15 |           | Yes      | Logical seek to target position, set by last CdlSetloc command.                                                    |
- * | CdlSeekP      |  0x16 |           | Yes      | Physical seek to target position, set by last CdlSetloc command.                                                   |
- * | CdlTest       |  0x19 | (varies)  | Yes      | Special test command not disclosed to official developers (see nocash documents for more info).                    |
- * | CdlReadS      |  0x1B | CdlLOC    | No       | Begin reading data sectors without pausing for error correction.                                                   |
- *
- * CD-ROM return values:
- *
- * | Command     | 0     | 1     | 2      | 3    | 4       | 5       | 6    | 7      |
- * | :---------- | :---- | :---- | :----- | :--- | :------ | :------ | :--- | :----- |
- * | CdlGetparam | stat  | mode  | 0      | file | channel |         |      |        |
- * | CdlGetlocL  | amin  | asec  | aframe | mode | file    | channel | sm   | ci     |
- * | CdlGetlocP  | track | index | min    | sec  | frame   | amin    | asec | aframe |
- * | CdlGetTN    | stat  | first | last   |      |         |         |      |        |
- * | CdlGetTD    | stat  | min   | sec    |      |         |         |      |        |
- *
- * NOTE: Values are in BCD format.
- *
- * @param com Command value
- * @param param Command parameters
- * @param result Pointer of buffer to store result
- * @return 1 if the command was issued successfully. Otherwise 0 if a
- * previously issued command has not yet finished processing.
- *
- * @see CdSync(), CdControlF()
- */
-int CdControl(uint8_t com, const void *param, uint8_t *result);
-
-/**
- * @brief Issues a CD-ROM command to the CD-ROM controller (blocking)
- *
- * @details This function works just like CdControl(), but blocks on blocking
- * commands until said blocking command has completed.
- *
- * Because this function waits for an acknowledge interrupt from the CD-ROM
- * controller, this function should not be used in a callback. Use CdControlF()
- * instead.
- *
- * @param com Command value
- * @param param Command parameters
- * @param result Pointer of buffer to store result
- * @return 1 if the command was issued successfully. Otherwise 0 if a
- * previously issued command has not yet finished processing.
+ * @details This function works similarly to CdControl() but does not block for
+ * the acknowledge interrupt from the CD-ROM controller, making it suitable for
+ * usage in an IRQ handler or callback function. Use CdSync() (outside of a
+ * callback) to wait for a command to finish, or CdSyncCallback() to register a
+ * callback to be executed once the drive is idle.
  *
- * @see CdControl(), CdControlF()
+ * A maximum of two commands can be issued at once and only the first command
+ * can have parameters, as the parameter buffer is not cleared until the last
+ * command is acknowledged by the controller.
+ *
+ * NOTE: as with CdControl(), some commands (CdlReadN, CdlReadS, CdlSeekL,
+ * CdlSeekP) are sent as two separate commands if a CdlLOC parameter is passed.
+ * In some cases this may overflow the controller's two-command buffer.
+ *
+ * @param cmd
+ * @param param Pointer to command parameters
+ * @return -1 if a parameter is required but was not specified, otherwise 1
+ * (even if sending the command failed)
+ *
+ * @see CdControl(), CdCommand()
  */
-int CdControlB(uint8_t com, const void *param, uint8_t *result);
+int CdControlF(CdlCommand cmd, const void *param);
 
 /**
- * @brief Issues a CD-ROM command to the CD-ROM controller (does not block)
+ * @brief Issues a custom packet to the CD-ROM controller.
  *
- * @details This function works more or less the same as CdControl() but it
- * does not block even for the acknowledge interrupt from the CD-ROM
- * controller. Since this function is non-blocking it can be used in a callback
- * function.
+ * @details This is a more advanced variant of CdControl() that allows sending
+ * commands with an arbitrary number of parameters, such as CdlTest commands,
+ * and does not issue any additional CdlSetloc commands automatically. The
+ * number of parameter bytes must be specified manually.
  *
- * When using this function in a callback, a maximum of two commands can be
- * issued at once and only the first command can have parameters. This is
- * because the CD-ROM controller can only queue up to two commands and the
- * parameter FIFO is not cleared until the last command is acknowledged. But
- * waiting for acknowledgment in a callback is not possible.
+ * As with CdControl(), this function waits for the drive to acknowledge the
+ * command. Any response from the controller is stored into the provided buffer
+ * asynchronously.
  *
- * @param com Command value
- * @param param Command parameters
- * @return 1 if the command was issued successfully. Otherwise 0 if a
- * previously issued command has not yet finished processing.
+ * This function requires interrupts to be enabled and cannot be used in a
+ * critical section or IRQ callback. Use CdCommandF() in callbacks instead.
  *
- * @see CdControl()
+ * @param cmd
+ * @param param Pointer to command parameters if any
+ * @param length Number of parameter bytes expected by the command
+ * @param result Optional pointer to buffer to store result into
+ * @return 1 if the command was issued successfully or 0 if a previously issued
+ * command has not yet finished processing
+ *
+ * @see CdSync(), CdCommandF(), CdControl()
  */
-int CdControlF(uint8_t com, const void *param);
+int CdCommand(CdlCommand cmd, const void *param, int length, uint8_t *result);
 
 /**
- * @brief Waits for blocking command or blocking status
+ * @brief Issues a custom packet to the CD-ROM controller (asynchronous).
  *
- * @details If mode is zero the function blocks if a blocking command was
- * issued earlier until the command has finished. If mode is non-zero the
- * function returns a command status value.
+ * @details This function works similarly to CdCommand() but does not block for
+ * the acknowledge interrupt from the CD-ROM controller, making it suitable for
+ * usage in an IRQ handler or callback function. Use CdSync() (outside of a
+ * callback) to wait for a command to finish, or CdSyncCallback() to register a
+ * callback to be executed once the drive is idle.
+ *
+ * A maximum of two commands can be issued at once and only the first command
+ * can have parameters, as the parameter buffer is not cleared until the last
+ * command is acknowledged by the controller.
+ *
+ * @param cmd
+ * @param param Pointer to command parameters
+ * @param length Number of parameter bytes expected by the command
+ * @return Always 1 (even if sending the command failed)
+ *
+ * @see CdCommand(), CdControlF()
+ */
+int CdCommandF(CdlCommand cmd, const void *param, int length);
+
+/**
+ * @brief Waits for a blocking command or returns the current status.
  *
- * A buffer specified by result will be set with the most recent CD-ROM status
- * value from the last command issued.
+ * @details Waits for the controller to finish processing any blocking command
+ * (if mode = 0) or returns the current command status (if mode = 1). The
+ * buffer specified by result will be populated with the most recent CD-ROM
+ * status value from the last command issued.
  *
- * @param mode Mode
- * @param result Pointer to store most recent CD-ROM status
+ * @param mode
+ * @param result Optional pointer to buffer to store result into
  * @return Command status is returned as one of the following definitions:
  *
  * | Definition   | Description                 |
@@ -409,332 +503,489 @@ int CdControlF(uint8_t com, const void *param);
  *
  * @see CdControl()
  */
-int CdSync(int mode, uint8_t *result);
+CdlIntrResult CdSync(int mode, uint8_t *result);
 
 /**
- * @brief Sets a callback function
+ * @brief Sets a callback for blocking commands.
  *
- * @details Sets a callback with the specified function func. The callback is
- * executed whenever a blocking command has completed.
+ * @details Registers a function to be called whenever a blocking command has
+ * completed. The callback will get the interrupt status (CdlComplete or
+ * CdlDiskError) and the pointer to any result buffer previously passed to
+ * CdControl() as arguments.
  *
- * status is the CD-ROM status from the command that has completed processing.
- * *result corresponds to the *result parameter on CdControl()/CdControlB() and
- * returns the pointer to the buffer last set with that function.
+ * The callback will run in the exception handler's context, so it should be as
+ * fast as possible and shall not call any function that relies on interrupts
+ * being enabled.
  *
- * @param func Callback function
- * @return Pointer to last callback function set, or NULL if none was set.
+ * @param func
+ * @return Previously set callback or NULL
  *
- * @see CdControl, CdControlB, CdSync
+ * @see CdControl(), CdControlB(), CdSync()
  */
-uint32_t CdSyncCallback(CdlCB func);
+CdlCB CdSyncCallback(CdlCB func);
 
 /**
- * @brief Sets a callback function
+ * @brief Sets a callback for incoming sector or report data.
+ *
+ * @details Registers a function to be called whenever a data sector or report
+ * packet is available to be read from the drive, or in case of an error. The
+ * callback will get the interrupt status (CdlDataReady or CdlDiskError) and
+ * the pointer to any result buffer previously passed to CdControl() as
+ * arguments.
  *
- * @details Sets a callback with the specified function func. The callback is
- * executed whenever there's an incoming data sector from the CD-ROM controller
- * during CdlReadN or CdlReadS. The pending sector data can be retrieved using
- * CdGetSector().
+ * Note that the actual sector data is not retrieved automatically and must
+ * instead be read into memory using CdGetSector() or CdGetSector2() before the
+ * drive overwrites its internal sector buffer.
  *
- * status is the CD-ROM status code from the last CD command that has finished
- * processing. *result corresponds to the result pointer that was passed by the
- * last CdControl()/CdControlB() call.
+ * The callback will run in the exception handler's context, so it should be as
+ * fast as possible and shall not call any function that relies on interrupts
+ * being enabled.
  *
- * This callback cannot be used in conjunction with CdRead() because it also
- * uses this callback hook for its own internal use. The previously set
- * callback is restored after read completion however.
+ * NOTE: when using CdRead() or CdReadRetry(), any callback set using
+ * CdReadyCallback() is temporarily disabled in order to let the library handle
+ * read sectors internally.
  *
- * @param func Callback function
- * @return Pointer to last callback function set, or NULL if none was set.
+ * @param func
+ * @return Previously set callback or NULL
  *
  * @see CdControl(), CdControlB(), CdGetSector()
  */
-int CdReadyCallback(CdlCB func);
+CdlCB CdReadyCallback(CdlCB func);
+
+/**
+ * @brief Sets a callback for the end of a track.
+ *
+ * @details Registers a function to be called whenever the drive encounters and
+ * pauses at the end of a track (if the CdlModeAP bit is set in the CD-ROM
+ * mode), or whether the end of the disc is reached during data reading or
+ * audio playback. The callback will get the interrupt status (CdlDataEnd) and
+ * the pointer to any result buffer previously passed to CdControl() as
+ * arguments.
+ *
+ * Such a callback can be used along with the CdlModeAP flag to detect when
+ * playback of a CD-DA track ends and automatically loop it or start playing
+ * another track, with no manual polling required.
+ *
+ * @param func
+ * @return Previously set callback or NULL
+ *
+ * @see CdControl()
+ */
+CdlCB CdAutoPauseCallback(CdlCB func);
 
 /**
- * @brief Gets data from the CD-ROM sector buffered
+ * @brief Transfers data from the CD-ROM sector buffer.
  *
  * @details Reads sector data that is pending in the CD-ROM sector buffer and
- * stores it to *madr. Uses DMA to transfer the sector data and blocks very
- * briefly until said transfer completes.
+ * stores it into the provided buffer (which must be 32-bit aligned). Blocks
+ * until the transfer has finished.
  *
  * This function is intended to be called within a callback routine set using
  * CdReadyCallback() to fetch read data sectors from the CD-ROM sector buffer.
- * 
- * @param madr Pointer to memory buffer to store sector data
- * @param size Number of 32-bit words to retrieve
- * @return Always 1.
+ *
+ * @param madr
+ * @param size Number of 32-bit words to read (usually 512 for a 2048-byte
+ * sector)
+ * @return Always 1
  *
  * @see CdReadyCallback()
  */
 int CdGetSector(void *madr, int size);
 
 /**
- * @brief Gets data from the CD-ROM sector buffered (non-blocking)
+ * @brief Transfers data from the CD-ROM sector buffer (non-blocking).
  *
  * @details Reads sector data that is pending in the CD-ROM sector buffer and
- * stores it to *madr. Uses DMA to transfer the sector data in the background
- * while keeping the CPU running (one word is transferred every 16 CPU cycles).
- * Note this is much slower than the blocking transfer performed by
- * CdGetSector().
+ * stores it into the provided buffer (which must be 32-bit aligned). The
+ * transfer runs in the background while keeping the CPU running; about one
+ * word is transferred every 16 CPU cycles. Note this is slower than the
+ * blocking transfer performed by CdGetSector().
  *
  * This function is intended to be called within a callback routine set using
  * CdReadyCallback() to fetch read data sectors from the CD-ROM sector buffer.
  * Since the transfer is asynchronous, CdDataSync() should be used to wait
  * until the whole sector has been read.
- * 
- * @param madr Pointer to memory buffer to store sector data
- * @param size Number of 32-bit words to retrieve
- * @return Always 1.
+ *
+ * @param madr
+ * @param size Number of 32-bit words to read (usually 512 for a 2048-byte
+ * sector)
+ * @return Always 1
  *
  * @see CdReadyCallback(), CdDataSync()
  */
 int CdGetSector2(void *madr, int size);
 
 /**
- * @brief Waits for sector transfer to finish
+ * @brief Waits for a sector buffer transfer to finish.
  *
- * @details If mode is zero the function blocks until any sector DMA transfer
- * initiated by calling CdGetSector2() has finished. If mode is non-zero the
- * function returns a boolean value representing whether a transfer is
- * currently in progress.
+ * @details Blocks until any sector DMA transfer initiated using CdGetSector2()
+ * has finished (if mode = 0) or returns whether a transfer is currently in
+ * progress (if mode = 1).
  *
- * @param mode Mode
+ * @param mode
  * @return 0 if the transfer has finished, 1 if it is still in progress or -1
- * in case of a timeout.
+ * in case of a timeout
  *
  * @see CdGetSector2()
  */
 int CdDataSync(int mode);
 
 /**
- * @brief Locates a file in the CD-ROM file system
+ * @brief Reads one or more sectors into a buffer.
  *
- * @details Searches a file specified by filename by path and name in the
- * CD-ROM file system and returns information of the file if found. The file
- * information acquired will be stored to loc.
+ * @details Starts reading the specified number of sectors, starting from the
+ * location set by the last CdlSetloc command issued, and stores them
+ * contiguously into the provided buffer. The given mode is applied using a
+ * CdlSetmode command prior to starting the read.
  *
- * Directories can be separated with slashes (/) or backslashes (\), a leading
- * slash or backslash is optional but paths must be absolute. File version
- * identifier (;1) at the end of the file name is also optional. File and
- * directory names are case insensitive.
+ * Each sector read is 2340 bytes long if the CdlModeSize bit is set in the
+ * mode, 2048 bytes long otherwise. Ideally, the CdlModeSpeed bit shall be set
+ * to enable double speed mode.
  *
- * The ISO9660 file system routines of libpsxcd do not support long file names
- * currently. Only MS-DOS style 8.3 file names are supported; extensions such
- * as Joliet and Rock Ridge are ignored.
+ * Reading is done asynchronously. Use CdReadSync() to block until all data has
+ * been read, or CdReadCallback() to register a callback to be executed on
+ * completion or error. In case of errors, reading is aborted immediately and
+ * CdReadSync() will return -1.
  *
- * Upon calling this function for the first time, the ISO descriptor of the
- * disc is read and the whole path table is cached into memory. Next the
- * directory descriptor of the particular directory specified is loaded and
- * cached to locate the file specified. The directory descriptor is kept in
- * memory as long as the consecutive files to be searched are stored in the
- * same directory until a file in another directory is to be searched. On which
- * the directory descriptor is unloaded and a new directory descriptor is read
- * from the disc and cached. Therefore, locating files in the same directory is
- * faster as the relevant directory descriptor is already in memory and no disc
- * reads are issued.
+ * This function requires interrupts to be enabled and cannot be used in a
+ * critical section or IRQ callback. Any callback set using CdReadyCallback()
+ * is temporarily disabled and restored once the read operation completes.
  *
- * As of Revision 66 of PSn00bSDK, media change is detected by checking the
- * CD-ROM lid open status bit and attempting to acknowledge it with a CdlNop
- * command, to discriminate the status from an open lid or changed disc.
+ * @param sectors
+ * @param buf
+ * @param mode CD-ROM mode to apply prior to reading using CdlSetmode
+ * @return 1 if the read operation started successfully or 0 in case of errors
  *
- * @param loc Pointer to a CdlFILE struct to store file information
- * @param filename Path and name of file to locate
- * @return Pointer to the specified CdlFILE struct. Otherwise NULL is returned
- * when the file is not found.
+ * @see CdReadRetry(), CdReadSync(), CdReadCallback()
  */
-CdlFILE* CdSearchFile(CdlFILE *loc, const char *filename);
+int CdRead(int sectors, uint32_t *buf, int mode);
 
 /**
- * @brief Reads sectors from the CD-ROM
+ * @brief Reads one or more sectors into a buffer (performs multiple attempts).
  *
- * @details Reads a number sectors specified by sectors from the location set
- * by the last CdlSetloc command, the read sectors are then stored to a buffer
- * specified by buf. mode specifies the CD-ROM mode to use for the read
- * operation.
+ * @details This function works similarly to CdRead(), but retries reading in
+ * case of errors. If reading fails, up to the specified number of attempts
+ * will be done before an error is returned by CdReadSync().
  *
- * The size of the sector varies depending on the sector read mode specified by
- * mode. For standard data sectors it is multiples of 2048 bytes. If
- * CdlModeSize0 is specified the sector size is 2328 bytes which includes the
- * whole sector minus sync, adress, mode and sub header bytes. CdlModeSize1
- * makes the sector size 2340 which is the entire sector minus sync bytes.
- * Ideally, CdlModeSpeed must be specified to read data sectors at double
- * CD-ROM speed.
+ * This function requires interrupts to be enabled and cannot be used in a
+ * critical section or IRQ callback. Any callback set using CdReadyCallback()
+ * is temporarily disabled and restored once the read operation completes.
  *
- * This function blocks very briefly to issue the necessary commands to start
- * CD-ROM reading. To determine if reading has completed use CdReadSync or
- * CdReadCallback.
+ * IMPORTANT: in order for retries to be correctly processed, CdReadSync(0)
+ * (blocking) shall be called immediately after starting the read, or
+ * CdReadSync(1) (non-blocking) shall be called frequently (e.g. once per
+ * frame) until reading has finished.
  *
- * @param sectors Number of sectors to read
- * @param buf Pointer to buffer to store sectors read
- * @param mode CD-ROM mode for reading
- * @return Always returns 0 even on errors. This may change in future versions.
+ * @param sectors
+ * @param buf
+ * @param mode CD-ROM mode to apply prior to reading using CdlSetmode
+ * @param attempts Maximum number of attempts (>= 1)
+ * @return 1 if the read operation started successfully or 0 in case of errors
  *
- * @see CdReadSync(), CdReadCallback()
+ * @see CdRead(), CdReadSync(), CdReadCallback()
  */
-int CdRead(int sectors, uint32_t *buf, int mode);
+int CdReadRetry(int sectors, uint32_t *buf, int mode, int attempts);
 
 /**
- * @brief Waits for CD-ROM read completion or returns read status
+ * @brief Cancels reading initiated by CdRead().
  *
- * @details This function works more or less like CdSync() but for CdRead(). If
- * mode is zero the function blocks if CdRead() was issued earlier until
- * reading has completed. If mode is non-zero the function completes
- * immediately and returns number of sectors remaining.
+ * @details Aborts any ongoing read operation that was previously started by
+ * calling CdRead() or CdReadRetry(). After aborting, CdReadSync() will return
+ * -2 and any callback registered using CdReadCallback() *not* be called.
  *
- * A buffer specified by result will be set with the most recent CD-ROM status
- * value from the last read issued.
+ * NOTE: the CD-ROM controller may take several hundred milliseconds to
+ * actually stop reading. CdReadSync() should be used to make sure the drive is
+ * idle before sending a command or starting another read.
  *
- * @param mode Mode
- * @param result Pointer to store most recent CD-ROM status
- * @return Number of sectors remaining. If reading is completed, 0 is returned.
- * On error, -1 is returned.
+ * @see CdReadSync()
+ */
+void CdReadBreak(void);
+
+/**
+ * @brief Waits for reading initiated by CdRead() to finish or returns status.
+ *
+ * @details Waits for any ongoing read operation previously started using
+ * CdRead() or CdReadRetry() to finish (if mode = 0) or returns the number of
+ * sectors pending (if mode = 1). The buffer specified by result will be
+ * populated with the most recent CD-ROM status value from the last command
+ * issued.
+ *
+ * When using CdReadRetry(), this function also handles starting a new read
+ * attempt if the previous one failed. As such, it needs to be called once (if
+ * mode = 0) or periodically (if mode = 1) in order to poll the drive for
+ * failures, even if the return value is ignored.
  *
- * @see CdRead()
+ * @param mode
+ * @param result Buffer to store most recent CD-ROM status into
+ * @return Number of sectors remaining, -1 in case of errors or -2 if the read
+ * was aborted
+ *
+ * @see CdRead(), CdReadCallback()
  */
 int CdReadSync(int mode, uint8_t *result);
 
 /**
- * @brief Sets a callback function for read completion
+ * @brief Sets a callback for read operations started by CdRead().
+ *
+ * @details Registers a function to be called whenever a read started using
+ * CdRead() or CdReadRetry() has completed. The callback will get the interrupt
+ * status (CdlComplete or CdlDiskError) and the pointer to a result buffer
+ * internal to the library.
+ *
+ * The callback will run in the exception handler's context, so it should be as
+ * fast as possible and shall not call any function that relies on interrupts
+ * being enabled.
+ *
+ * @param func 
+ * @return Previously set callback or NULL
  *
- * @details Works much the same as CdSyncCallback() but for CdRead(). Sets a
- * callback with the specified function func. The callback is executed whenever
- * a read operation initiated by CdRead() has completed.
+ * @see CdRead(), CdReadSync()
+ */
+CdlCB CdReadCallback(CdlCB func);
+
+/**
+ * @brief Returns the last command issued.
  *
- * status is the CD-ROM status from the command that has completed processing.
- * *result points to a read result buffer.
+ * @details Returns the index of the last command sent to the CD-ROM controller
+ * using CdCommand(), CdControl() or any of its variants. The value is stored
+ * in an internal variable, so this function returns instantly and can be used
+ * in an IRQ callback.
  *
- * @param func Callback function
- * @return Pointer to last callback function set, or NULL if none was set.
+ * @return Last command issued
  *
- * @see CdRead()
+ * @see CdControl()
  */
-uint32_t CdReadCallback(CdlCB func);
+CdlCommand CdLastCom(void);
 
 /**
- * @brief Gets the most recent CD-ROM status
+ * @brief Returns the last CD-ROM position set.
  *
- * @details Returns the CD-ROM status since the last command issued. The status
- * value is updated by most CD-ROM commands.
+ * @details Returns the last seek location set using the CdlSetloc command (or
+ * any of the commands that are processed by sending CdlSetloc internally, such
+ * as CdlReadN, CdlReadS, CdlSeekL or CdlSeekP). The value is stored in an
+ * internal variable, so this function returns instantly and can be used in an
+ * IRQ callback.
  *
- * To get the current CD-ROM status you can issue CdlNop commands at regular
- * intervals to update the CD-ROM status this function returns.
+ * Note that if CdlReadN, CdlReadS or CdlPlay were issued, this will be the
+ * location the read was started from and *not* the current position of the
+ * drive head, which can instead be retrieved using CdlGetlocL or CdlGetlocP.
  *
- * @return CD-ROM status from last comand issued.
+ * @return Pointer to an internal CdlLOC structure containing the last position
  *
  * @see CdControl()
  */
-int CdStatus(void);
+const CdlLOC *CdLastPos(void);
 
 /**
- * @brief Gets the last CD-ROM mode
+ * @brief Returns the last CD-ROM mode set.
  *
- * @details Returns the CD-ROM mode last set when issuing a CdlSetmode command.
- * The function returns instantly as it merely returns a value stored in an
- * internal variable.
+ * @details Returns the CD-ROM mode last set using the CdlSetmode command.
+ * The value is stored in an internal variable, so this function returns
+ * instantly and can be used in an IRQ callback.
  *
- * Since the value is simply a copy of what was specified from the last
- * CdlSetmode command, the mode value may become inaccurate if CdlInit or other
- * commands that affect the CD-ROM mode have been issued previously.
+ * WARNING: upon receiving some commands, such as CdlInit, the CD-ROM drive may
+ * change its mode automatically. The value returned by CdMode() will not
+ * reflect those changes; use CdlGetparam instead.
  *
- * @return Last CD-ROM mode value.
+ * @return Last CD-ROM mode value set
+ *
+ * @see CdControl()
  */
 int CdMode(void);
 
 /**
- * @brief Sets CD-ROM mixer or attenuation
+ * @brief Returns the most recent CD-ROM status.
+ *
+ * @details Returns the CD-ROM status since the last command issued. The value
+ * is stored in an internal variable, so this function returns instantly and
+ * can be used in an IRQ callback.
+ *
+ * The status value is updated by most CD-ROM commands, with the exception of
+ * CdlTest, CdlGetlocL and CdlGetlocP; it can also be updated manually by
+ * issuing the CdlNop command.
+ *
+ * @return CD-ROM status returned by last comand issued
+ *
+ * @see CdControl()
+ */
+int CdStatus(void);
+
+/**
+ * @brief Retrieves the disc's table of contents.
+ *
+ * @details Retrieves the track entries from a CD's table of contents (TOC). The
+ * function can return up to 99 track entries, which is the maximum number of
+ * tracks on a CD. This function shall only be called while the drive is idle
+ * and cannot be used in an IRQ callback or critical section.
+ *
+ * NOTE: the CD-ROM controller only returns the minutes and seconds of each
+ * track's location. This makes it impossible to start playing a track from its
+ * *exact* beginning, and may result in the end of the previous track being
+ * played if there are no silent gaps between tracks. The CD specification
+ * recommends adding a 2-second pregap to each track for this reason.
+ *
+ * @param toc Pointer to an array of CdlLOC entries
+ * @return Number of tracks on the disc, or 0 in case of error
+ *
+ * @see CdControl()
+ */
+int CdGetToc(CdlLOC *toc);
+
+/**
+ * @brief Returns the CD-ROM controller's region code.
+ *
+ * @details Attempts to fetch region information from the drive using a CdlTest
+ * command. This can be used to reliably determine the system's region without
+ * having to resort to workarounds like probing the BIOS ROM.
  *
- * @details Sets the CD-ROM attenuation parameters from a CdlATV struct
- * specified by vol. The CD-ROM attenuation settings are different from the SPU
- * CD-ROM volume.
+ * This function may return incorrect results on emulators or consoles equipped
+ * with CD-ROM drive emulation devices such as the PSIO. It is not affected by
+ * modchips.
  *
- * Normally used to configure CD and XA audio playback for mono or reverse
- * stereo output, though this was rarely used in practice.
+ * @return Region code or 0 if the region cannot be determined
+ */
+CdlRegionCode CdGetRegion(void);
+
+/**
+ * @brief Sets the CD-ROM volume mixing matrix.
+ *
+ * @details Sets the volume levels of the CD-ROM drive's audio output (used for
+ * both CD-DA and XA playback) to match the values in the provided CdlATV
+ * structure.
+ *
+ * The default setting is { 128, 0, 128, 0 }, i.e. send the left channel to the
+ * left output only and the right channel to the right output only. The output
+ * can be downmixed to mono by setting the values to { 64, 64, 64, 64 }, or the
+ * left and right channels can be swapped using { 0, 128, 0, 128 }.
+ *
+ * NOTE: the SPU has an additional volume control for CD audio. Both must be
+ * set in order for audio output to work.
  *
  * @param vol CD-ROM attenuation parameters
- * @return Always 1.
+ * @return Always 1
  */
 int CdMix(const CdlATV *vol);
 
 /**
- * @brief Opens a directory on the CD-ROM file system
+ * @brief Locates a file in the CD-ROM file system.
+ *
+ * @details Searches the CD-ROM's ISO9660 file system for the specified file
+ * and populates the given CdlFILE structure with information about the file if
+ * found. This function uses dynamic memory allocation.
+ *
+ * Directories can be separated with slashes (/) or backslashes (\), a leading
+ * slash or backslash is optional but paths must be absolute. The device prefix
+ * (cdrom:) must be omitted. A file version identifier (;1) at the end of the
+ * name is also optional. File and directory names are case insensitive; long
+ * names and ISO9660 extensions such as Joliet are currently not supported.
+ *
+ * This function is blocking and may take several seconds to load and
+ * subsequently parse the path table and directory records if none of the file
+ * system functions have yet been called.
+ *
+ * Upon calling this function for the first time, the ISO descriptor of the
+ * disc is read and the whole path table is cached into memory. Next the
+ * directory descriptor of the particular directory specified is loaded and
+ * cached to locate the file specified. The directory descriptor is kept in
+ * memory as long as the consecutive files to be searched are stored in the
+ * same directory until a file in another directory is to be searched. On which
+ * the directory descriptor is unloaded and a new directory descriptor is read
+ * from the disc and cached. Therefore, locating files in the same directory is
+ * faster as the relevant directory descriptor is already in memory and no disc
+ * reads are issued.
+ *
+ * Since file system access is slow, it is recommended to only use
+ * CdSearchFile() sparingly to e.g. find the location of a custom archive file,
+ * and then use the archive's internal table of contents to locate entries
+ * within the archive.
+ *
+ * @param loc Pointer to a CdlFILE structure
+ * @param filename
+ * @return Pointer to the specified CdlFILE structure, or a null pointer if the
+ * file cannot be found or another error occurred; the return value of
+ * CdIsoError() is also updated
+ *
+ * @see CdOpenDir()
+ */
+CdlFILE* CdSearchFile(CdlFILE *loc, const char *filename);
+
+/**
+ * @brief Opens a directory on the CD-ROM file system.
  *
- * @details Opens a directory on the CD-ROM file system to read the contents of
- * a directory.
+ * @details Opens a directory on the CD-ROM's ISO9660 file system and reads its
+ * contents, returning a newly allocated CdlDIR structure. This function uses
+ * dynamic memory allocation.
  *
- * A path name can use a slash (/) or backslash character (\) as the directory
- * name separator. The path must be absolute and should begin with a slash or
- * backslash. It should also not be prefixed with a device name (ie.
- * \MYDIR1\MYDIR2 will work but not cdrom:\MYDIR1\MYDIR2). The file system
- * routines in libpsxcd can query directory paths of up to 128 characters.
+ * Directories can be separated with slashes (/) or backslashes (\), a leading
+ * slash or backslash is optional but paths must be absolute. The device prefix
+ * (cdrom:) must be omitted. Directory names are case insensitive; long names
+ * and ISO9660 extensions such as Joliet are currently not supported.
  *
- * The ISO9660 file system routines of libpsxcd do not support long file names
- * currently. Only MS-DOS style 8.3 file names are supported; extensions such
- * as Joliet and Rock Ridge are ignored.
+ * This function is blocking and may take several seconds to load and
+ * subsequently parse the path table and directory records if none of the file
+ * system functions have yet been called.
  *
- * @param path Directory path to open
- * @return Pointer of a CdlDIR context, NULL if an error occurred.
+ * @param path
+ * @return Pointer of a CdlDIR context or a null pointer if an error occurred;
+ * the return value of CdIsoError() is also updated
  *
  * @see CdReadDir(), CdCloseDir()
  */
-CdlDIR* CdOpenDir(const char* path);
+CdlDIR *CdOpenDir(const char *path);
 
 /**
- * @brief Reads a directory entry from an open directory context
+ * @brief Obtains information about the next file in the directory.
  *
- * @details Retrieves a file entry from an open directory context and stores it
- * to a CdlFILE struct specified by file. Repeated calls of this function
- * retrieves the next directory entry available until there are no more
- * directory entries that follow.
+ * @details Retrieves a file entry from an open directory context and stores
+ * information about the file into the provided CdlFILE structure. This
+ * function is meant to be called repeatedly until no more files are available
+ * in the directory, in which case it returns 0.
  *
- * @param dir Open directory context (from CdOpenDir())
- * @param file Pointer to a CdlFILE struct
- * @return 1 if there are proceeding directory entries that follow, otherwise 0.
+ * @param dir
+ * @param file Pointer to a CdlFILE structure
+ * @return 1 if there are proceeding directory entries that follow, 0 otherwise
  *
  * @see CdOpenDir()
  */
-int CdReadDir(CdlDIR* dir, CdlFILE* file);
+int CdReadDir(CdlDIR *dir, CdlFILE *file);
 
 /**
- * @brief Closes a directory context created by CdOpenDir()
+ * @brief Closes a directory opened by CdOpenDir().
  *
- * @details Closes a directory query context created by CdOpenDir(). Behavior
- * is undefined when closing a previously closed directory context.
+ * @details Closes and deallocates directory query context returned by
+ * CdOpenDir(). Behavior is undefined when closing a previously closed
+ * directory context.
  *
- * @param dir Directory context
+ * @param dir
  *
  * @see CdOpenDir()
  */
-void CdCloseDir(CdlDIR* dir);
-
-int CdGetVolumeLabel(char* label);
+void CdCloseDir(CdlDIR *dir);
 
 /**
- * @brief Sets a callback function for auto pause
- *
- * @details The callback function specified in *func is executed when an auto
- * pause interrupt occurs when the current CD-ROM mode is set with CdlModeAP.
- * Auto pause interrupt occurs when CD Audio playback reaches the end of the
- * audio track. Specifying 0 disables the callback.
+ * @brief Retrieves the volume label of the CD-ROM file system.
  *
- * This can be used to easily loop CD audio automatically without requiring any
- * intervention in your software loop.
+ * @details Reads the volume identifier of the disc's ISO9660 file system and
+ * stores it into the provided string buffer. The volume label can be up to 32
+ * characters long.
  *
- * @param func Callback function
- * @return Pointer to the last callback function set. Zero if no callback was
- * set previously.
+ * This function is blocking and may take several seconds to load and
+ * subsequently parse the path table and directory records if none of the file
+ * system functions have yet been called.
  *
- * @see CdControl()
+ * @param label
+ * @return Length of the volume label (excluding the null terminator) or -1 in
+ * case of an error; the return value of CdIsoError() is also updated
  */
-int* CdAutoPauseCallback(void(*func)());
+int CdGetVolumeLabel(char *label);
 
 /**
- * @brief Retrieves CD-ROM ISO9660 parser status
+ * @brief Retrieves CD-ROM ISO9660 parser status.
  *
  * @details Returns the status of the file system parser from the last call of
- * a file system related function, such as CdSearchFile(), CdGetVolumeLabel()
- * and CdOpenDir(). Use this function to retrieve the exact error occurred when
- * either of those functions fail.
+ * a file system related function, such as CdSearchFile(), CdGetVolumeLabel(),
+ * CdOpenDir() and CdLoadSession(). Use this function to retrieve the exact
+ * error occurred when any of those functions fail.
  *
  * @return CD-ROM ISO9660 parser error code, as listed below:
  *
@@ -745,11 +996,13 @@ int* CdAutoPauseCallback(void(*func)());
  * | CdlIsoReadError | Read error occurred while reading the CD-ROM file system descriptor.                                |
  * | CdlIsoInvalidFs | Disc does not contain a standard ISO9660 file system.                                               |
  * | CdlIsoLidOpen   | Lid is open when attempting to parse the CD-ROM file system.                                        |
+ *
+ * @see CdSearchFile(), CdOpenDir()
  */
 int CdIsoError(void);
 
 /**
- * @brief Locates and parses the specified disc session
+ * @brief Locates and loads the specified disc session.
  *
  * @details Loads a session specified by session on a multi-session disc. Uses
  * CdlSetsession to seek to the specified disc session, then scans the
@@ -778,16 +1031,15 @@ int CdIsoError(void);
  * with the swap trick however, so a chipped or unlockable console is desired
  * for reading multi-session discs.
  *
- * NOTE: When the lid has been opened, the current CD-ROM session is reset to
+ * NOTE: when the lid has been opened, the current CD-ROM session is reset to
  * the first session on the disc. The console may produce an audible click
  * sound when executing this function. This is normal, and the click sound is
  * no different to the click heard on disc spin-up in older models of the
  * console.
  *
  * @param session Session number (1 = first session)
- * @return 0 on success. On failure due to open lid, bad session number or no
- * volume descriptor found in specified session, returns -1 and return value of
- * CdIsoError() is updated.
+ * @return 0 on success or -1 in case of errors; the return value of
+ * CdIsoError() is also updated
  */
 int CdLoadSession(int session);
 
diff --git a/libpsn00b/psxcd/_cd_control.s b/libpsn00b/psxcd/_cd_control.s
deleted file mode 100644
index 5fa336a..0000000
--- a/libpsn00b/psxcd/_cd_control.s
+++ /dev/null
@@ -1,144 +0,0 @@
-.set noreorder
-
-.include "hwregs_a.inc"
-
-.section .text
-
-#
-# Issues command and parameter bytes to CD controller directly
-#
-.global _cd_control
-.type _cd_control, @function
-_cd_control:
-
-	# a0 - command value
-	# a1 - pointer to parameters
-	# a2 - length of parameters
-	
-	addiu	$sp, -16
-	sw		$ra, 0($sp)
-	sw		$a0, 4($sp)
-	sw		$a1, 8($sp)
-	sw		$a2, 12($sp)
-	
-#	move	$a3, $a2					# Debug
-#	move	$a2, $a1
-#	move	$a1, $a0
-#	la		$a0, _cd_control_msg
-#	jal		printf
-#	addiu	$sp, -16
-#	addiu	$sp, 16
-
-	lw		$a0, 4($sp)
-	lw		$a1, 8($sp)
-	lw		$a2, 12($sp)
-	
-	li		$v0, 1					# Set acknowledge wait flag
-	la		$v1, _cd_ack_wait
-	sb		$v0, 0($v1)
-	
-	# Commands that have a 'completion' interrupt (CDIRQ2)
-	
-	beq		$a0, 0x07, .Lset_complete	# CdlStandby
-	nop
-	beq		$a0, 0x08, .Lset_complete	# CdlStop
-	nop
-	beq		$a0, 0x09, .Lset_complete	# CdlPause
-	nop
-	beq		$a0, 0x0A, .Lset_complete	# CdlInit
-	nop
-	beq		$a0, 0x12, .Lset_complete	# CdlSetsession
-	nop
-	beq		$a0, 0x15, .Lset_complete	# CdlSeekL
-	nop
-	beq		$a0, 0x16, .Lset_complete	# CdlSeekP
-	nop
-	beq		$a0, 0x1A, .Lset_complete	# GetID
-	nop
-	beq		$a0, 0x1D, .Lset_complete	# GetQ
-	nop
-	
-	la		$v1, _cd_complt_wait	# Set wait complete flag
-	sb		$0 , 0($v1)
-	
-	b		.Lno_complete
-	nop
-	
-.Lset_complete:
-
-	la		$v1, _cd_complt_wait	# Set wait complete flag
-	sb		$v0, 0($v1)
-	
-.Lno_complete:
-	
-	bne		$a0, 0x0E, .Lnot_mode
-	lbu		$v0, 0($a1)
-	la		$v1, _cd_last_mode
-	sb		$v0, 0($v1)
-	
-.Lnot_mode:
-	
-	la		$v1, _cd_last_int		# Clear last IRQ value
-	sb		$0 , 0($v1)
-
-	la		$v1, _cd_last_cmd		# Save command as last command
-	sb		$a0, 0($v1)
-	
-	lui		$v1, IOBASE
-	
-.Lbusy_wait:
-	lbu		$v0, CD_REG0($v1)
-	nop
-	andi	$v0, 0x80
-	bnez	$v0, .Lbusy_wait
-	nop
-	
-	li		$v0, 1					# Clear parameter FIFO (in case it wasn't cleared)
-	sb		$v0, CD_REG0($v1)
-	li		$v0, 0x40
-	sb		$v0, CD_REG3($v1)
-	
-#.Lflush_response:					# Flush response FIFO
-#	lbu		$v0, CD_REG1($v1)
-#	nop
-#	lbu		$v0, CD_REG0($v1)
-#	nop
-#	andi	$v0, 0x20
-#	beqz	$v0, .Lflush_response
-#	nop
-	
-.Lcmd_wait:							# Wait for CD to become ready for commands
-	lbu		$v0, CD_REG0($v1)
-	nop
-	andi	$v0, 0x80
-	bnez	$v0, .Lcmd_wait
-	nop
-	
-	sb		$0 , CD_REG0($v1)
-	
-	beqz	$a2, .Lno_params
-	nop
-	
-.Lfeed_params:						# Feed parameters to parameter FIFO
-	lbu		$v0, 0($a1)
-	addi	$a2, -1
-	sb		$v0, CD_REG2($v1)
-	bgtz	$a2, .Lfeed_params
-	addiu	$a1, 1
-	
-.Lno_params:
-
-	sb		$0 , CD_REG0($v1)		# Feed command value
-	sb		$a0, CD_REG1($v1)
-	
-	lw		$ra, 0($sp)
-	addiu	$sp, 16
-	jr		$ra
-	nop
-	
-
-#.section .data
-
-#_cd_control_msg:
-#	.asciiz "CdControl(%d, %x, %d)\n"
-	
\ No newline at end of file
diff --git a/libpsn00b/psxcd/cdmix.s b/libpsn00b/psxcd/cdmix.s
deleted file mode 100644
index 40cd181..0000000
--- a/libpsn00b/psxcd/cdmix.s
+++ /dev/null
@@ -1,34 +0,0 @@
-.set noreorder
-
-.include "hwregs_a.inc"
-
-.section .text
-
-
-.global CdMix
-.type CdMix, @function
-CdMix:
-
-	lui		$a3, IOBASE
-	
-	lbu		$t0, 0($a0)
-	lbu		$t1, 1($a0)
-	lbu		$t2, 2($a0)
-	lbu		$t3, 3($a0)
-	
-	li		$v0, 2
-	sb		$v0, CD_REG0($a3)
-	sb		$t0, CD_REG2($a3)
-	sb		$t1, CD_REG3($a3)
-	
-	li		$v0, 3
-	sb		$v0, CD_REG0($a3)
-	sb		$t2, CD_REG1($a3)
-	sb		$t3, CD_REG2($a3)
-	
-	li		$v0, 0x20
-	sb		$v0, CD_REG3($a3)
-	
-	jr		$ra
-	li		$v0, 1
-	
\ No newline at end of file
diff --git a/libpsn00b/psxcd/cdread.c b/libpsn00b/psxcd/cdread.c
new file mode 100644
index 0000000..d211a01
--- /dev/null
+++ b/libpsn00b/psxcd/cdread.c
@@ -0,0 +1,168 @@
+/*
+ * PSn00bSDK CD-ROM library (high-level reading API)
+ * (C) 2020-2022 Lameguy64, spicyjpeg - MPL licensed
+ *
+ * CdRead() and its related functions are separate from the "main" psxcd code
+ * since handling retries is fairly complicated. In particular the drive
+ * controller will not process any command properly for some time after a
+ * CdlPause command, so an external timer (the vblank counter) and manual
+ * polling are required to defer the next attempt.
+ */
+
+#include <stdint.h>
+#include <assert.h>
+#include <psxgpu.h>
+#include <psxapi.h>
+#include <psxcd.h>
+
+#define CD_READ_TIMEOUT		180
+#define CD_READ_COOLDOWN	60
+
+/* Internal globals */
+
+static CdlCB _read_callback = (CdlCB) 0;
+
+static int     _total_sectors, _sector_size;
+static uint8_t _read_result[4];
+
+static volatile uint32_t *_read_addr;
+static volatile int      _read_timeout, _pending_attempts, _pending_sectors;
+
+extern CdlCB _cd_override_callback;
+
+/* Private utilities and sector callback */
+
+static void _sector_callback(CdlIntrResult irq, uint8_t *result) {
+	if (irq == CdlDataReady) {
+		CdGetSector((void *) _read_addr, _sector_size);
+		_read_addr += _sector_size;
+
+		if (--_pending_sectors > 0) {
+			_read_timeout = VSync(-1) + CD_READ_TIMEOUT;
+			return;
+		}
+	}
+
+	// Stop reading if an error occurred or if no more sectors need to be read.
+	CdCommandF(CdlPause, 0, 0);
+
+	_cd_override_callback = (CdlCB) 0;
+	if (!_pending_attempts && _read_callback)
+		_read_callback(irq, result);
+
+	_read_timeout = VSync(-1) + CD_READ_COOLDOWN;
+}
+
+static int _poll_retry(void) {
+	if (!_pending_attempts) {
+		_sdk_log("CdRead() failed, too many attempts\n");
+
+		_pending_sectors = 0;
+		return -1;
+	}
+
+	//CdControlB(CdlPause, 0, 0);
+
+	_sdk_log("CdRead() failed, retrying (%d sectors pending)\n", _pending_sectors);
+	_pending_attempts--;
+
+	// Restart from the first sector that returned an error.
+	CdlLOC pos;
+	CdIntToPos(
+		CdPosToInt(CdLastPos()) + _total_sectors - _pending_sectors,
+		&pos
+	);
+
+	_read_timeout  = VSync(-1) + CD_READ_TIMEOUT;
+	_total_sectors = _pending_sectors;
+
+	FastEnterCriticalSection();
+	_cd_override_callback = &_sector_callback;
+	FastExitCriticalSection();
+
+	if (CdCommand(CdlSetloc, (uint8_t *) &pos, 3, _read_result))
+		CdCommand(CdlReadN, 0, 0, _read_result);
+
+	return _pending_sectors;
+}
+
+/* Public API */
+
+int CdReadRetry(int sectors, uint32_t *buf, int mode, int attempts) {
+	if (CdReadSync(1, 0) > 0) {
+		_sdk_log("CdRead() failed, another read in progress (%d sectors pending)\n", _pending_sectors);
+		return 0;
+	}
+
+	_read_addr        = buf;
+	_read_timeout     = VSync(-1) + CD_READ_TIMEOUT;
+	_pending_attempts = attempts - 1;
+	_pending_sectors  = sectors;
+	_total_sectors    = sectors;
+	_sector_size      = (mode & CdlModeSize) ? 585 : 512;
+
+	FastEnterCriticalSection();
+	_cd_override_callback = &_sector_callback;
+	FastExitCriticalSection();
+
+	uint8_t _mode = mode;
+	if (!CdCommand(CdlSetmode, &_mode, 1, 0))
+		return 0;
+	if (!CdCommand(CdlReadN, 0, 0, _read_result))
+		return 0;
+
+	return 1;
+}
+
+int CdRead(int sectors, uint32_t *buf, int mode) {
+	return CdReadRetry(sectors, buf, mode, 1);
+}
+
+void CdReadBreak(void) {
+	if (_pending_sectors > 0)
+		_pending_sectors = -1;
+}
+
+int CdReadSync(int mode, uint8_t *result) {
+	if (mode) {
+		if (_pending_sectors < 0)
+			return -2;
+		if (!_pending_sectors)
+			return 0;
+
+		if (VSync(-1) > _read_timeout)
+			return _poll_retry();
+		if (CdSync(1, 0) == CdlDiskError)
+			return -1;
+
+		return _pending_sectors;
+	}
+
+	while (_pending_sectors > 0) {
+		if (VSync(-1) > _read_timeout) {
+			if (_poll_retry() < 0)
+				return -1;
+		}
+
+		//if (CdSync(1, 0) == CdlDiskError)
+			//return -1;
+	}
+
+	CdlIntrResult status = CdSync(0, result);
+	if (_pending_sectors < 0)
+		return -2;
+	if (status != CdlComplete)
+		return -1;
+
+	return 0;
+}
+
+CdlCB CdReadCallback(CdlCB func) {
+	FastEnterCriticalSection();
+
+	CdlCB old_callback = _read_callback;
+	_read_callback     = func;
+
+	FastExitCriticalSection();
+	return old_callback;
+}
diff --git a/libpsn00b/psxcd/common.c b/libpsn00b/psxcd/common.c
new file mode 100644
index 0000000..6b20df2
--- /dev/null
+++ b/libpsn00b/psxcd/common.c
@@ -0,0 +1,435 @@
+/*
+ * PSn00bSDK CD-ROM library (common functions)
+ * (C) 2020-2022 Lameguy64, spicyjpeg - MPL licensed
+ */
+
+#include <stdint.h>
+#include <assert.h>
+#include <psxetc.h>
+#include <psxapi.h>
+#include <psxcd.h>
+#include <hwregs_c.h>
+
+#define CD_ACK_TIMEOUT		0x100000
+#define CD_SYNC_TIMEOUT		0x100000
+
+/* Internal globals */
+
+static CdlCB _ready_callback = (CdlCB) 0;
+static CdlCB _sync_callback  = (CdlCB) 0;
+static CdlCB _pause_callback = (CdlCB) 0;
+
+static uint8_t *_result_ptr;
+static uint8_t _last_command, _last_mode;
+static CdlLOC  _last_pos;
+
+static volatile uint8_t _last_status, _last_irq, _last_error;
+static volatile uint8_t _ack_pending, _sync_pending;
+
+// These globals are accessed by other parts of the library.
+CdlCB _cd_override_callback;
+volatile int _cd_media_changed;
+
+/* Command metadata */
+
+// The original implementation of CdControlF() and the IRQ handler used a
+// ridiculous number of branches to account for command-specific behavior.
+// Storing that information as an array of bitfields is far more efficient.
+typedef enum {
+	PARAM_1		= 1,
+	PARAM_2		= 2,
+	PARAM_3		= 3,
+	STATUS		= 1 << 2,	// First byte of CdlAcknowledge response is status
+	C_STATUS	= 1 << 3,	// First byte of CdlComplete response is status
+	BLOCKING	= 1 << 4,	// Command triggers CdlComplete interrupt
+	OPTIONAL	= 1 << 5,	// Parameter is optional for the command
+	SETLOC		= 1 << 6	// Parameter shall be sent as a separate CdlSetloc
+} CommandFlags;
+
+// https://problemkaputt.de/psx-spx.htm#cdromcontrollercommandsummary
+static const uint8_t _command_flags[] = {
+	0,
+	STATUS,									// CdlNop
+	STATUS | PARAM_3,						// CdlSetloc
+	STATUS | OPTIONAL | PARAM_1,			// CdlPlay
+	//STATUS | SETLOC,						// CdlPlay
+	STATUS,									// CdlForward
+	STATUS,									// CdlBackward
+	STATUS | SETLOC,						// CdlReadN
+	STATUS | C_STATUS | BLOCKING,			// CdlStandby
+	STATUS | C_STATUS | BLOCKING,			// CdlStop
+	STATUS | C_STATUS | BLOCKING,			// CdlPause
+	STATUS | C_STATUS | BLOCKING,			// CdlInit
+	STATUS,									// CdlMute
+	STATUS,									// CdlDemute
+	STATUS | PARAM_2,						// CdlSetfilter
+	STATUS | PARAM_1,						// CdlSetmode
+	STATUS,									// CdlGetparam
+	0,										// CdlGetlocL
+	0,										// CdlGetlocP
+	STATUS | C_STATUS | BLOCKING | PARAM_1,	// CdlSetsession
+	STATUS,									// CdlGetTN
+	STATUS | PARAM_1,						// CdlGetTD
+	STATUS | C_STATUS | BLOCKING | SETLOC,	// CdlSeekL
+	STATUS | C_STATUS | BLOCKING | SETLOC,	// CdlSeekP
+	0,
+	0,
+	PARAM_1,								// CdlTest
+	STATUS | C_STATUS | BLOCKING,			// CdlGetID
+	STATUS | SETLOC,						// CdlReadS
+	STATUS,									// CdlReset
+	STATUS | BLOCKING | PARAM_2,			// CdlGetQ
+	STATUS | C_STATUS | BLOCKING			// CdlReadTOC
+};
+
+/* Private interrupt handler */
+
+static void _update_status(uint8_t status) {
+	uint8_t last = _last_status;
+	_last_status = status;
+
+	if (!(last & CdlStatError) && (status & CdlStatError))
+		_sdk_log("drive error, status=0x%02x, code=0x%02x\n", _last_status, _last_error);
+
+	if (!(last & CdlStatShellOpen) && (status & CdlStatShellOpen)) {
+		_sdk_log("shell opened, invalidating cache\n");
+		_cd_media_changed = 1;
+	}
+}
+
+static void _cd_irq_handler(void) {
+	CD_REG(0) = 1;
+	CdlIntrResult irq = CD_REG(3) & 7;
+
+	if (irq == CdlDataReady) {
+		// TODO: are the first 4 accesses really needed, or was this just
+		// Sony's (dumb) way to flush the KUSEG write queue? We definitely
+		// don't need to do that since we're using KSEG1.
+		CD_REG(0) = 0;
+		CD_REG(0);
+		CD_REG(3) = 0;
+		CD_REG(3);
+		CD_REG(0) = 0;
+		CD_REG(3) = 0x80; // Request data
+	}
+
+	CD_REG(0) = 1;
+	CD_REG(3) = 0x1f; // Acknowledge all IRQs
+	CD_REG(3) = 0x40; // Reset parameter buffer
+
+	//while (CD_REG(0) & (1 << 5))
+		//CD_REG(1);
+	for (int i = 0; i < 50; i++)
+		__asm__ volatile("");
+
+	if (!irq || (irq > CdlDiskError))
+		return;
+
+	// Fetch the result from the drive if a buffer was previously set up. The
+	// first byte is always read as it contains the drive status for most
+	// commands.
+	uint8_t first_byte = CD_REG(1);
+	CdlCB   callback;
+
+	if (_result_ptr) {
+		_result_ptr[0] = first_byte;
+
+		for (int i = 1; (CD_REG(0) & 0x20) && (i < 8); i++)
+			_result_ptr[i] = CD_REG(1);
+	}
+
+	switch (irq) {
+		case CdlDataReady:
+			// CdRead() can override any callback set using CdReadyCallback()
+			// by setting _cd_override_callback.
+			callback = _cd_override_callback;
+			if (!callback)
+				callback = _ready_callback;
+
+			_update_status(first_byte);
+			break;
+
+		case CdlComplete:
+			_sync_pending = 0;
+			callback      = _sync_callback;
+
+			if (_last_command <= CdlReadTOC) {
+				if (_command_flags[_last_command] & C_STATUS)
+					_update_status(first_byte);
+			}
+			break;
+
+		case CdlAcknowledge:
+			_ack_pending = 0;
+			callback     = (CdlCB) 0;
+
+			if (_last_command <= CdlReadTOC) {
+				if (_command_flags[_last_command] & STATUS)
+					_update_status(first_byte);
+			}
+			break;
+
+		case CdlDataEnd:
+			callback = _pause_callback;
+
+			_update_status(first_byte);
+			break;
+
+		case CdlDiskError:
+			_last_error = CD_REG(1);
+			callback    = _ready_callback;
+
+			if (_ack_pending || _sync_pending) {
+				if (_sync_callback)
+					_sync_callback(irq, _result_ptr);
+
+				_ack_pending  = 0;
+				_sync_pending = 0;
+			}
+
+			_update_status(first_byte);
+			break;
+	}
+
+	if (callback)
+		callback(irq, _result_ptr);
+
+	_last_command = 0;
+	_last_irq     = irq;
+	_result_ptr   = (uint8_t *) 0;
+}
+
+/* Initialization */
+
+int CdInit(void) {
+	EnterCriticalSection();
+	InterruptCallback(IRQ_CD, &_cd_irq_handler);
+	ExitCriticalSection();
+
+	CD_DELAY_SIZE = 0x00020943;
+
+	CD_REG(0) = 1;
+	CD_REG(3) = 0x1f; // Acknowledge all IRQs
+	CD_REG(2) = 0x1f; // Enable all IRQs
+	CD_REG(0) = 0;
+	CD_REG(3) = 0x00; // Clear any pending request
+
+	CdlATV mix = { 0x80, 0x00, 0x80, 0x00 };
+	CdMix(&mix);
+
+	DMA_DPCR        |= 0x0000b000; // Enable DMA3
+	DMA_CHCR(DMA_CD) = 0x00000000; // Stop DMA3
+
+	_last_mode    = 0;
+	_ack_pending  = 0;
+	_sync_pending = 0;
+
+	_cd_override_callback = (CdlCB) 0;
+	_cd_media_changed     = 1;
+
+	// Initialize the drive.
+	CdCommand(CdlNop, 0, 0, 0);
+	CdCommand(CdlInit, 0, 0, 0);
+
+	if (CdSync(0, 0) == CdlDiskError) {
+		_sdk_log("setup error, bad disc/drive or no disc inserted\n");
+		return 0;
+	}
+
+	CdCommand(CdlDemute, 0, 0, 0);
+	_sdk_log("setup done\n");
+	return 1;
+}
+
+/* Low-level command API */
+
+int CdCommandF(CdlCommand cmd, const void *param, int length) {
+	const uint8_t *_param = (const uint8_t *) param;
+
+	_last_command = (uint8_t) cmd;
+	_ack_pending  = 1;
+
+	if (cmd <= CdlReadTOC) {
+		if (_command_flags[cmd] & BLOCKING)
+			_sync_pending = 1;
+
+		// Keep track of the last mode and seek location set (so retries can be
+		// attempted).
+		
+		if (cmd == CdlSetloc) {
+			_last_pos.minute = _param[0];
+			_last_pos.second = _param[1];
+			_last_pos.sector = _param[2];
+		} else if (cmd == CdlSetmode) {
+			_last_mode = _param[0];
+		}
+	}
+
+	// Request a command FIFO write.
+	while (CD_REG(0) & 0x80)
+		__asm__ volatile("");
+
+	CD_REG(0) = 1;
+	CD_REG(3) = 0x40; // Reset parameter buffer
+
+	//while (CD_REG(0) & (1 << 5))
+		//CD_REG(1);
+	for (int i = 0; i < 50; i++)
+		__asm__ volatile("");
+
+	// Wait for the FIFO to become ready, then send the parameters followed by
+	// the command index.
+	while (CD_REG(0) & (1 << 7))
+		__asm__ volatile("");
+
+	CD_REG(0) = 0;
+	for (; length; length--)
+		CD_REG(2) = *(_param++);
+
+	CD_REG(0) = 0;
+	CD_REG(1) = (uint8_t) cmd;
+	return 1;
+}
+
+int CdCommand(CdlCommand cmd, const void *param, int length, uint8_t *result) {
+	/*if (_ack_pending) {
+		_sdk_log("CdCommand(0x%02x) failed, drive busy\n", cmd);
+		return 0;
+	}*/
+
+	_result_ptr = result;
+	CdCommandF(cmd, param, length);
+
+	// Wait for the command to be acknowledged.
+	for (int i = CD_ACK_TIMEOUT; i; i--) {
+		if (!_ack_pending)
+			return 1;
+	}
+
+	_sdk_log("CdCommand(0x%02x) failed, acknowledge timeout\n", cmd);
+	return 0;
+}
+
+/* High-level command API */
+
+int CdControlF(CdlCommand cmd, const void *param) {
+	// Assume no parameters need to be passed if the command is unknown.
+	uint8_t flags = (cmd <= CdlReadTOC) ? _command_flags[cmd] : 0;
+	int length;
+
+	if (flags & OPTIONAL) {
+		// The command may optionally take a parameter.
+		length = param ? (flags & 3) : 0;
+	} else if (flags & SETLOC) {
+		// The command takes no parameter, but the API allows specifying a
+		// location to be sent to the drive as a separate CdlSetloc command.
+		length = 0;
+		if (param)
+			CdCommandF(CdlSetloc, param, 3);
+	} else {
+		// The command takes a mandatory parameter or no parameter.
+		length = flags & 3;
+		if (length && !param)
+			return -1;
+	}
+
+	return CdCommandF(cmd, param, length);
+}
+
+int CdControl(CdlCommand cmd, const void *param, uint8_t *result) {
+	/*if (_ack_pending) {
+		_sdk_log("CdControl(0x%02x) failed, drive busy\n", cmd);
+		return 0;
+	}*/
+
+	_result_ptr = result;
+	CdControlF(cmd, param);
+
+	// Wait for the command to be acknowledged.
+	for (int i = CD_ACK_TIMEOUT; i; i--) {
+		if (!_ack_pending)
+			return 1;
+	}
+
+	_sdk_log("CdControl(0x%02x) failed, acknowledge timeout\n", cmd);
+	return 0;
+}
+
+int CdControlB(CdlCommand cmd, const void *param, uint8_t *result) {
+	int error = CdControl(cmd, param, result);
+	if (error != 1)
+		return error;
+
+	error = CdSync(0, 0);
+	return (error == CdlDiskError) ? 0 : 1;
+}
+
+/* Other APIs and callback setters */
+
+CdlIntrResult CdSync(int mode, uint8_t *result) {
+	if (mode) {
+		if (_sync_pending)
+			return CdlNoIntr;
+
+		if (result)
+			*result = _last_status;
+		if (_last_irq == CdlAcknowledge)
+			return CdlComplete;
+
+		return _last_irq;
+	}
+
+	for (int i = CD_SYNC_TIMEOUT; i; i--) {
+		if (!_sync_pending)
+			return CdSync(1, result); // :P
+	}
+
+	_sdk_log("CdSync() timeout\n");
+	return -1;
+}
+
+CdlCommand CdLastCom(void) {
+	return _last_command;
+}
+
+const CdlLOC *CdLastPos(void) {
+	return &_last_pos;
+}
+
+int CdMode(void) {
+	return _last_mode;
+}
+
+int CdStatus(void) {
+	return _last_status;
+}
+
+CdlCB CdReadyCallback(CdlCB func) {
+	FastEnterCriticalSection();
+
+	CdlCB old_callback = _ready_callback;
+	_ready_callback    = func;
+
+	FastExitCriticalSection();
+	return old_callback;
+}
+
+CdlCB CdSyncCallback(CdlCB func) {
+	FastEnterCriticalSection();
+
+	CdlCB old_callback = _sync_callback;
+	_sync_callback     = func;
+
+	FastExitCriticalSection();
+	return old_callback;
+}
+
+CdlCB CdAutoPauseCallback(CdlCB func) {
+	FastEnterCriticalSection();
+
+	CdlCB old_callback = _pause_callback;
+	_pause_callback    = func;
+
+	FastExitCriticalSection();
+	return old_callback;
+}
diff --git a/libpsn00b/psxcd/getsector.c b/libpsn00b/psxcd/getsector.c
deleted file mode 100644
index a214d7a..0000000
--- a/libpsn00b/psxcd/getsector.c
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * PSn00bSDK CD drive library (sector DMA API)
- * (C) 2022 spicyjpeg - MPL licensed
- */
-
-#include <stdint.h>
-#include <assert.h>
-#include <psxcd.h>
-#include <hwregs_c.h>
-
-#define DATA_SYNC_TIMEOUT	0x100000
-
-/* DMA transfer functions */
-
-int CdGetSector(void *madr, int size) {
-	//while (!(CD_STAT & (1 << 6)))
-		//__asm__ volatile("");
-
-	DMA_MADR(3) = (uint32_t) madr;
-	DMA_BCR(3)  = size | (1 << 16);
-	DMA_CHCR(3) = 0x11000000;
-
-	while (DMA_CHCR(3) & (1 << 24))
-		__asm__ volatile("");
-
-	return 1;
-}
-
-int CdGetSector2(void *madr, int size) {
-	//while (!(CD_STAT & (1 << 6)))
-		//__asm__ volatile("");
-
-	DMA_MADR(3) = (uint32_t) madr;
-	DMA_BCR(3)  = size | (1 << 16);
-	DMA_CHCR(3) = 0x11400100; // Transfer 1 word every 16 CPU cycles
-
-	return 1;
-}
-
-int CdDataSync(int mode) {
-	if (mode)
-		return (DMA_CHCR(3) >> 24) & 1;
-
-	for (int i = DATA_SYNC_TIMEOUT; i; i--) {
-		if (!(DMA_CHCR(3) & (1 << 24)))
-			return 0;
-	}
-
-	_sdk_log("CdDataSync() timeout\n");
-	return -1;
-}
diff --git a/libpsn00b/psxcd/isofs.c b/libpsn00b/psxcd/isofs.c
index e00ddeb..0ac782b 100644
--- a/libpsn00b/psxcd/isofs.c
+++ b/libpsn00b/psxcd/isofs.c
@@ -11,6 +11,7 @@
 #include <psxcd.h>
 #include "isofs.h"
 
+#define CD_READ_ATTEMPTS	3
 #define DEFAULT_PATH_SEP	'\\'
 #define IS_PATH_SEP(ch)		(((ch) == '/') || ((ch) == '\\'))
 
@@ -21,7 +22,7 @@ typedef struct _CdlDIR_INT
 	uint8_t		*_dir;
 } CdlDIR_INT;
 
-extern int _cd_media_changed;
+extern volatile int _cd_media_changed;
 
 
 static int		_cd_iso_last_dir_lba;
@@ -77,7 +78,7 @@ static int _CdReadIsoDescriptor(int session_offs)
 	_sdk_log("Read sectors.\n");
 
 	// Read volume descriptor
-	CdRead(1, (uint32_t*)_cd_iso_descriptor_buff, CdlModeSpeed);
+	CdReadRetry(1, (uint32_t*)_cd_iso_descriptor_buff, CdlModeSpeed, CD_READ_ATTEMPTS);
 	
 	if( CdReadSync(0, 0) )
 	{
@@ -115,7 +116,7 @@ static int _CdReadIsoDescriptor(int session_offs)
 	// Read path table
 	CdIntToPos(descriptor->pathTable1Offs, &loc);
 	CdControl(CdlSetloc, (uint8_t*)&loc, 0);
-	CdRead(i>>11, (uint32_t*)_cd_iso_pathtable_buff, CdlModeSpeed);
+	CdReadRetry(i>>11, (uint32_t*)_cd_iso_pathtable_buff, CdlModeSpeed, CD_READ_ATTEMPTS);
 	if( CdReadSync(0, 0) )
 	{
 		_sdk_log("Error reading ISO path table.\n");
@@ -163,7 +164,7 @@ static int _CdReadIsoDirectory(int lba)
 	
 	// Read first sector of directory record
 	_cd_iso_directory_buff = (uint8_t*)malloc(2048);
-	CdRead(1, (uint32_t*)_cd_iso_directory_buff, CdlModeSpeed);
+	CdReadRetry(1, (uint32_t*)_cd_iso_directory_buff, CdlModeSpeed, CD_READ_ATTEMPTS);
 	if( CdReadSync(0, 0) )
 	{
 		_sdk_log("Error reading initial directory record.\n");
@@ -194,7 +195,7 @@ static int _CdReadIsoDirectory(int lba)
 
 		_sdk_log("Allocated %d bytes for directory record.\n", i);
 
-		CdRead(i>>11, (uint32_t*)_cd_iso_directory_buff, CdlModeSpeed);
+		CdReadRetry(i>>11, (uint32_t*)_cd_iso_directory_buff, CdlModeSpeed, CD_READ_ATTEMPTS);
 		if( CdReadSync(0, 0) )
 		{
 			_sdk_log("Error reading remaining directory record.\n");
@@ -485,13 +486,13 @@ CdlFILE *CdSearchFile(CdlFILE *fp, const char *filename)
 	}
 	else
 	{
-		_sdk_log("Longest path: %s|\n", rbuff);
+		_sdk_log("Longest path: %s\n", rbuff);
 	}
 #endif
 	
 	if( get_pathname(search_path, filename) )
 	{
-		_sdk_log("Search path = %s|\n", search_path);
+		_sdk_log("Search path = %s\n", search_path);
 	}
 	
 	// Search the pathtable for a matching path
@@ -499,7 +500,7 @@ CdlFILE *CdSearchFile(CdlFILE *fp, const char *filename)
 	for(i=1; i<num_dirs; i++)
 	{
 		rbuff = resolve_pathtable_path(i, tpath_rbuff+127);
-		_sdk_log("Found = %s|\n", rbuff);
+		_sdk_log("Found = %s\n", rbuff);
 
 		if( rbuff )
 		{
@@ -580,7 +581,7 @@ CdlDIR *CdOpenDir(const char* path)
 	for( i=1; i<num_dirs; i++ )
 	{
 		rbuff = resolve_pathtable_path( i, tpath_rbuff+127 );
-		_sdk_log( "Found = %s|\n", rbuff );
+		_sdk_log( "Found = %s\n", rbuff );
 
 		if( rbuff )
 		{
@@ -666,11 +667,9 @@ int CdReadDir(CdlDIR *dir, CdlFILE* file)
 	
 	file->size = dir_entry->entrySize.lsb;
 
-	_sdk_log("dir_entry->entryLength = %d, ", dir_entry->entryLength);
-
 	d_dir->_pos += dir_entry->entryLength;
 
-	_sdk_log("d_dir->_pos = %d\n", d_dir->_pos);
+	_sdk_log("dir_entry->entryLength = %d, d_dir->_pos = %d\n", dir_entry->entryLength, d_dir->_pos);
 
 	// Check if padding is reached (end of record sector)
 	if( d_dir->_dir[d_dir->_pos] == 0 )
@@ -697,34 +696,29 @@ int CdIsoError()
 	return _cd_iso_error;
 }
 
-int CdGetVolumeLabel(char* label)
+int CdGetVolumeLabel(char *label)
 {
-	int i;
+	int i, length = 31;
 	ISO_DESCRIPTOR* descriptor;
-	
+
 	if( _CdReadIsoDescriptor(0) )
-	{
 		return -1;
-	}
-	
+
 	descriptor = (ISO_DESCRIPTOR*)_cd_iso_descriptor_buff;
-	
-	i = 0;
-	for( i=0; (descriptor->volumeID[i]!=0x20)&&(i<32); i++ )
-	{
-		label[i] = descriptor->volumeID[i];
-	}
-	
-	label[i] = 0x00;
-	
-	return 0;
+
+	while (descriptor->volumeID[length] == 0x20)
+		length--;
+
+	length++;
+	memcpy(label, descriptor->volumeID, length);
+	label[length] = 0x00;
+
+	return length;
 }
 
 
 // Session load routine
 
-void _cd_control(unsigned char com, unsigned char *param, int plen);
-
 static volatile unsigned int _ready_oldcb;
 
 static volatile int _ses_scanfound;
@@ -733,7 +727,7 @@ static volatile int _ses_scancomplete;
 //static volatile char _ses_scan_resultbuff[8];
 static volatile char *_ses_scanbuff;
 
-static void _scan_callback(int status, unsigned char *result)
+static void _scan_callback(CdlIntrResult status, unsigned char *result)
 {
 	if( status == CdlDataReady )
 	{
@@ -743,7 +737,7 @@ static void _scan_callback(int status, unsigned char *result)
 		{
 			if( strncmp((const char*)_ses_scanbuff+1, "CD001", 5) == 0 )
 			{
-				_cd_control(CdlPause, 0, 0);
+				CdControlF(CdlPause, 0);
 				_ses_scancomplete = 1;
 				_ses_scanfound = 1;
 				return;
@@ -752,7 +746,7 @@ static void _scan_callback(int status, unsigned char *result)
 		_ses_scancount++;
 		if( _ses_scancount >= 512 )
 		{
-			_cd_control(CdlPause, 0, 0);
+			CdControlF(CdlPause, 0);
 			_ses_scancomplete = 1;
 			return;
 		}
@@ -760,7 +754,7 @@ static void _scan_callback(int status, unsigned char *result)
 	
 	if( status == CdlDiskError )
 	{
-		_cd_control(CdlPause, 0, 0);
+		CdControlF(CdlPause, 0);
 		_ses_scancomplete = 1;
 	}
 }
@@ -768,7 +762,7 @@ static void _scan_callback(int status, unsigned char *result)
 int CdLoadSession(int session)
 {
 	CdlLOC *loc;
-	unsigned int ready_oldcb;
+	CdlCB ready_oldcb;
 	char scanbuff[2048];
 	char resultbuff[16];
 	int i;
@@ -791,9 +785,7 @@ int CdLoadSession(int session)
 	}
 	
 	// Set search routine callback
-	EnterCriticalSection();
 	ready_oldcb = CdReadyCallback(_scan_callback);
-	ExitCriticalSection();
 
 	_ses_scanfound = 0;
 	_ses_scancount = 0;
@@ -810,26 +802,20 @@ int CdLoadSession(int session)
 	// Wait until scan complete
 	while(!_ses_scancomplete);
 
-	EnterCriticalSection();
 	CdReadyCallback((void*)_ready_oldcb);
-	ExitCriticalSection();
 
 	if( !_ses_scanfound )
 	{
 		_sdk_log("CdLoadSession(): Did not find volume descriptor.\n");
 
 		_cd_iso_error = CdlIsoInvalidFs;
-		EnterCriticalSection();
 		CdReadyCallback((CdlCB)ready_oldcb);
-		ExitCriticalSection();
 
 		return -1;
 	}
 	
 	// Restore old callback if any
-	EnterCriticalSection();
 	CdReadyCallback((CdlCB)ready_oldcb);
-	ExitCriticalSection();
 
 	// Wait until CD-ROM has completely stopped reading, to get a consistent
 	// fix of the CD-ROM pickup's current location
diff --git a/libpsn00b/psxcd/misc.c b/libpsn00b/psxcd/misc.c
new file mode 100644
index 0000000..8fd2a4d
--- /dev/null
+++ b/libpsn00b/psxcd/misc.c
@@ -0,0 +1,151 @@
+/*
+ * PSn00bSDK CD-ROM library (misc. functions)
+ * (C) 2020-2022 Lameguy64, spicyjpeg - MPL licensed
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <psxetc.h>
+#include <psxcd.h>
+#include <hwregs_c.h>
+
+#define DATA_SYNC_TIMEOUT	0x100000
+
+/* Private types */
+
+typedef struct {
+	uint8_t status, first_track, last_track;
+} TrackInfo;
+
+/* Sector DMA transfer functions */
+
+int CdGetSector(void *madr, int size) {
+	//while (!(CD_REG(0) & (1 << 6)))
+		//__asm__ volatile("");
+
+	DMA_MADR(DMA_CD) = (uint32_t) madr;
+	DMA_BCR(DMA_CD)  = size | (1 << 16);
+	DMA_CHCR(DMA_CD) = 0x11000000;
+
+	while (DMA_CHCR(DMA_CD) & (1 << 24))
+		__asm__ volatile("");
+
+	return 1;
+}
+
+int CdGetSector2(void *madr, int size) {
+	//while (!(CD_REG(0) & (1 << 6)))
+		//__asm__ volatile("");
+
+	DMA_MADR(DMA_CD) = (uint32_t) madr;
+	DMA_BCR(DMA_CD)  = size | (1 << 16);
+	DMA_CHCR(DMA_CD) = 0x11400100; // Transfer 1 word every 16 CPU cycles
+
+	return 1;
+}
+
+int CdDataSync(int mode) {
+	if (mode)
+		return (DMA_CHCR(DMA_CD) >> 24) & 1;
+
+	for (int i = DATA_SYNC_TIMEOUT; i; i--) {
+		if (!(DMA_CHCR(DMA_CD) & (1 << 24)))
+			return 0;
+	}
+
+	_sdk_log("CdDataSync() timeout\n");
+	return -1;
+}
+
+/* LBA/MSF conversion */
+
+CdlLOC *CdIntToPos(int i, CdlLOC *p) {
+	i += 150;
+
+	p->minute = itob(i / (75 * 60));
+	p->second = itob((i / 75) % 60);
+	p->sector = itob(i % 75);
+	return p;
+}
+
+int CdPosToInt(const CdlLOC *p) {	
+	return (
+		(btoi(p->minute) * (75 * 60)) +
+		(btoi(p->second) * 75) +
+		btoi(p->sector)
+	) - 150;
+}
+
+/* Misc. functions */
+
+int CdGetToc(CdlLOC *toc) {
+	TrackInfo track_info;
+
+	if (!CdCommand(CdlGetTN, 0, 0, (uint8_t *) &track_info))
+		return 0;
+	if (CdSync(1, 0) != CdlComplete)
+		return 0;
+
+	int first  = btoi(track_info.first_track);
+	int tracks = btoi(track_info.last_track) + 1 - first;
+	//assert(first == 1);
+
+	for (int i = 0; i < tracks; i++) {
+		uint8_t track = itob(first + i);
+
+		if (!CdCommand(CdlGetTD, &track, 1, (uint8_t *) &toc[i]))
+			return 0;
+		if (CdSync(1, 0) != CdlComplete)
+			return 0;
+
+		toc[i].sector = 0;
+		toc[i].track  = track;
+	}
+
+	return tracks;
+}
+
+CdlRegionCode CdGetRegion(void) {
+	uint8_t param = 0x22;
+	uint8_t result[16];
+
+	// Test command 0x22 is unsupported in firmware version C0, which was used
+	// exclusively in the SCPH-1000 Japanese model. It's thus safe to assume
+	// that the console is Japanese if the command returns a valid error.
+	// https://psx-spx.consoledev.net/cdromdrive/#19h22h-int3for-europe
+	memset(result, 0, 16);
+
+	if (!CdCommand(CdlTest, &param, 1, result)) {
+		_sdk_log("failed to probe drive region\n");
+		return (result[1] == 0x10) ? CdlRegionSCEI : CdlRegionUnknown;
+	}
+
+	_sdk_log("drive region: %s\n", result);
+
+	if (!strcmp(result, "for Japan"))
+		return CdlRegionSCEI;
+	if (!strcmp(result, "for U/C"))
+		return CdlRegionSCEA;
+	if (!strcmp(result, "for Europe"))
+		return CdlRegionSCEE;
+	if (!strcmp(result, "for NETNA") || !strcmp(result, "for NETEU"))
+		return CdlRegionSCEW;
+	if (!strcmp(result, "for US/AEP"))
+		return CdlRegionDebug;
+
+	return CdlRegionUnknown;
+}
+
+int CdMix(const CdlATV *vol) {
+	CD_REG(0) = 2;
+	CD_REG(2) = vol->val0;
+	CD_REG(3) = vol->val1;
+
+	CD_REG(0) = 3;
+	CD_REG(1) = vol->val2;
+	CD_REG(2) = vol->val3;
+
+	CD_REG(3) = 0x20; // Unmute XA, apply volume changes
+	return 1;
+}
diff --git a/libpsn00b/psxcd/psxcd.c b/libpsn00b/psxcd/psxcd.c
deleted file mode 100644
index 9392d30..0000000
--- a/libpsn00b/psxcd/psxcd.c
+++ /dev/null
@@ -1,371 +0,0 @@
-#include <stdint.h>
-#include <assert.h>
-#include <psxgpu.h>
-#include <psxapi.h>
-#include <psxcd.h>
-
-#define READ_TIMEOUT	600		// 10 seconds for NTSC
-
-extern volatile char _cd_ack_wait;
-extern volatile uint8_t _cd_last_int;
-extern volatile uint8_t _cd_last_mode;
-extern volatile uint8_t _cd_status;
-extern volatile CdlCB _cd_callback_int1_data;
-
-volatile uint8_t *_cd_result_ptr;
-
-// For read retry
-volatile CdlLOC _cd_last_setloc;
-volatile uint32_t *_cd_last_read_addr;
-volatile int _cd_last_sector_count;
-
-int _cd_media_changed;
-
-void _cd_init(void);
-void _cd_control(unsigned char com, const void *param, int plen);
-void _cd_wait_ack(void);
-void _cd_wait(void);
-
-int CdInit(void) {
-	// Sets up CD-ROM hardware and low-level subsystem
-	_cd_init();
-	
-	// So CD ISO file system component will update the ISO descriptor
-	_cd_media_changed = 1;
-	
-	// Issue commands to initialize the CD-ROM hardware
-	CdControl(CdlNop, 0, 0);
-	CdControl(CdlInit, 0, 0);
-	
-	if(CdSync(0, 0) != CdlDiskError) {
-		CdControl(CdlDemute, 0, 0);
-		_sdk_log("setup done\n");
-	} else {
-		_sdk_log("setup error, bad disc/drive or no disc inserted\n");
-	}
-	
-	return 1;
-}
-
-int CdControl(unsigned char com, const void *param, unsigned char *result)
-{	
-	// Don't issue command if ack is not received yet
-	if( _cd_ack_wait )
-	{
-		return 0;
-	}
-	
-	_cd_result_ptr = result;
-	
-	CdControlF(com, param);
-	_cd_wait_ack();
-	
-	// Set media changed flag if lid had been opened
-	if( (CdStatus()&0x10) )
-	{
-		_cd_media_changed = 1;
-	}
-	
-	return 1;
-}
-
-int CdControlB(unsigned char com, const void *param, unsigned char *result)
-{
-	if( !CdControl(com, param, result) )
-	{
-		return 0;
-	}
-	
-	CdSync(0, 0);
-	return 1;
-}
-
-int CdControlF(unsigned char com, const void *param)
-{
-	int param_len=0;
-
-	// Command specific parameters
-	switch(com)
-	{
-		case CdlSetloc:
-			param_len = 3;
-			_cd_last_setloc = *((CdlLOC*)param);
-			break;
-		case CdlPlay:
-			if( param )
-			{
-				param_len = 1;
-			}
-			break;
-		case CdlSetfilter:
-			param_len = 2;
-			break;
-		case CdlSetmode:
-		case CdlSetsession:
-		case CdlTest:
-		case CdlGetTD:
-			param_len = 1;
-			break;
-		case CdlReadN:
-		case CdlReadS:
-		case CdlSeekL:
-		case CdlSeekP:
-			if( param )
-			{
-				_cd_control(CdlSetloc, param, 3);
-				_cd_last_setloc = *((CdlLOC*)param);
-			}
-			break;
-	}
-
-	// Issue CD command
-	_cd_control(com, param, param_len);
-
-	return 1;
-}
-
-int CdSync(int mode, unsigned char *result)
-{
-	int cdirq;
-	
-	if( mode )
-	{
-		if( result )
-		{
-			*result = _cd_status;
-		}
-		
-		cdirq = _cd_last_int;
-		if( cdirq == CdlAcknowledge )
-		{
-			cdirq = CdlComplete;
-		}
-		return cdirq;
-	}
-	
-	_cd_wait();
-	
-	if( result )
-	{
-		*result = _cd_status;
-	}
-	
-	cdirq = _cd_last_int;
-	if( cdirq == CdlAcknowledge )
-	{
-		cdirq = CdlComplete;
-	}
-	
-	return cdirq;
-}
-
-int CdGetToc(CdlLOC *toc)
-{
-	uint8_t track_info[8];
-	int i,tracks;
-	
-	// Get number of tracks
-	if( !CdControl(CdlGetTN, 0, track_info) )
-	{
-		return 0;
-	}
-	
-	if( CdSync(1, 0) != CdlComplete )
-	{
-		return 0;
-	}
-	
-	tracks = 1+(btoi(track_info[2])-btoi(track_info[1]));
-	
-	// Get track positions
-	for(i=0; i<tracks; i++)
-	{
-		int t = itob(1+i);
-		if( !CdControl(CdlGetTD, (uint8_t*)&t, (uint8_t*)&toc[i]) )
-		{
-			return 0;
-		}
-		if( CdSync(1, 0) != CdlComplete )
-		{
-			return 0;
-		}
-		toc[i].sector = 0;
-		toc[i].track = 1+i;
-	}
-	
-	return tracks;
-}
-
-CdlLOC *CdIntToPos(int i, CdlLOC *p) {
-
-	i += 150;
-	
-	p->minute = itob((i/75)/60);
-	p->second = itob((i/75)%60);
-	p->sector = itob(i%75);
-
-	return p;
-	
-}
-
-int CdPosToInt(const CdlLOC *p)
-{	
-	return ((75*(btoi(p->minute)*60))+(75*btoi(p->second))+btoi(p->sector))-150;
-}
-
-int CdStatus(void)
-{	
-	return _cd_status;	
-}
-
-int CdMode(void)
-{
-	return _cd_last_mode;
-}
-
-
-// CD data read routines
-volatile int _cd_sector_count = 0;
-volatile uint32_t *_cd_read_addr;
-volatile uint8_t _cd_read_result[8];
-volatile uint32_t _cd_read_oldcb;
-volatile uint32_t _cd_read_sector_sz;
-volatile uint32_t _cd_read_counter;
-
-
-
-volatile CdlCB _cd_read_cb;
-
-// Sector callback
-static void _CdReadReadyCallback(int status, unsigned char *result)
-{
-	_cd_read_counter = VSync(-1);
-
-	if( status == CdlDataReady )
-	{
-		// Fetch sector from CD controller
-		CdGetSector((void*)_cd_read_addr, _cd_read_sector_sz);
-		
-		// Increment destination address
-		_cd_read_addr += _cd_read_sector_sz;
-	
-		// Subtract sector count
-		_cd_sector_count--;
-	}
-	
-	// End reading with pause command when sector count reaches zero
-	// or when an error occurs
-	if( ( _cd_sector_count <= 0 ) || ( status == CdlDiskError ) )
-	{
-		// Stop reading
-		_cd_control(CdlPause, 0, 0);
-		
-		// Revert previous ready callback
-		_cd_callback_int1_data = (CdlCB)_cd_read_oldcb;
-		
-		// Execute read completion callback
-		if( _cd_read_cb )
-		{
-			_cd_read_cb(status, result);
-		}
-	}
-}
-
-int CdRead(int sectors, uint32_t *buf, int mode)
-{
-	// Set sectors to read count
-	_cd_sector_count = sectors;
-	_cd_last_sector_count = sectors;
-	_cd_last_read_addr = buf;
-	_cd_read_addr = buf;
-	
-	// Determine sector based on mode flags
-	if( mode & CdlModeSize )
-		_cd_read_sector_sz = 2340 / 4;
-	else
-		_cd_read_sector_sz = 2048 / 4;
-	
-	_cd_read_counter = VSync(-1);
-	
-	// Set read callback
-	EnterCriticalSection();
-	_cd_read_oldcb = CdReadyCallback(_CdReadReadyCallback);
-	ExitCriticalSection();
-
-	// Set specified mode
-	CdControl(CdlSetmode, (uint8_t*)&mode, 0);
-	
-	// Begin reading sectors
-	CdControl(CdlReadN, 0, (uint8_t*)_cd_read_result);
-	
-	return 0;
-}
-
-static void CdDoRetry()
-{
-	int cb;
-	
-	_sdk_log("retrying read...\n");
-	
-	// Stop reading
-	CdControl(CdlPause, 0, 0);
-	CdSync(0, 0);
-	
-	// Reset parameters for retrying read operation
-	_cd_sector_count	= _cd_last_sector_count;
-	_cd_read_addr		= _cd_last_read_addr;
-	
-	// Reset timeout
-	_cd_read_counter = VSync(-1);
-
-	EnterCriticalSection();
-	CdReadyCallback(_CdReadReadyCallback);
-	ExitCriticalSection();
-
-	// Retry read
-	CdControl(CdlSetloc, (void*)&_cd_last_setloc, 0);
-	CdControl(CdlReadN, 0, (uint8_t*)_cd_read_result);
-}
-
-int CdReadSync(int mode, uint8_t *result)
-{
-	if( (VSync(-1)-_cd_read_counter) > READ_TIMEOUT )
-	{
-		CdDoRetry();
-	}
-
-	if( mode )
-	{
-		if( CdSync(1, 0) == CdlDiskError )
-		{
-			return -1;
-		}
-		return _cd_sector_count;
-	}
-	
-	while(_cd_sector_count > 0)
-	{
-		if( (VSync(-1)-_cd_read_counter) > READ_TIMEOUT )
-		{
-			CdDoRetry();
-		}
-	}
-	
-	if( CdSync(0, result) != CdlComplete )
-	{
-		return -1;
-	}
-	
-	return 0;
-}
-
-uint32_t CdReadCallback(CdlCB func)
-{
-	unsigned int old_func;
-	
-	old_func = (unsigned int)_cd_read_cb;
-	
-	_cd_read_cb = func;
-	
-	return old_func;
-}
diff --git a/libpsn00b/psxcd/psxcd_asm.s b/libpsn00b/psxcd/psxcd_asm.s
deleted file mode 100644
index c0a5312..0000000
--- a/libpsn00b/psxcd/psxcd_asm.s
+++ /dev/null
@@ -1,487 +0,0 @@
-.set noreorder
-
-.include "hwregs_a.inc"
-
-.section .text
-
-.global _cd_init
-.type _cd_init, @function
-_cd_init:
-
-	addiu	$sp, -4
-	sw		$ra, 0($sp)
-	
-	jal		EnterCriticalSection
-	nop
-	
-	lui		$a3, IOBASE				# Acknowledge all CD IRQs
-	
-	li		$v0, 0x20943			# Set CD-ROM Delay/Size and common delay
-	sw		$v0, CD_DELAY_SIZE($a3)
-	li		$v0, 0x1325
-	sw		$v0, COM_DELAY_CFG($a3)
-	
-	li		$v0, 1
-	sb		$v0, CD_REG0($a3)
-	li		$v0, 0x1f
-	sb		$v0, CD_REG3($a3)
-	sb		$v0, CD_REG2($a3)		# Enable all IRQs
-	
-	sb		$0 , CD_REG0($a3)
-	sb		$0 , CD_REG3($a3)
-	
-	la		$a1, _cd_handler
-	jal		InterruptCallback
-	li		$a0, 2
-	
-	li		$v0, 2					# Set CD left volume
-	sb		$v0, CD_REG0($a3)
-	li		$v0, 0x80
-	sb		$v0, CD_REG2($a3)
-	
-	li		$v0, 3					# Set CD right volume
-	sb		$v0, CD_REG0($a3)
-	li		$v0, 0x80
-	sb		$v0, CD_REG1($a3)
-	
-	li		$v0, 0x20				# Apply volume
-	sb		$v0, CD_REG3($a3)
-	
-	# Clear a bunch of stats
-	la		$v0, _cd_ack_wait
-	sb		$0 , 0($v0)
-	la		$v0, _cd_complt_wait
-	sb		$0 , 0($v0)
-	la		$v0, _cd_last_cmd
-	sb		$0 , 0($v0)
-	la		$v0, _cd_last_mode
-	sb		$0 , 0($v0)
-	la		$v0, _cd_last_int
-	sb		$0 , 0($v0)
-	
-	la		$v0, _cd_result_ptr
-	sw		$0 , 0($v0)
-	
-	# Clear callback hooks
-	la		$v0, _cd_callback_int1_data
-	sw		$0 , 0($v0)
-	la		$v0, _cd_callback_int4
-	sw		$0 , 0($v0)
-	
-	la		$v0, _cd_read_cb
-	sw		$0 , 0($v0)
-	
-	lw		$v0, DMA_DPCR($a3)
-	li		$v1, 0xB000
-	or		$v0, $v1
-	sw		$v0, DMA_DPCR($a3)
-	
-	jal		ExitCriticalSection
-	nop
-	
-	lw		$ra, 0($sp)
-	addiu	$sp, 4
-	jr		$ra
-	nop
-	
-	
-.global _cd_wait
-.type _cd_wait, @function
-_cd_wait:
-	la		$v0, _cd_ack_wait
-	lbu		$v0, 0($v0)
-	nop
-	bnez	$v0, _cd_wait
-	nop
-.Lcomplete:
-	la		$v0, _cd_complt_wait
-	lbu		$v0, 0($v0)
-	nop
-	bnez	$v0, .Lcomplete
-	nop
-	jr		$ra
-	nop
-
-	
-.global _cd_wait_ack
-.type _cd_wait_ack, @function
-_cd_wait_ack:
-	la		$v0, _cd_ack_wait
-	lbu		$v0, 0($v0)
-	nop
-	bnez	$v0, _cd_wait_ack
-	nop
-	jr		$ra
-	nop
-	
-	
-.global _cd_wait_complt
-.type _cd_wait_complt, @function
-_cd_wait_complt:
-	la		$v0, _cd_complt_wait
-	lbu		$v0, 0($v0)
-	nop
-	bnez	$v0, _cd_wait_complt
-	nop
-	jr		$ra
-	nop
-	
-	
-.type _cd_handler, @function
-_cd_handler:
-
-	addiu	$sp, -4
-	sw		$ra, 0($sp)
-	
-	lui		$a3, IOBASE				# Get IRQ number
-	li		$v0, 1
-	sb		$v0, CD_REG0($a3)
-
-	lbu		$v0, CD_REG3($a3)
-	nop
-	andi	$v0, 0x7
-	
-	la		$v1, _cd_last_int		# Save last IRQ value
-	sb		$v0, 0($v1)
-	
-	bne		$v0, 0x1, .Lno_data
-	nop
-	
-	sb		$0 , CD_REG0($a3)
-	lbu		$v1, CD_REG0($a3)
-	sb		$0 , CD_REG3($a3)
-	lbu		$v1, CD_REG3($a3)
-	
-	sb		$0 , CD_REG0($a3)		# Load data FIFO on INT1
-	li		$v1, 0x80
-	sb		$v1, CD_REG3($a3)
-	
-.Lno_data:
-	
-	li		$v1, 1
-	sb		$v1, CD_REG0($a3)		# Clear CD interrupt and parameter FIFO
-	li		$v1, 0x5f
-	sb		$v1, CD_REG3($a3)
-	li		$v1, 0x40
-	sb		$v1, CD_REG3($a3)
-	
-	li		$v1, 0					# Delay when clearing parameter FIFO
-	sw		$v1, 0($0)
-	li		$v1, 1
-	sw		$v1, 0($0)
-	li		$v1, 2
-	sw		$v1, 0($0)
-	li		$v1, 3
-	sw		$v1, 0($0)
-	
-	la		$v1, _cd_last_int
-	lbu		$v0, 0($v1)
-	
-	beq		$v0, 0x1, .Lirq_1		# Data ready
-	nop
-	beq		$v0, 0x2, .Lirq_2		# Command finish
-	nop
-	beq		$v0, 0x3, .Lirq_3		# Acknowledge
-	nop
-	beq		$v0, 0x4, .Lirq_4		# Data/track end
-	nop
-	beq		$v0, 0x5, .Lirq_5		# Error
-	nop
-	
-	b		.Lirq_misc
-	nop
-	
-.Lirq_1:	# Data ready
-	
-	jal		_cd_fetch_result
-	nop
-	
-	la		$v0, _cd_callback_int1_data
-	lw		$v0, 0($v0)
-	nop
-	beqz	$v0, .Lirq_misc
-	nop
-	
-	la		$a0, _cd_last_int
-	lbu		$a0, 0($a0)
-	la		$a1, _cd_result_ptr
-	lw		$a1, 0($a1)
-	
-	jalr	$v0
-	addiu	$sp, -16
-	addiu	$sp, 16
-	
-	b		.Lirq_misc
-	nop
-	
-.Lirq_2:	# Command complete
-
-	jal		_cd_fetch_result
-	nop
-	
-	la		$v0, _cd_complt_wait
-	sb		$0 , 0($v0)
-	
-	la		$v0, _cd_sync_cb
-	lw		$v0, 0($v0)
-	nop
-	beqz	$v0, .Lirq_misc
-	nop
-	
-	la		$a0, _cd_last_int
-	lbu		$a0, 0($a0)
-	la		$a1, _cd_result_ptr
-	lw		$a1, 0($a1)
-	jalr	$v0
-	addiu	$sp, -16
-	addiu	$sp, 16
-	
-	b		.Lirq_misc
-	nop
-	
-.Lirq_3:	# Command acknowledge
-	
-	jal		_cd_fetch_result
-	nop
-	
-	la		$v0, _cd_ack_wait
-	sb		$0 , 0($v0)
-	
-	b		.Lirq_misc
-	nop
-	
-.Lirq_4:
-
-	jal		_cd_fetch_result
-	nop
-	
-	la		$v0, _cd_callback_int4
-	lw		$v0, 0($v0)
-	nop
-	beqz	$v0, .Lirq_misc
-	nop
-	
-	jalr	$v0
-	addiu	$sp, -16
-	addiu	$sp, 16
-	
-	b		.Lirq_misc
-	nop
-	
-.Lirq_5:	# Error
-	
-	jal		_cd_fetch_result
-	nop
-	
-	la		$v0, _cd_complt_wait
-	lbu		$v0, 0($v0)
-	nop
-	beqz	$v0, .Lno_complete
-	nop
-	
-	la		$v0, _cd_sync_cb
-	lw		$v0, 0($v0)
-	nop
-	beqz	$v0, .Lno_complete
-	nop
-	
-	li		$a0, 0x05				# CdlDiskError
-	la		$a1, _cd_result_ptr
-	lw		$a1, 0($a1)
-	jalr	$v0
-	addiu	$sp, -16
-	addiu	$sp, 16
-	
-.Lno_complete:
-
-	la		$v0, _cd_complt_wait
-	sb		$0 , 0($v0)
-	la		$v0, _cd_ack_wait
-	sb		$0 , 0($v0)
-	
-	la		$v0, _cd_callback_int1_data
-	lw		$v0, 0($v0)
-	nop
-	beqz	$v0, .Lirq_misc
-	nop
-	
-	li		$a0, 0x05				# CdlDiskError
-	la		$a1, _cd_result_ptr
-	lw		$a1, 0($a1)
-	
-	jalr	$v0
-	addiu	$sp, -16
-	addiu	$sp, 16
-	
-.Lirq_misc:
-	
-	lw		$ra, 0($sp)
-	addiu	$sp, 4
-	jr		$ra
-	nop
-	
-
-_cd_fetch_result:
-
-	lui		$a3, IOBASE
-	
-	la		$a0, _cd_status
-	lbu		$v0, CD_REG1($a3)
-	
-	la		$v1, _cd_last_int
-	lbu		$v1, 0($v1)
-	nop
-	beq		$v1, 0x2, .Lirq2_checks
-	nop
-	
-	# IRQ3 checks
-	
-	la		$v1, _cd_last_cmd
-	lbu		$v1, 0($v1)
-	nop
-	beq		$v1, 0x10, .Lskip_status
-	nop
-	beq		$v1, 0x11, .Lskip_status
-	nop
-
-	b		.Lwrite_status
-	nop
-	
-	# IRQ2 checks
-	
-.Lirq2_checks:
-
-	la		$v1, _cd_last_cmd
-	lbu		$v1, 0($v1)
-	nop
-	beq		$v1, 0x1D, .Lskip_status
-	nop
-
-.Lwrite_status:
-
-	sb		$v0, 0($a0)
-	
-.Lskip_status:
-
-	la		$a0, _cd_result_ptr
-	lw		$a0, 0($a0)
-	nop
-	beqz	$a0, .Lno_result
-	nop
-	sb		$v0, 0($a0)
-	addiu	$a0, 1
-	
-	move	$a1, $0
-.Lread_futher_result:
-
-	lbu		$v0, CD_REG0($a3)
-	nop
-	andi	$v0, 0x20
-	beqz	$v0, .Lno_result
-	addu	$a1, 1
-	bge		$a1, 7, .Lno_result			# timeout (locks up here on PSIO)
-	nop
-	lbu		$v0, CD_REG1($a3)
-	lbu		$v1, CD_REG0($a3)
-	sb		$v0, 0($a0)
-	
-	andi	$v1, 0x20					# when performing a CD-ROM read
-	bnez	$v1, .Lread_futher_result
-	addiu	$a0, 1
-
-.Lno_result:
-
-#	lbu		$v0, CD_REG0($a3)			# Flush response FIFO
-#	nop
-#	andi	$v0, 0x20
-#	bnez	$v0, .Lno_result
-#	lbu		$v0, CD_REG1($a3)
-
-	jr		$ra
-	nop
-	
-	
-.global CdAutoPauseCallback
-.type CdAutoPauseCallback, @function
-CdAutoPauseCallback:
-	
-	addiu	$sp, -8
-	sw		$ra, 0($sp)
-	sw		$a0, 4($sp)
-	
-	la		$v1, _cd_callback_int4
-	lw		$v0, 0($v1)
-	
-	la		$v1, _cd_callback_int4
-
-	lw		$a0, 4($sp)
-	nop
-	sw		$a0, 0($v1)
-
-	lw		$ra, 0($sp)
-	addiu	$sp, 8
-	jr		$ra
-	nop
-	
-	
-.global CdReadyCallback
-.type CdReadyCallback, @function
-CdReadyCallback:
-	
-	addiu	$sp, -12
-	sw		$ra, 0($sp)
-	sw		$a0, 4($sp)
-	
-	la		$v1, _cd_callback_int1_data
-	lw		$v0, 0($v1)
-	
-	la		$v1, _cd_callback_int1_data
-	sw		$v0, 8($sp)
-
-	lw		$a0, 4($sp)
-	nop
-	sw		$a0, 0($v1)
-
-	lw		$ra, 0($sp)
-	lw		$v0, 8($sp)
-	jr		$ra
-	addiu	$sp, 12
-	
-	
-.global CdSyncCallback
-.type CdSyncCallback, @function
-CdSyncCallback:
-	addiu	$sp, -12
-	sw		$ra, 0($sp)
-	sw		$a0, 4($sp)
-	
-	la		$v1, _cd_sync_cb
-	lw		$v0, 0($v1)
-	
-	la		$v1, _cd_sync_cb
-	sw		$v0, 8($sp)
-
-	lw		$a0, 4($sp)
-	nop
-	sw		$a0, 0($v1)
-
-	lw		$ra, 0($sp)
-	lw		$v0, 8($sp)
-	jr		$ra
-	addiu	$sp, 12
-	
-
-.section .data
-
-.comm	_cd_last_cmd, 1, 1
-.comm	_cd_last_mode, 1, 1
-.comm	_cd_ack_wait, 1, 1
-.comm	_cd_complt_wait, 1, 1
-
-.comm	_cd_status, 1, 1
-.comm	_cd_last_int, 1, 1
-
-# Callback hooks
-.comm	_cd_callback_int1_data, 4, 4		# Data IRQ callback
-.comm	_cd_callback_int4, 4, 4				# Autopause callback
-.comm	_cd_sync_cb, 4, 4
diff --git a/libpsn00b/psxcd/readme.txt b/libpsn00b/psxcd/readme.txt
index 64643ed..dcb40b6 100644
--- a/libpsn00b/psxcd/readme.txt
+++ b/libpsn00b/psxcd/readme.txt
@@ -1,45 +1,39 @@
 PSX CD-ROM library, part of PSn00bSDK
-2020 Lameguy64 / Meido-Tek Productions
+2020-2022 Lameguy64 / Meido-Tek Productions
 
 Licensed under Mozilla Public License
 
-	Open source implementation of the long awaited CD-ROM library that
-provides greater functionality than the BIOS CD-ROM subsystem. Supports
-pretty much all features of the CD-ROM hardware such as CD data read,
-CD Audio and XA audio playback. Data streaming should also be possible
-with the use of CdlReadN/CdlReadS commands and CdReadyCallback().
+Open source implementation of the long awaited CD-ROM library that provides
+greater functionality than the BIOS CD-ROM subsystem. Supports pretty much all
+features of the CD-ROM hardware such as CD data read, CD Audio and XA audio
+playback, with the exception of the St*() APIs for .STR playback (but manual
+streaming using CdReadyCallback() is still supported).
 
-	Library also includes an ISO9660 file system parser for locating
-files within the CD-ROM file system. Unlike the file system parser in
-the official libraries libpsxcd can parse directories containing any
-number of files. Rock-ridge and Joliet extensions are not supported
-however.
-
-	Be aware that the CD-ROM library might have some loose ends as it
-is still a work in progress, but should work flawlessly in most use
-cases.
+An ISO9660 file system driver for locating files within the CD-ROM is also
+included. Unlike the ISO9660 parser in the official libraries, libpsxcd can
+parse directories containing any number of files. Currently no ISO9660
+extensions are supported.
 
+Be aware that the CD-ROM library might have some loose ends as it is still a
+work in progress, but should work flawlessly in most use cases.
 
 Library developer(s):
 
-	Lameguy64
-
+	Lameguy64 (ISO9660 driver, initial implementation of low-level functions)
+	spicyjpeg (C rewrite)
 
 Library header(s):
 
 	psxcd.h
 
-
 Todo list:
 
 	* Command query mechanism so that more than 2 CD-ROM commands can
 	  easily be issued in callbacks. Official library probably does this.
-	
+
 	* Helper functions for handling disc changes (CdDiskReady and
 	  CdGetDiskType) are not yet implemented.
-	
-	* CdReadBreak() not yet implemented.
-	
+
 	* Data streaming functions (prefixed with St*) not yet implemented.
 	  Would require devising a PSn00bSDK equivalent of the STR file
-	  format.
\ No newline at end of file
+	  format.
diff --git a/libpsn00b/psxetc/interrupts.c b/libpsn00b/psxetc/interrupts.c
index 2dacaed..f05b089 100644
--- a/libpsn00b/psxetc/interrupts.c
+++ b/libpsn00b/psxetc/interrupts.c
@@ -173,6 +173,7 @@ int ResetCallback(void) {
 	for (int i = 0; i < NUM_DMA_CHANNELS; i++)
 		_dma_handlers[i] = (void *) 0;
 
+	COM_DELAY_CFG = 0x00001325;
 	_96_remove();
 	RestartCallback();
 	return 0;
diff --git a/libpsn00b/psxspu/common.c b/libpsn00b/psxspu/common.c
index a340af6..5dae473 100644
--- a/libpsn00b/psxspu/common.c
+++ b/libpsn00b/psxspu/common.c
@@ -44,6 +44,11 @@ static size_t _dma_transfer(uint32_t *data, size_t length, int write) {
 		length += DMA_CHUNK_LENGTH - 1;
 	}
 
+	// Increase bus delay for DMA reads
+	SPU_DELAY_SIZE &= 0xf0ffffff;
+	if (!write)
+		SPU_DELAY_SIZE = 2 << 24;
+
 	SPU_CTRL &= 0xffcf; // Disable DMA request
 	_wait_status(0x0030, 0x0000);
 
@@ -102,6 +107,8 @@ static size_t _manual_write(const uint16_t *data, size_t length) {
 /* Public API */
 
 void SpuInit(void) {
+	SPU_DELAY_SIZE = 0x200931e1;
+
 	SPU_CTRL = 0x0000; // SPU disabled
 	_wait_status(0x001f, 0x0000);