Audio Interface

The Audio Interface (or AI) is one of multiple I/O interfaces in the RCP, which is used to playback audio samples. It is a very simple audio processor: it fetches samples via DMA from RDRAM at a specified rate, and then outputs them. It performs absolutely no conversion on the samples: any audio processing functionality (decompression, mixing, etc.) must be performed by either the CPU or the RSP.

Memory mapped registers are used to configure the AI and initiate DMA transfers. The base address for these registers is, also known as AI_BASE. However, because all memory accesses in the CPU are made using virtual addresses, the following addresses must be offset appropriately. For non-cached reads/writes, add  to the address. As an example, to directly write to the AI_LENGTH register, use address.

DMA
AI allows to playback samples via a DMA channel. The CPU prepares a buffer of samples in RDRAM, then writes the AI registers to setup a DMA transfer specifying the buffer address and the length. The AI starts playing back those samples in background. Like the RSP and the RDP DMAs, also the AI DMAs has a double-buffering mechanism, so it is possible to enqueue a second buffer while the first one is playing back. This allows for continuous playback: as soon as a buffer is finished, a second is hopefully ready for playback so that the audio is uninterrupted.

The AI does not have an internal RAM holding samples: the DMA is directly connected to the DAC. This means that the DMA will progress as samples are physically put through the DAC, and the configured playback rate.

Connected to the DMA channel, there is a IRQ triggered via MI. Contrary to the usual working of DMAs, the AI IRQ is triggered when a DMA transfer starts, not when it ends. This can be intuitively explained: the AI wants to notify the CPU to prepare and enqueue a new buffer while a buffer is currently playing, so that the hopefully the new one will be ready by the time the current one finishes, to allow uninterrupted playback. If the AI generated the interrupt at the end of the buffer, that would be too late to enqueue a new one without audio crackings, which in turns means that the CPU wouldn't be able to rely on the IRQ for audio pacing.

AI only supports stereo samples. Sample bitsize is configurable.

Delayed-carry hardware bug
The AI DMA has a hardware bug that triggers whenever the last sample of a DMA transfer ends exactly at the boundary of a 8KiB (0x2000) page. When this happens, AI will add 0x2000 to the address of the next buffer that will be played back, effectively playing back samples from a different address than that programmed by the CPU.

The most likely explanation for this hardware bug is a delayed carry: maybe the AI has some internal address register split in two halves, with the lower half being 13 bits. When the lower-half register overflows (producing a carry), the carry is meant to be added to the higher-half register, but it might be that this happens 1 cycle later: if the DMA transfer ends exactly at that moment, the carry is added to the higher half at the beginning of the next transfer itself.

Libdragon has a workaround for this bug.

= Registers = Table Notation: R = Readable bit W = Writable bit U = Undefined/Unused bit -n = Default value n at power on [x:y] = Specifies bits x to y, inclusively

0x0450 0000 - AI_DRAM_ADDR

 * U-0 || U-0 || U-0 || U-0 || U-0 || U-0 || U-0 || U-0


 * W-0 || W-0 || W-0 || W-0 || W-0 || W-0 || W-0 || W-0
 * colspan="8" | DRAM_ADDR[23:16]
 * colspan="8" | DRAM_ADDR[23:16]


 * W-0 || W-0 || W-0 || W-0 || W-0 || W-0 || W-0 || W-0
 * colspan="8" | DRAM_ADDR[15:8]
 * colspan="8" | DRAM_ADDR[15:8]


 * W-0 || W-0 || W-0 || W-0 || W-0 || W-0 || W-0 || W-0
 * colspan="5" | DRAM_ADDR[7:3] || 0 || 0 || 0
 * colspan="5" | DRAM_ADDR[7:3] || 0 || 0 || 0

Extra Details:
 * Read access
 * The register is write-only. Reading it returns a mirror of AI_LENGTH.

0x0450 0004 - AI_LENGTH

 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || RW-? || RW-?
 * — || — || — || — || — || — || colspan="2"|LENGTH[16]
 * — || — || — || — || — || — || colspan="2"|LENGTH[16]


 * RW-? || RW-? || RW-? || RW-? || RW-? || RW-? || RW-? || RW-?
 * colspan="8" | LENGTH[15:8]
 * colspan="8" | LENGTH[15:8]


 * RW-? || RW-? || RW-? || RW-? || RW-? || R-? || R-? || R-?
 * colspan="5" | LENGTH[7:3] || 0 || 0 || 0
 * colspan="5" | LENGTH[7:3] || 0 || 0 || 0

0x0450 0008 - AI_CONTROL

 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || W-?
 * — || — || — || — || — || — || — || DMA_ENABLE
 * — || — || — || — || — || — || — || DMA_ENABLE

Extra Details:
 * Read access
 * The register is write-only. Reading it returns a mirror of AI_LENGTH.

0x0450 000C - AI_STATUS

 * R-? || R-? || U-? || U-? || U-? || U-? || R-? || U-1
 * FULL || BUSY || — || — || — || — || ENABLED || 1
 * FULL || BUSY || — || — || — || — || ENABLED || 1


 * U-? || U-? || U-? || U-1 || U-? || U-? || U-? || U-?
 * — || — || — || 1 || — || — || — || —
 * — || — || — || 1 || — || — || — || —


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || R-?
 * — || — || — || — || — || — || — || FULL
 * — || — || — || — || — || — || — || FULL

This register is read-only. Writes to it acknowledge the AI interrupt.

0x0450 0010 - AI_DACRATE

 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || W-? || W-? || W-? || W-? || W-? || W-?
 * — || — || colspan="6" | DACRATE[13:8]
 * — || — || colspan="6" | DACRATE[13:8]


 * W-? || W-? || W-? || W-? || W-? || W-? || W-? || W-?
 * colspan="8" | DACRATE[7:0]
 * colspan="8" | DACRATE[7:0]

The register is write-only. Reading it returns a mirror of AI_LENGTH.

The sample rate is the Video clock, divided by one more than this number.

For example, a value of 1103 would result in a sample rate of 44136 Hz on an NTSC console.

====

0x0450 0014 - AI_BITRATE

 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || U-? || U-? || U-? || U-?


 * U-? || U-? || U-? || U-? || W-? || W-? || W-? || W-?
 * — || — || — || — || colspan="4" | BITRATE[3:0]
 * — || — || — || — || colspan="4" | BITRATE[3:0]

The register is write-only. Reading it returns a mirror of AI_LENGTH.

The bit clock rate is the Video clock, divided by one more than this number. A written value of 0 instad stops the clock.

The bit clock rate must at least 66 times faster than the DAC rate.

====