SPC700 Reference

System Overview

CPU

8-bit SPC700, runs at 1.024MHz, however, each instruction takes a minimum of 2 cycles

Memory

64KB (NOT 32KB), shared with everything.

Communication

4 8-bit I/O ports to transfer data to/from the SNES.

Sound

8x channels of ADPCM compressed sample goodness. The DSP also has special hardware for echo effects, white noise, and pitch modulation.

Timers

Two 8-bit 8KHz timers + one more 8-bit 64KHz timer, all have 4-bit count-up values.

SPC Memory Map and Registers

* Only if X bit is set in the undocumented register.

Pages 0/1 are known as the "Zero Pages". Accesses to zero page memory can be done with faster (and smaller) cpu instructions (one byte addresses). Which zero page to be operated on can be switched with a processor flag. Page 1 is mainly used for stack space.

Registers

Control Register

       7     6     5     4     3     2     1     0
    +-----+-----+-----+-----+-----+-----+-----+-----+
 F1 |  -  |  -  | PC32| PC10|  -  | ST2 | ST1 | ST0 | Control, Write only!
    +-----+-----+-----+-----+-----+-----+-----+-----+

PC32: "PORT CLEAR" Writing '1' here will reset input from ports 2 & 3. (reset to zero)
PC10: "PORT CLEAR" Writing '1' here will reset input from ports 0 & 1.
STx:  Writing '1' here will activate timer X, writing '0' disables the timer.

There will probably be some conflict if the snes writes data at the same time the SPC initiates a port clear function.

Some emulators don't emulate this, BSNES does though.

Writing to the control register will ALWAYS reset active timers. Control is not readable. Writing '1' to any of the timer bits will start / restart the timer, even if it's already active, writing '0' will stop the timer. Even when using bit operations, the other timers will still be affected.

Communication Ports

There are 8 bytes worth of buffered data passed around; one byte on the SPC side and one byte on the CPU side, for each of the 4 ports. Therefore, data can be written in both directions simultaneously. The SNES uses registers 2140 - 2143. The SPC uses registers F4 - F7.

SNES SIDE               SPC SIDE

(write)                    (write)
-----> $2140 ------------,    .-------- $F4 <-----
-----> $2141 ----------, |    | .------ $F5 <-----
-----> $2142 --------, | |    | | .---- $F6 <-----
-----> $2143 ------, | | |    | | | .-- $F7 <-----
                   | | | |    | | | |
<----- $2140 <-----|-|-|-|----' | | |
<----- $2141 <-----|-|-|-|------' | |
<----- $2142 <-----|-|-|-|--------' |
<----- $2143 <-----|-|-|-|----------'
 (read)            | | | |          (read)
                   | | | `------------> $F4 ------>
                   | | `--------------> $F5 ------>
                   | `----------------> $F6 ------>
                   `------------------> $F7 ------>

Hardware Quirk! When writing in 16-bit values to 2140 / 2141, a noise pulse (or some technical thingy) may write data to 2143 too! Always write to 2140 / 2141 with 8-bit writes if this is undesired.

Another Warning! When a read from a port conflicts with a write to the port from the opposing CPU, the data may be garbled. Always re-fetch values that may be affected by this conflict!

Here is a fraction of code that handles the above conflict:

;-------------------------------------------------------------------
comms_process:
;-------------------------------------------------------------------

    mov a, comms_v          ; COMMS_V is the last data written to port0
    cmp a, spc_port0        ; if the value in port0 is different, this means the SNES has sent new data.
    beq cp_exit             ; if its the same, then there are no messages.

; receive message
    mov a, spc_port1        ; PORT1 contains the message type
    mov comms_v, spc_port0  ; PORT0 should contain valid data now, since a few cycles have passed.
    cmp a, #20h             ; determine message type... etc...

    --PROCESS MESSAGE--

    mov spc_port0, comms_v  ; mimic the value of port0 to let the SPC know we're finished,
                            ; if the value is incorrect then the SNES will get caught in an infinite loop.

Here is an unstable example that may crash:

;-------------------------------------------------------------------
comms_process:
;-------------------------------------------------------------------

    mov a, spc_port0        ; check port0 for different data
    cmp a, comms_v          ; comms_v is last value
    beq cp_exit             ; if its the same, then there are no messages.

; receive message
    mov comms_v, a          ; save validation <- THE DATA MAY BE GARBLED!
    mov a, spc_port1

    --PROCESS MESSAGE--

    mov spc_port0, comms_v  ; mimic the value of port0 to let the blah blah blah. This
                            ; data might be incorrect! It may hang-up the SNES side.

DSP Access

The DSP is accessed through 2 registers. One register points to a DSP register index. The other allows reading from / writing to the DSP register specified.

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$F2   |  x  |  x  |  x  |  x  |  x  |  x  |  x  |  x  | DSP-Address, Read / Write
      +-----+-----+-----+-----+-----+-----+-----+-----+

x: Pointer to DSP register.

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$F3   |  x  |  x  |  x  |  x  |  x  |  x  |  x  |  x  | DSP-Data, Read / Write
      +-----+-----+-----+-----+-----+-----+-----+-----+

x: Data to be written / data being read.

To write a value to the DSP:

1. Write address of DSP register to F2.
2. Write desired value to F3.

And to read a value:

1. Write address of DSP register to F2.
2. Read the value from F3.

F2 / F3 can be written simultaneously with a 16-bit transfer:

; Setting DSP register $00 to $25
; and $01 to $30

    mov a, #$00
    mov y, #$25
    movw    $F2, ya
    inc a
    mov y, #$30
    movw    $F2, ya

; theres a few possibilities to write data to the DSP...
; spc has some mem->mem / mem->imm instructions too.
    inc $F2     ; set register $02 to $99
    mov $F3, #$99

Timers

The SPC contains 3 timers that can be used for general purpose. Timers 0,1 count up at 8KHz, Timer 2 has a higher precision of 64KHz.

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$FA+X |  t  |  t  |  t  |  t  |  t  |  t  |  t  |  t  | Timer-X, Write only!
      +-----+-----+-----+-----+-----+-----+-----+-----+

t: Timing value.

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$FD+X |  -  |  -  |  -  |  -  |  c  |  c  |  c  |  c  | Counter-X, Read only!
      +-----+-----+-----+-----+-----+-----+-----+-----+

c: Count-up value.

The timers consist of an 8-bit internal counter and a 4-bit up-counter. When the timer is off, the internal counter can be programmed through registers Timer-X registers. When the timer is activated by a '1' bit in the Control register, then the timer starts counting up (at 8KHz/64Khz) until it reaches the amount specified in Timer-X. When this happens the internal counter is reset and Counter-X is incremented. When you read Counter-X, the value in it will be reset to zero. Take care not to let the up-counter overflow! It's only 4-bits wide, and if it overflows the value will be lost.

Psuedo Code - Setting Timer 0 to tick at 15ms:

1. ...Make sure the timer is off.
2. Write 120 (0x78) to FA (15/(1000/8000) = 15*8 = 120)
3. Write '1' to the control register bit (F1)
4. Timer is started..
5. Read FD periodically to check if ticks have passed.

Real Code:

; An example to wait 15ms.

    mov timer0,  #$78           ; 15ms timing value
    mov control, #$01           ; this will destroy all other timers

    ; timer is started

wait_for_tick:
        mov a, counter0         ; read counter
        beq     wait_for_tick   ; loop if 0

    ; tick has passed, process data

CPU Register Set

The CPU has 6 registers in it: A, X, Y, SP, PC, PSW

All are 8-bit except for the PC (Program Counter), which points at a 16-bit program execution address.

The A (Accumulator) register is compatible with most CPU instructions.

The X/Y (Index) registers are mostly used for counters/memory addressing. For some instructions, the Y register can be paired with A ("YA") for 16-bit operations.

The SP (Stack Pointer) register points to an area of memory in Page1 (0100 - 01FF). Stack operations affect SP, the IPL ROM initializes SP to the top of Page1.

The PSW (Program Status Word) register contains various bits that effect operation of the CPU.

CPU Program Status Word

Flags stored in PSW Register

Negative Flag (N): The MSB of an operation's result is copied to the Negative flag.

Overflow Flag (V): I don't think I ever had to use this bit, It tells you if an overflow occured in the previous arithmetic operation.

Direct Page Flag (P): This bit controls the direct-page (dp) operations. The dp operations only have 1 address byte. If the P flag is cleared then the effective address will be 0000h+address. Otherwise it will be 0100h+address.

Half Carry Flag (H): The half-carry flag is used in arithmetic operations. It can be used to determine if the DAA/DAS instruction needs to be executed after a BCD addition/subtraction operation. It cannot be directly set by any instruction, however, it is cleared with CLRV.

Carry Flag (C): The carry flag is mainly used in arithmetic operations. It can be used to control program flow after addition/subtraction. Its also used by a few other functions, like shift commands. It can be directly set by instructions SETC and CLRC.

Break Flag (B): This flag is unused. The only instruction that touches it is BRK.

Interrupt Enable (I): Interrupts are not supported. This flag is unused.

Opcode Matrices (by jwdonal)

SPC700 Opcode Matrix by Type (Native Mnemonics)

SPC700 Opcode Matrix by Type (65816-Style Mnemonics)

SPC700 Opcode Matrix by Addressing Mode (Native Mnemonics)

SPC700 Opcode Matrix by Addressing Mode (65816-Style Mnemonics)

SPC700 Opcode Matrix by Bits (Native Mnemonics)

SPC700 Opcode Matrix by Bits (65816-Style Mnemonics)

SPC700 Addressing Modes Effective Address Regions

Instruction Chart

CPU Instruction Set

Registers:
A   A register
X   X register
Y   Y register
PSW PSW register
YA  YA paired 16-bit register
PC  Program Counter
SP  Stack Pointer

Data types:
imm 8-bit immediate data
dp  8-bit direct page offset (direct page is either 0000h or 0100h depending on P flag)
abs 16-bit absolute address
rel 8-bit offset relative to PC
mem bit operation address, (13-bits)
bit bit location (3-bits)

Memory:
(addr)       8-bit memory value at addr
word:(addr)  16-bit memory value at addr
abs:(addr)   16-bit memory value at addr
I hope you get the point. :\

For opcode affected instructions:
    MSB
x   [ x | x | x | 0 |     opcode    ]

y   [ y | y | y | 1 |     opcode    ]

Flag settings:
Uppercase flag: Flag is set according to result of operation
Lowercase 'c' : Flag is complemented
       -      : Flag is not affected
       0      : Flag is reset
       1      : Flag is set

Operations:

<-  Transfer data (in direction)
->  Transfer data
+=  Add values and affect operand
+   Add values and do not affect operand
    Same for all arithmetic/logical operations
-   Subtraction
|   Logical OR
^   Exclusive Logical OR
&   Logical AND
>>  Shift right 1 bit
<<  Shift left 1 bit
++  Increment Data
--  Decrement Data
*   Multiplication
/   Division
%   Modulus (remainder)

8-bit Data Transmission (Read)

8-bit Data Transmission (Write)

8-bit Data Transmission (Reg->Reg, Mem->Mem)

8-bit Arithmetic

8-bit Logical Operations

8-bit Increment / Decrement Operations

8-bit Shift / Rotation Operations

16-bit Data Transmission Operations

16-bit Arithmetic Operations

Multiplication / Division Operations

Decimal Compensation Operations

Program Flow Operations

Subroutine Operations

Stack Operations

Bit Operations

PSW Operations

Other Commands

Special Notes

(X), (Y) are direct page addresses too! Assume addition of 100h if the P flag is set.

DIV only works if the resulting quotient is < 200h; the output registers contain garbage if the quotient exceeds this.

Bit Rate Reduction (BRR)

BRR is the compression format used by the DSP. It's a series of 9 byte blocks containing a header and 8 bytes of sample data. It looks like this:

BRR BLOCK
      8     7     6     5     4     3     2     1     0
   +-----+-----+-----+-----+-----+-----+-----+-----+-----+
   | E F | C D | A B | 8 9 | 6 7 | 4 5 | 2 3 | 0 1 | HEAD|
   +-----+-----+-----+-----+-----+-----+-----+-----+-----+
                                               ^
                                  the lower sample is in the high nibble

BRR HEAD
      7     6     5     4     3     2     1     0
   +-----+-----+-----+-----+-----+-----+-----+-----+
   |         RANGE         |   FILTER  |LOOP | END |
   +-----+-----+-----+-----+-----+-----+-----+-----+

RANGE: This is a shift value for the 4-bit data.

FILTER: This selects a filter for the decompression.

LOOP: This flag is set if the sample loops (commercial games set this for all blocks in looped samples).

END: When the decoder reads this bit, it will stop the sample (or restart from loop point) and set a bit in ENDX.

Example Decompression Routine:

NOTICE! This is only an approximation of the decompression routine performed by the DSP, look at some BRR compression source-code (like DMV47's) for an accurate example!

Sample Decompression Routine:
1. Read 4 bits from source data. (SAMPLE)
2. Shift the bits left by RANGE.
3. Get filter coefficients a & b from table below.
4. Add `LAST_SAMPLE1 * a` to SAMPLE.
5. Add `LAST_SAMPLE2 * b` to SAMPLE.
6. LAST_SAMPLE2 = LAST_SAMPLE1.
7. LAST_SAMPLE1 = SAMPLE.
8. Output SAMPLE.

Filter  Coef A   Coef B
  0     0        0
  1     0.9375   0
  2     1.90625  -0.9375
  3     1.796875 -0.8125

DSP

DSP Register Map

- prefix indicates that the register will be written to by the DSP during activity. For each voice (x=voice#):

DSP Voice Register: VOL

There are some undocumented quirks (emulated though) that I experienced when using these registers (while writing XMSNES). Sometimes the value I write gets ignored.. (or something), I'm not really sure what the exact problem is.

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x0   | sign|              Volume Left                |
      +-----+-----+-----+-----+-----+-----+-----+-----+

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x1   | sign|              Volume Right               |
      +-----+-----+-----+-----+-----+-----+-----+-----+

Volume, 8-bit signed value.

DSP Voice Register: P

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x2   |               Lower 8-bits of Pitch           |
      +-----+-----+-----+-----+-----+-----+-----+-----+

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x3   |  -  |  -  |   Higher 6-bits of Pitch          |
      +-----+-----+-----+-----+-----+-----+-----+-----+

Pitch is a 14-bit value.

The pitch can be calculated with this formula:

Let desired DSP pitch be P.

Pitch->Hz
               P
HZ = 32000 * ------
              2^12

(HZ = P * 7.8125)

Hz->Pitch
             HZ
P = 2^12 * -------
            32000

(P = HZ / 7.8125)

The highest pitch will reproduce the sound at approx. 2 octaves higher (~128KHz sample rate). The lowest pitch is basically not limited (but you will lose accuracy at lower pitches).

A few pitch->interval relations...

    400h     800h   1000h     2000h   3FFFh
-----|--------|-------|---------|-------|-----
   -2oct   -1oct   original   +1oct   +2oct
                    sound
                (best quality!)

DSP Voice Register: SRCN

Source number is a reference to the "Source Directory" (see DIR). The DSP will use the sample with this index from the directory. I'm not sure what happens when you change the SRCN when the channel is active, but it probably doesn't have any effect until KON is set.

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x4   |                 Source Number                 |
      +-----+-----+-----+-----+-----+-----+-----+-----+

DSP Voice Register: ADSR

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x5   |ENABL|        DR       |          AR           |
      +-----+-----+-----+-----+-----+-----+-----+-----+

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x6   |     SL          |          SR                 |
      +-----+-----+-----+-----+-----+-----+-----+-----+

The ENABL bit determines which envelope mode to use. If this bit is set then ADSR is used, otherwise GAIN is operative.

My knowledge about DSP stuff is a bit low. Some enlightenment on how the ADSR works would be greatly appreciated!

Table 2.2 ADSR Parameters

AR  TIME FROM 0->1    DR  TIME FROM 1->SL    SL  RATIO    SR  TIME FROM 0->1
00  4.1 sec           00  1.2 sec            00  1/8      00  Infinite
01  2.5 sec           01  740 msec           01  2/8      01   38 sec
02  1.5 sec           02  440 msec           02  3/8      02   28 sec
03  1.0 sec           03  290 msec           03  4/8      03   24 sec
04  640 msec          04  180 msec           04  5/8      04   19 sec
05  380 msec          05  110 msec           05  6/8      05   14 sec
06  260 msec          06   74 msec           06  7/8      06   12 sec
07  160 msec          07   37 msec           07  8/8      07  9.4 sec
08   96 msec                                              08  7.1 sec
09   64 msec                                              09  5.9 sec
0A   40 msec                                              0A  4.7 sec
0B   24 msec                                              0B  3.5 sec
0C   16 msec                                              0C  2.9 sec
0D   10 msec                                              0D  2.4 sec
0E    6 msec                                              0E  1.8 sec
0F    0 msec                                              0F  1.5 sec
                                                          10  1.2 sec
                                                          11  880 msec
                                                          12  740 msec
     |                                                    13  590 msec
     |                                                    14  440 msec
   1 |--------                                            15  370 msec
     |       /\                                           16  290 msec
     |      /| \                                          17  220 msec
     |     / |  \                                         18  180 msec
     |    /  |   \                                        19  150 msec
   SL|---/---|-----\__                                    1A  110 msec
     |  /    |    |   \___                                1B   92 msec
     | /     |    |       \_________________              1C   74 msec
     |/AR    | DR |           SR            \   t         1D   55 msec
     |-------------------------------------------         1E   37 msec
     0                                      |             1F   18 msec

     key on                                Key off
       (cool ascii picture taken from "APU MANUAL IN TEXT BY LEDI")

DSP Voice Register: GAIN

GAIN can be used to implement custom envelopes in your program. There are 5 modes GAIN uses.

DIRECT

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x7   |  0  |               PARAMETER                 |
      +-----+-----+-----+-----+-----+-----+-----+-----+

INCREASE (LINEAR)
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x7   |  1  |  1  |  0  |          PARAMETER          |
      +-----+-----+-----+-----+-----+-----+-----+-----+

INCREASE (BENT LINE)

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x7   |  1  |  1  |  1  |          PARAMETER          |
      +-----+-----+-----+-----+-----+-----+-----+-----+

DECREASE (LINEAR)

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x7   |  1  |  0  |  0  |          PARAMETER          |
      +-----+-----+-----+-----+-----+-----+-----+-----+

DECREASE (EXPONENTIAL)

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x7   |  1  |  0  |  1  |          PARAMETER          |
      +-----+-----+-----+-----+-----+-----+-----+-----+

Direct: The value of ENVX is set to PARAMETER.

Increase (Linear): ENVX slides to 1 with additions of 1/64.

Increase (Bent Line): ENVX slides up with additions of 1/64 until it reaches 3/4, then it slides up to 1 with additions of 1/256.

Decrease (Linear): ENVX slides down to 0 with subtractions of 1/64.

Decrease (Exponential): ENVX slides down exponentially by getting multiplied by 255/256.

Table 2.3 Gain Parameters (Increate 0 -> 1 / Decrease 1 -> 0):

DSP Voice Register: ENVX

ENVX gets written to by the DSP. It contains the present ADSR/GAIN envelope value.

ENVX
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x8   |  0  |                 VALUE                   |
      +-----+-----+-----+-----+-----+-----+-----+-----+

7-bit unsigned value

DSP Voice Register: OUTX

OUTX is written to by the DSP. It contains the present wave height multiplied by the ADSR/GAIN envelope value. It isn't multiplied by the voice volume though.

OUTX
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$x9   | sign|                 VALUE                   |
      +-----+-----+-----+-----+-----+-----+-----+-----+

8-bit signed value

DSP Register: MVOL/EVOL

Main/Echo volume! 8-bit signed values. Regular sound is scaled by the main volume. Echoed sound is scaled by the echo volume.

I also had a problem with writing to these registers, sometimes my writes would get ignored, or zeroed?

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$0C   | sign|         Left Output Main Volume         |
      +-----+-----+-----+-----+-----+-----+-----+-----+

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$1C   | sign|        Right Output Main Volume         |
      +-----+-----+-----+-----+-----+-----+-----+-----+

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$2C   | sign|         Left Output Echo Volume         |
      +-----+-----+-----+-----+-----+-----+-----+-----+

         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$3C   | sign|        Right Output Echo Volume         |
      +-----+-----+-----+-----+-----+-----+-----+-----+

DSP Registers: KON/KOF

Writing bits to KON will start/restart the voice specified. Writing bits to KOF will cause the voice to fade out. The fade is done with subtraction of 1/256 values and takes about 8msec.

It is said that you should not write to KON/KOF in succession, you have to wait a little while (a few NOPs).

Key-On
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$4C   |VOIC7|VOIC6|VOIC5|VOIC4|VOIC3|VOIC2|VOIC1|VOIC0|
      +-----+-----+-----+-----+-----+-----+-----+-----+
Key-Off
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$5C   |VOIC7|VOIC6|VOIC5|VOIC4|VOIC3|VOIC2|VOIC1|VOIC0|
      +-----+-----+-----+-----+-----+-----+-----+-----+

DSP Register: FLG

Flags
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$6C   |RESET|MUTE |~ECEN|         NOISE CLOCK         |
      +-----+-----+-----+-----+-----+-----+-----+-----+

RESET: Soft reset. Writing a '1' here will set all voices in a state of "Key-On suspension" (???). MUTE is also set. A soft-reset gets triggered upon power-on.

MUTE: Mutes all channel output.

ECEN: ~Echo enable. A '0' here enables echo data to be written into external memory (the memory your program/data is in!). Be careful when enabling it, it's quite easy to crash your program with the echo hardware!

NOISE CLOCK: Designates the frequency for the white noise.

DSP Register: ENDX

This register is written to during DSP activity.

Each voice gets 1 bit. If the bit is set then it means the BRR decoder has reached the last compressed block in the sample.

ENDX
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$7C   |VOIC7|VOIC6|VOIC5|VOIC4|VOIC3|VOIC2|VOIC1|VOIC0|
      +-----+-----+-----+-----+-----+-----+-----+-----+

DSP Register: EFB

Writing to this register sets the Echo Feedback. It's an 8-bit signed value. Some more information on how the feedback works would be nice.

EFB
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$0D   | sign|             Echo Feedback               |
      +-----+-----+-----+-----+-----+-----+-----+-----+

DSP Register: PMON

PMON
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$2D   |VOIC7|VOIC6|VOIC5|VOIC4|VOIC3|VOIC2|VOIC1|  -  |
      +-----+-----+-----+-----+-----+-----+-----+-----+

Pitch modulation multiplies the current pitch of the channel by OUTX of the previous channel. (P (modulated) = P[X] * (1 + OUTX[X-1])

So a sine wave in the previous channel would cause some vibrato on the modulated channel. Note that OUTX is before volume multiplication, so you can have a silent channel for modulating.

DSP Register: NON

Noise enable.

NON
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$3D   |VOIC7|VOIC6|VOIC5|VOIC4|VOIC3|VOIC2|VOIC1|VOIC0|
      +-----+-----+-----+-----+-----+-----+-----+-----+

When the noise enable bit is specified for a certain channel, white noise is issued instead of sample data. The frequency of the white noise is set in the FLG register. The white noise still requires a (dummy) sample to determine the length of sound (or unlimited sound if the sample loops).

DSP Register: EON

Echo enable.

EON
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$4D   |VOIC7|VOIC6|VOIC5|VOIC4|VOIC3|VOIC2|VOIC1|VOIC0|
      +-----+-----+-----+-----+-----+-----+-----+-----+

This register enables echo effects for the specified channel(s).

DSP Register: DIR

Source Directory Offset.

DIR
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$5D   |                  Offset value                 |
      +-----+-----+-----+-----+-----+-----+-----+-----+

This register points to the source(sample) directory in external RAM. The pointer is calculated by Offset*100h.

The source directory contains sample start and loop point offsets. Its a simple array of 16-bit values.

SAMPLE DIRECTORY

OFFSET  SIZE    DESC
dir+0   16-BIT  SAMPLE-0 START
dir+2   16-BIT  SAMPLE-0 LOOP START
dir+4   16-BIT  SAMPLE-1 START
dir+6   16-BIT  SAMPLE-1 LOOP START
dir+8   16-BIT  SAMPLE-2 START
...
This can continue for up to 256 samples. (SRCN can only reference 256 samples)

DSP Register: ESA

Echo data start address.

ESA
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$6D   |                  Offset value                 |
      +-----+-----+-----+-----+-----+-----+-----+-----+

This register points to an area of memory to be used by the echo buffer. Like DIR its value is multiplied by 100h.

DSP Register: EDL

Echo delay size.

EDL
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$7D   |  -  |  -  |  -  |  -  |      Echo Delay       |
      +-----+-----+-----+-----+-----+-----+-----+-----+

EDL specifies the delay between the main sound and the echoed sound. The delay is calculated as EDL * 16ms.

Increased amounts of delay require more memory. The amount of memory required is EDL * 2KBytes (MAX $7800 bytes). The memory region used will be [ESA*100h] -> [ESA*100h + EDL*800h -1]. If EDL is zero, 4 bytes of memory at [ESA*100h] -> [ESA*100h + 3] will still be used.

DSP Register: COEF

Echo FIR filter coefficients.

COEF
         7     6     5     4     3     2     1     0
      +-----+-----+-----+-----+-----+-----+-----+-----+
$xF   | sign|         Filter Coefficient X            |
      +-----+-----+-----+-----+-----+-----+-----+-----+

The 8-bytes at $0F,$1F,$2F,$3F,$4F,$5F,$6F,$7F are used by the 8-tap FIR filter. I really have no idea how FIR filters work... but the filter is applied to the echo output.

DSP Echo Function

Ah, the spotlight of SPC music, the echoing! A short review of the registers used:

EVOL: This is the volume multiplier of the echo output. Note that even if the Main volume is 0, the echo volume can still be heard. It is independent from the main volume.

FLG: Flags register. The "Echo Enable" bit is contained in here.

EFB: Echo Feedback. This is an 8-bit signed value used for feedback multiplication.

EON: Echo Channel Enable. One bit per channel to indicate that it should be echoed.

ESA: Echo Start Address. A pointer to the area of memory designated for the echoing buffer.

EDL: Echo Delay. 4-bit value that designates both the delay time for the echo, and the size of the echoing buffer. (d16ms time) (d2KB memory)

COEF: Echo FIR Filter Coefficients. Again, I have no idea how the filter works. A setting of 127,0,0,0,0,0,0,0 will result in the original sound.

To enable echoing:

Initialization, order of operation is not of concern
*. Set ESA to memory region to be used.
*. Set EDL to desired echo delay. You will require 2KB*EDL of space for the echoing buffer.
*. Set the filter coefficients. A setting of 127,0,0,0,0,0,0,0 won't affect the sound output.
*. Set Echo Feedback.
*. Enable echo for desired channels (EON).

Startup:
1. Delay 240ms ***see below***.
2. Set EVOL to desired volume.
3. Write '0' to the ECEN bit in the FLG register.
4. Echo is enabled.
5. Freely change all parameters (except ESA,EDL).

*** This is because the echo hardware doesn't actually read the buffer designation values until it reaches the END of the old buffer! (the old buffer sizes could be uninitialized garbage). There is no way to determine the write position. 240ms is the max delay time, so it is the safe value to use. Another method is to read EDL (d) before you set it, and delay d*16ms.

Another special note: Echo writing DOES wrap around the memory edge, I had my program crash when the ESA was at the very end of memory (and I didn't delay properly). It wrote to the end... and then wrapped around to munch all my DP memory all the way to the program code.

PS: Lower your headphone volume when playing with the EFB register.

Precautions

Don't use an excessive sound data compression ratio. Samples with low sample rates may cause distortion. And they don't convert to BRR very well.

Take care that the mixed output doesn't exceed the maximum waveform limit. If the mixed waveform (all 8-channels together) overflows, some distortion noise will be produced.

Check for monaural output! This will mess up your cool 'surreal' effect when your setting one side of the channel volume to negative.

Sustain continuous sample flow. Sampled data that isn't continuous will cause 'clicking' sounds to appear. A very obvious example is when you disable a channel by cutting the volume. A quick fade-out should be used instead.

IPL ROM

The IPL ROM is a 64 byte image that is built into the SPC to handle data transfers from the SNES. This code is ran at power-on/reset. Here is the code for the IPL ROM:

; Commented SPC-700 IPL ROM
; by eKid

; Original disassembly from SID-SPC written by Alfatech/Triad

; This code assembles with TASM

;-------------------------------------------------------------------------------
; DEFINITIONS
;-------------------------------------------------------------------------------

WriteAdr    =$00    ; Write address during transfers
Port0       =$F4    ; I/O ports
Port1       =$F5
Port2       =$F6
Port3       =$F7

.ORG $FFC0
;-------------------------------------------------------------------------------
Start:
;-------------------------------------------------------------------------------

; set stack pointer to $EF
;   "why EF? page1 has 256 memory bytes!"
;   because the value in X is reused in the page0 clear (saves 2 bytes)
;   the higher 16 bytes of page0 contain hardware registers.

    mov x, #$EF
    mov sp, x

; clear zero-page memory

    mov a, #$00
clrpg0: mov (x), a
    dec x
    bne clrpg0

; indicate ready signal, write 0BBAAh to ports 0/1

    mov Port0, #$AA
    mov Port1, #$BB

; idle until the SNES sends the transfer signal to port0 ($CC)
; and then process data

wait1:  cmp $F4, #$CC
    bne wait1

    bra ProcessData

;-------------------------------------------------------------------------------
TransferData:
;-------------------------------------------------------------------------------

; wait until Port0 gets zero written to it

wait2:  mov y, Port0
    bne wait2

; this is the main transfer loop

transfer_bytes:
    cmp y, Port0    ; check for data
    bne check_end

    mov a, Port1    ; read byte of data
    mov Port0, y    ; reply to SNES (snes can write new data now)
    mov [WriteAdr]+Y, A ; write data to memory
    inc y       ; increment index
    bne transfer_bytes  ; loop

; index overflowed, increment high byte of WriteAdr
    inc WriteAdr+1

check_end:

; if y - port0 < 0 then the transfer is complete (SNES added 2 or more)

    bpl transfer_bytes

; confirm this! we may have checked with invalid data
; also, this is used when the "inc WriteAdr+1" path is taken
;         (when transferring to $8000 or higher)

    cmp y, Port0
    bpl transfer_bytes

; transfer is finished, process data again

;-------------------------------------------------------------------------------
ProcessData:
;-------------------------------------------------------------------------------

; read word from ports 2/3
; word may be data write address,
; or program entry point (depending on port0)

    movw    ya, Port2
    movw    WriteAdr, ya
    movw    ya, $F4
    mov Port0, a    ; reply to SNES with PT0 data
    mov a, y
    mov x, a

; if port1 wasn't zero, then start the transfer

    bne TransferData

; otherwise...
; jump to program entry point
; X is zero in this case, so this
; is an effective "movw pc, WriteAdr"
    jmp [WriteAdr+X]

;-------------------------------------------------------------------------------
ResetVector:
;-------------------------------------------------------------------------------
    di
    stop

; When program flow is passed to the user code, the Accumulator
; and X/Y index registers are zero, and the SP is initialized to $EF.
; Also, page0 memory is cleared. (EXCEPT for the word at $00)

.end

Uploading Software

Here is the upload protocol:

SPC SIDE     |   SNES SIDE
---------------------------------------------------
PORT0=0AAh  >>>                                    | Stage 1, "is the SPC ready to receive data??"
PORT1=0BBh  >>>  Confirm 0AABBh                    |
---------------------------------------------------
            <<<  PORT1 = NOT0                      | Stage 2, initialize transfer
            <<<  PORT2/3 = TRANSFER ADDRESS LO/HI  |
            <<<  PORT0 = 0CCh                      |
PORT0=PT0   >>>  (confirm this)                    | PT0 is data received in port0 on the SPC side
---------------------------------------------------| the SPC will mimic stuff you put in port0
                DATA TRANSFER START                |
---------------------------------------------------|
            <<<  PORT1 = FIRST BYTE OF DATA        | Stage 3, start transfer
            <<<  PORT0 = 00h                       |
PORT0=PT0   >>>  (confirm this)                    |
---------------------------------------------------
            <<<  PORT1 = DATA                      | Stage 4, transfer data
            <<<  PORT0 = LAST PORT0 DATA +1        |
PORT0=PT0   >>>  (confirm this)                    |
--------------------------------------------------------
Sending the next block...                               |
            <<<  PORT1 = NOT 0                          | Stage 5, next block
            <<<  PORT2/3 = TRANSFER ADDRESS             |
            <<<  PORT0 = PREVIOUS PORT0 DATA + 2 to 127 | NOTE: this value cannot be zero, add another 1 or so if it is
PORT0=PT0   >>>  (confirm this)                         |
                 jump to DATA TRANSFER START            |
------------------------------------------------------------
After the last block...                                     |  Stage 6, start program
            <<<  PORT1 = 0                                  |
            <<<  PORT2/3 = PROGRAM ENTRY POINT              |
            <<<  PORT0 = PREVIOUS PORT0 DATA + 2 to 127     |
PORT0=PT0   >>>  (confirm this)                             |
                 (assume the code is running successfully)  |
------------------------------------------------------------

Warning! If this routine is interrupted, the SPC may time-out! (or something) Your program will then get stuck in an infinite loop of waiting for the SPC reply. Inhibit interrupts during the transfer protocol.

Have a look at my booting procedure (does not support multiple blocks):

;--------------------------------------------
snakBoot:
;--------------------------------------------

; wait for ready signal

-   ldx REG_APUI00
    cpx #0BBAAh
    bne -

; start transfer:
; port1   = !0
; port2/3 = transfer address ( 0200h )
; port0   = 0CCh

    lda #1
    sta REG_APUI01
    inc a
    stz REG_APUI02
    sta REG_APUI03

    lda #0CCh
    sta REG_APUI00

; wait for SPC

-   cmp REG_APUI00
    bne -

; ready to transfer...

    lda.w   snakd_binary    ; read first byte
    xba
    lda #0
    ldx #1
    bra sb_start

; transfer bytes

sb_send:
    xba

    lda.w   snakd_binary,x  ; read byte
    inx
    xba
-   cmp REG_APUI00
    bne -

    ina         ; add 1 to counter

sb_start:
    rep #20h
    sta REG_APUI00  ; write to port1
    sep #20h

    cpx #snakd_size ; all bytes transferred?
    bcc sb_send     ; no, then send next byte

; all bytes transferred

-   cmp REG_APUI00  ; sync
    bne -

    ina         ; add 2 or so...
    ina

    stz REG_APUI01  ; port1=0
    ldx #0200h      ; write program entry point
    stx REG_APUI02
    sta REG_APUI00  ; write validation

-   cmp REG_APUI00  ; final sync
    bne -

; snakdriver is installed

    rtl

1. Wait for the word in ports0/1 to read BBAA
2. Write a nonzero value in port1 and the transfer address in ports 2/3.
3. Write 0CCh to port0.
4. Wait for the SPC to mimic the data it receives in port0 (0CCh in this case). The loader only uses port0 for replies.
5. Start a counter at 00h, write the first byte of data to port1, and write the counter to port0.
6. Wait for the SPC to reply with 00h (yes, it mimics).
7. Write the next data byte to port1, increment the counter, write the counter to port0.
8. Wait for the SPC to reply with the counter value.
9. Goto 7 if there are more bytes to be transferred.
10. Write 0 to port1, the program entry point to port2/3, and then finally... add 2 (or more) to the counter and write to port0.
11. (Optional) Wait for the SPC to mimic that last byte...

Based on SPCTECH by eKid (EFNet - #snesdev) and Anomie's docs.