MOST System On Chip: Final Product Data Sheet
MOST System On Chip: Final Product Data Sheet
DS8805FP5
Apr. 2003
®
MOST
Media Oriented Systems Transport
This table represents valid part numbers at the time of printing and may not represent parts that are cur-
rently available. For the latest list of valid ordering numbers for this product, please contact the nearest
sales office (as listed on back page).
Intellectual Property
© Copyright 2001-2003 Oasis SiliconSystems. The information within this document is Oasis SiliconSys-
tems intellectual property. Duplication of this document without the expressed written permission from
Oasis SiliconSystems is prohibited. The information in this document is considered "Restricted Access",
and must not be sent to third parties without written permission from Oasis SiliconSystems.
Trademarks
MOST is a registered trademark of Oasis SiliconSystems. All other trademarks used in this document are
proprietary of their respective owners.
Patents
There are a number of patents and patents pending on the MOST technology. The rights to these patents
are not granted without any specific Agreement between the users and the patent owners.
Each of these three networks, or data transfer methods, operates independently (not affecting the other two),
providing a robust, dependable, and deterministic system architecture. The OS8805 supports the Control
and Streaming portions of the MOST Network, by default. The OS8805 also supports Packet messages if
enabled, otherwise it will not acknoledge reception of asynchronous Packets.
Final Product Data Sheet © Copyright 2001-2003 Oasis SiliconSystems DS8805FP5
Restricted Access Page 15
Address
Handler
Net Network- MOST
Block Master Supervisor
Decentral
Shadow Layer II
Device
Registry 6: Presentation
(Layer 2)
Layer
memory
Applications Socket
Notification Service
MOST Command Interpreter
Stream
Services Transparent
Channel 5: Session
Allocation Layer
DSP1
NetServices Software
Service
Synchronous
MOST
Service
DSP0 MOST Channel Allocation 4: Transport
Supervisor
Application
Processor Service Service
Layer
Remote-Control
Message Service
Async. Data
(Layer 1)
ADCs
Transceiver Control
Basic Services
MOST
RX
TX
Converter Packet Logic
Management Low-Level 2: Data-Link
Network Layer
OS8104
Power
Supply
FOX
FOR
1: Physical
Physical Interface: Media and Connectors
POF POF Layer
GND
MOST Network
+12 V
Figure 1-1: MOST Hardware/Software System Overview
DS8805FP5
Restricted Access
OS8805 MOST System On Chip
As shown in Figure 1-2, the chip contains four main processors: the Host Controller, the MOST Processor,
and two DSPs. The Host Controller operates on the Control bus and communicates with the external Host
System. This Controller manages the peripherals on the Control Bus, loads programs into the DSP memo-
ries, and configures the MOST Processor and connection to the MOST Network. The data crossing the
Control bus is generally low-speed data such as configuration information and messages to or from the
MOST Network. The Controller interfaces to the external system through a Control Port. For external sys-
tems with intelligence, the Control Port (and the chip) can be configured as a serial device. For stand-alone
applications, the Control Port can be configured as a master, wherein the Controller manages the external
peripherals in a similar fashion as the peripherals on the Control bus.
The Host Controller generally operates out of on-chip Flash memory, but also supports operation from
external memory through the external memory port. If the Controller uses external memory, then DSP0 is
limited to the internal data memory. If the Controller runs out of internal Flash, DSP0 can use the external
memory port for data-memory expansion.
Host System
External
Control Bus Memory Port
2k
Data RAM 2k
control
64 Pointers DSP1 DSP0 Data RAM
Source
(Gazelle) (Gazelle) 64 Pointers
Converters 2k
Program RAM 2k
Program RAM
Routing Bus
MOST Processor
Source Ports
MOST
Transceiver
RX TX
MOST Network
Figure 1-2: OS8805 Block Diagram
Host System
Debug External
Port Control 128k
Port Memory Port
Flash
Control Program
Dual USART
Bus Memory
or GPIO
Host Controller 4k Data
Timer or (Cougar)
GPIO RAM
DSP0
DC ADC DSP0 I/O Bus
COM Port DSP0
(Gazelle)
Debug COM
GTR
DSP1
DSP1 I/O Bus
COM Port DSP1
Source Debug COM (Gazelle)
Converter
Control
MOST MOST
Clock COM Port Processor
Manager
DSP0 DSP1
(Gazelle) (Gazelle)
MOST MOST
Routing Port Routing Port
Source Converters
Routing Bus
MPX ADC MPX
Source Ports
FSY
Mic ADC MIC
SCK
AD2L
SR0 AD2R
Stereo AD1L
Port 0
SX0 Audio ADC AD1R
AD0L
AD0R
DA0
MOST Processor DAC0
SR1 DA0B
Port 1
SX1 DA1
DAC1
Cross-Point DA1B
Switch
DA2
(MRT) DAC2
DA2B
DA3
DAC3
DA3B
MOST
Transceiver
RX TX
MOST Network
Figure 1-4: MOST Processor Overview
ASP A1
Routing Bus
The Host Controller connects to the DSP’s program controller and has read/write access to the program
counter, the program control register, and Program memory. This feature allows downloading programs as
well as visibility of the DSP internal operation.
All the memories associated with the DSP processor are on-chip. The Program memory is 26 bits wide
and 2048 locations deep. The Data memory section is divided into left and right sides with each side hav-
ing a Pointer memory and a Vector memory. Each Pointer memory is 25 bits wide and both left and right
Pointer memories are 64 locations deep. Left Vector memory is 14 bits wide and 2048 locations deep.
Right Vector memory is 18 bits wide and 2048 locations deep.
The left and right Pointer memories store pointer values which consist of a 11-bit address, 6-bit update,
and 8-bit modulo field. The accumulator consists of the low accumulator (14 bits), the high accumulator
(18 bits), and the guard bits (4 bits).
Each DSP can control up to 8 GPIO pins that are multiplexed with the Asynchronous Source Ports. If the
Async. Source Ports are not used, the DSP (or the Host Controller) can utilize the pins as GPIO.
Host
Controller Clock Manager GPIO and I2C - SPI
DC ADC
(Cougar) and PLL Timer Control Port
Control Bus
Debug
Port COM COM
COM Port Port
Port
External
Memory
Controller DSP0 DSP1 Source Data MOST
DSP Bus (Gazelle) (Gazelle) Ports Converters Core
Routing Bus
Figure 2-1: Control Bus
2.1 Architecture
The Host Controller conforms to the Oasis SiliconSystems Cougar 16-bit architecture and is a general pur-
pose CISC architecture processor. The multiple-byte instructions and CISC architecture is optimized to
reduce Program memory requirement of control applications. A byte/word mode switch enables it to effi-
ciently process byte and word variables allowing optimal use of data memory. Special I/O instructions and
a maximum performance of 8.5 MIPS (2 cycles/instruction at 384Fs) enable it to properly process real-time
applications. For programming information on the Controller, see the Cougar User’s Manual. The OS8805
has 128k bytes of on-chip Flash Program memory and 4k bytes of on-chip Data memory.
The Cougar Host Controller instructions can be one to four bytes in length. The first byte consists of the
opcode, and indicates the addressing mode for the instruction. The following bytes provide an 8- to 16-bit
direct memory address or immediate data, or up to an 17-bit jump address. The Controller can access one
byte of Program memory every two clock cycles, and operates at a clock frequency of 384×Fs.
The addressing mode determines the number of bytes in the instruction. For a two-byte instruction, the
second byte contains 8-bit immediate data or an 8-bit address. For a three-byte instruction, the second and
third bytes together form 16-bit immediate data or a 16-bit address. Four-byte instructions are used in jump
and jump to subroutine instructions as absolute addresses that span the entire Program memory space.
When an instruction is executed, the first byte of the instruction (the opcode) is loaded into the Instruction
Register (IR). The lower three or four bits of the byte indicate the addressing mode to be used by the
instruction. When an extended jump is fetched, its fourth byte is written into the M2 register.
8 bits
Opcode
Instruction Mode
Four-bit Addressing Field
4 bits 4 bits
- OR -
Instruction Mode
Three-bit Addressing Field
5 bits 3 bits
Single-operand instructions use the 3-bit address field and dual-operand instructions use the 4-bit address
field. For more information, see Section 2, in the Cougar User’s Manual. Table 2-1 lists the instructions that
use the 3-bit addressing field. The Bit Move instruction also uses a 3-bit address field; however, it doesn’t
support Register addressing, only Data memory direct or indirect.
Opcode (bits 7:0) Instruction
1000 0yyy Increment
1000 1yyy Test
1001 0yyy Shift right
1001 1yyy Exchange
1010 0yyy Decrement
1011 0yyy Shift left
Table 2-1: Single-Operand Instructions
The Host Controller communicates with the DSPs and peripherals through the Control bus. Each proces-
sor and peripheral has registers mapped into the I/O space of the Controller. The processors and many of
the peripherals can interrupt the Controller when service is required.
The Controller’s Program memory contains programs that are downloaded into the Program RAM of the
DSPs. The external Program memory can be Flash, EPROM, or SRAM (generally used for emulators in a
debug environment).
RST
(from control register)
Latch
XME/PCS
MA16, PA15, MA[14:0]
Internal
Program Flash
Host
(128k x 8)
MUX
Controller
External Program MD[7:0] (Cougar)
ROM/RAM
(128k x 8)
BOOT
PMW
RFS1 MOST Processor High Frequency Select. When set, operates the MOST Processor at a
higher speed. RFS1 must be set when Packet Data is supported (bNC.APREN set).
RSTD Host Controller Reset Disable.
0 - The reset vector is loaded in the program counter when the RESET instruction is executed
or when RGEN.XME is changed. All Host Controller registers are reset just like all the
peripheral circuits/registers.
1 - The Host Controller is NOT reset when a RESET instruction is executed or when RGEN.XME
is changed. In addition all Host Controller internal registers are NOT reset: PC (program
counter) SPC, DSPC, SR IFL, IER, SP, SPCH, DSPCH, and PGMP. Peripheral regis-
ters/circuits are still reset.
XMQ External Program Memory interface Quiet. This bit, in combination with the RGEN.XME bit,
define how the external memory interface pins function:
External Memory Interface
RGEN.XME MMPC.XMQ
DSP0 Host Cont. Read Host Cont. Write
1 0 * Data memory † internal Flash ‡ internal Flash
1 1 none † internal Flash † external memory
0 x none † external memory † external memory
* DSP Data memory is only enabled when GCTL.EDMEN is set. Otherwise, the pins are EGPIO.
† Read or written a byte at a time, through ACCL (ACC[7:0]).
‡ Written a word at a time. ACCH to the lower address and ACCL to the higher address.
PCSC Controls the phase timing of the Host Controller clocks. Also affects the PCS pin timing when
the external memory interface is enabled for the Host Controller. When PCSC is clear, the PCS
high and low times are equivalent. When PCSC is set, the PCS low time is longer that the high
time. See the External Program Memory Interface tables in the Electrical Characteristics section for
more details.
Internal Flash memory can only be written (a word at a time) when RGEN.XME is set and MMPC.XMQ is clear
(DSP data memory selected for external memory port), and Flash protection for the particular memory
location is disabled.
When Programming internal Flash, data is written a word at a time; therefore, the LSB in
AR1 must be 0. ACCH is written to the lower byte of memory and ACCL is written to the
upper byte. This byte-order is opposite to words written into Data memory.
FCP[1:0] Flash Clock Prescaler. Determines the prescaler for the Flash programming time (delay
counter clock).
00 - Divide by 1.
01 - Divide by 2.
10 - Divide by 3.
11 - Divide by 4.
FPT[1:0] Flash Program Time. Programming Cycle time. The Flash programming time should be 20 µs
minimum. See Table 2-5 for programming time details.
00 - 384 cycles
01 - 272 cycles
10 - 156 cycles
11 - 116 cycles
FPT[1:0] (Fs = 44.1 kHz) FPT[1:0] (Fs = 48 kHz)
FCP[1:0]
384 272 156 116 384 272 156 116
1 22.6 16.0 9.2 6.8 20.8 14.6 8.5 6.3
2 45.3 32.1 18.4 13.7 41.7 29.5 16.9 12.6
3 68.0 48.2 27.6 20.5 62.5 44.3 25.4 18.9
4 90.7 64.2 36.8 27.4 83.3 59.0 33.9 25.2
Table 2-5: Flash Memory Programming Times (in µs)
PER Partition Erase. When clear, Flash Program memory is written. When set, the Flash memory
partition that is selected during a Program memory write instruction, (rom)*ar1 = acc;, is
erased (data used in write instruction is ignored). Flash protection for the particular location or
partition must be disabled in order to write to or erase internal Flash memory.
FPD Flash Powerdown. When clear, Flash memory is powered up and operating normally. When
set, the Flash memory is powered down and not accessible. Since this disables further instruc-
tions (halts Host Controller operation), it should only be set to minimize power when the Host
Controller is operating out of external Program memory.
The Flash programming time must be kept greater than or equal to 20 µs and less than or equal to 40 µs.
When the PLL is unlocked, the sample frequency can drift down to its minimum frequency. However, if the
PLL unlocks during a Program memory write, the duration of the write is short enough that the PLL fre-
quency will not drift too far from its nominal locked value. Therefore, software that writes to Program mem-
ory must check the state of the PLL and, if unlocked (CMCS.LOCK clear), software must either not initiate
any more Program memory writes, or shorten the programming time through the FMC.FPT[1:0] bits.
FB[15:0] Flash Block protection. When a bit is set, the 8K Flash memory block cannot be read using the
instruction acc = (rom)*ar1;or written/erased using (rom)*ar1 = acc;. The value read
back will be indeterminate. When FBn is clear, the Program read instruction reads a byte con-
stant from Program memory, and the Program write instruction either writes a word from ACC
or erases a partition (based on FMC.PER). The Flash Handler resides in FB1.
FBIB Info Block protection. When set, the Flash 256-byte Info Block cannot be read, written, or
erased. The value read back will be indeterminate. When FBIB is clear, the Program read
instruction reads a byte constant from the Info Block, and the Program write instruction either
writes a word from ACC or erases a partition.
Bits in FPBK and FPB16 are protected from arbitrary writes by only allowing certain bits to be updated from
certain Program memory locations. Therefore, an IO Write instruction from the following PC locations will
allow the listed bits to be updated. FB1 contains the Flash Handler and is always protected.
PC location for IO Write
Register bits that can be changed
Instruction
Block PC Address Register Bits
0x03862 FPBK FB[15:2]
FB2
0x03867 FPB16 FP[7:0]A, FP[7:0]B (all bits)
0x048DF FPBK FB[15:3]
FB3
0x048E4 FPB16 FP[5:0]A, FP[5:0]B
0x0996E FPBK FB[15:5]
FB5
0x09973 FPB16 FP[3:0]A, FP[3:0]B
Table 2-8: IO Write Locations for FPBK and FPB16 Bits
Program data is byte-wide, where an instruction is made up of one, two, three, or four program data bytes.
The first byte of the instruction always contains the op-code and indicates the addressing mode for the
instruction. For two-byte instructions, the second byte contains either immediate data or an 8-bit direct
address. For three-byte instructions, the second and third bytes contain either 16-bit immediate data or a
16-bit direct address. The only four-byte instructions are absolute jumps, either conditional or bit-set/clear,
that cover the entire Program memory space.
The interrupt controller handles eleven interrupt sources (IFL register bits), the Debug Port interrupt, and
reset (start-up). Interrupts divert program flow to an interrupt vector address. The return-from-interrupt
instruction returns execution back to the interrupted instruction, and execution continues as expected. The
hardware registers associate with the interrupt controller are the interrupt flag register IFL, interrupt enable
register IER, and the stack pointer SP.
The reset vector can be directed to two different locations, depending on the status of the BOOT pin. When
the BOOT pin is high, the master reset initializes the host program counter to 0x00008, which is used by
the Flash Handler. When the BOOT pin is low, the master reset initializes the host program counter to
0x00000 to start normal program execution. The Host Controller’s Vector table is illustrated in Figure 2-5.
The BOOT interrupt is used by the on-chip Flash Handler software which resides in the lowest 8k Flash
The Watchdog timer powers up enabled. Therefore, if its counter reaches the terminal
count, it will reset the chip. If it is not used, it must be explicitly disabled by setting
RGEN.WDD.
The Controller has 11 different interrupt sources generated from the two DSPs, the GPIO pins (configured
as interrupts), the timer, the DC measurement ADC, and the Control Port. All IFL interrupts use the same
interrupt vector location at Program memory address 0x00004. For interrupts to occur, the Global Interrupt
Enable status bit SR.GIE must be high (using the ENABLE instruction) and the appropriate bit in IER must be
set. The Interrupt Flag register IFL identifies the source of the interrupt. To clear an edge-sensitive inter-
rupt, a zero must be written to the respective bit that is set in the IFL register. Level-sensitive interrupt bits
in IFL are read-only and cannot be cleared through the IFL register. The Interrupt Enable register IER pro-
vides independent enables for each interrupt. Other than the Debug Port interrupt, which has the highest
priority, the other 11 interrupts have the same priority. The interrupt priority and servicing must be handled
through software. An interrupt can also be generated by writing a one to the corresponding bit in the inter-
rupt flag register IFL, if the interrupt is enabled.
If an edge-trigger interrupt condition occurs while SR.GIE is cleared, the interrupt remains pending until
SR.GIE is set. When SR.GIE is set high, a pending interrupt will then set the corresponding bit in IFL bit. The
IER bits can block a IFL bit from causing an interrupt; however, the IFL bit will still be set and can be polled,
if desired.
The IFL register should not be written when the SR.GIE bit is set; otherwise, an edge-sensitive interrupt
occurring during the I/O write instruction could be lost. The following code could lose an interrupt:
// assume SR.GIE set
acc = 0xFFFD;
ifl &= acc; // read-modify-write to IFL. Could lose an incoming interrupt
The following code will not miss an interrupt, since pending logic stores all incoming edge-sensitive inter-
rupts when SR.GIE is clear:
// assume SR.GIE set
disable; // clear SR.GIE, any incoming interrupts will now be pending
acc = 0xFFFD;
ifl &= acc; // IFL can be written without concern for losing interrupts
enable; // re-set SR.GIE, if any interrupts came in while it was clear, they
// will happen now.
When an interrupt occurs, SR.GIE is cleared by hardware, and the Program Counter (PC) value is written to
the Shadow Program Counter registers SPC/SPCH. SPC/SPCH must be stored on a software stack
before the interrupt service routine calls any subroutines. If SPC/SPCH is not saved, its contents will be
The Debug Port interrupt vectors to location 0x0000C. The Debug Port interrupt is enabled by setting the
IER.DIEN bit. The Debug Port interrupt can also be caused by one of the DSPs executing a TRAP instruction
(which is not masked by IER.DIEN). The TRAP instruction also causes the particular DSP to vector to the
Debug Interrupt vector.
When a debug interrupt occurs, the PC value is written to the Debug Shadow PC registers DSPC/DSPCH,
and the Debug Interrupt Vector is loaded into the PC. The Debug Interrupt does not affect SR.GIE and can-
not be interrupted. The RET instruction is used to exit the Debug Interrupt since it does not affect SR.GIE.
The first RET instruction inside the Debug ISR fetches the return address from DSPC/DSPCH; therefore,
special attention is needed when using subroutines from within the Debug ISR. If this issue is not
addressed, the first subroutine’s RET instruction will exit the entire Debug ISR instead of returning to the
calling routine. In addition, this first RET restores/unblocks SR.GIE, therefore, SR.GIE must be cleared before
the first RET, and restored before exiting the debug ISR.
2.1.5.2 Inherent
In Inherent mode, the instruction does not specify data or a data location. Instead, the opcode is explicitly
stated by the instruction, and performs a discrete task. All Inherent mode instructions are 1-byte instruc-
tions.
reti; // Returns from an interrupt handling state.
enable; // Set SR.GIE
carry = 0;
nop;
acc = 0xF234;
sw; // set word mode
*ar1 = acc; // Loads the variable pointed to by AR1 from ACC. The SR flags are
// updated based on the word result stored at *AR1. Since var =
// 0xF234, SR.N would be set, and SR.Z would be clear.
acc -= *ar1; // Subtracts variable pointed to by AR1 from ACC. The SR flags are
// updated based on the entire ACC result. Since ACC is zero in
// this example, SR.N would be clear, and SR.Z would be set.
A17 17th address bit of Program memory. When set, the 256-byte information block of the Flash
memory is selected. A16 must be clear when A17 is set.
A16 16th address bit of Program memory. Selects either the upper (when set) or lower 64k of Pro-
gram memory to read from or write to.
The data registers are one-way (read-only and write-only), that share a common address.
Since the data registers for each direction share the same I/O address, the value written
cannot be read. The value read is from the other device.
For example, data written by the Host Controller to a DSP can be read by the DSP, but NOT by the Host
Controller. When the Host Controller reads the register, the data read is the last data written by the DSP.
On the Control bus, each data register has two I/O addresses. The Host Controller signifies the first and
last word of a transfer by accessing one address. The Controller uses the other address to transfer all
other data.
The STR, RD, and WR flags are read-only. They support handshaking between the Controller and each
slave during data transfers. They are set when the Controller accesses the data register and are cleared
when the slave accesses the data register. A low-to-high transition of the STR, WR, or RD flags can generate
the COM port interrupt in the DSPs. A low-to-high transition of INT can generate the COM port interrupt in
the Host Controller. Since the status flags have to cross clock boundaries, a one-cycle delay is incurred
between when a status flag is changed, and when it becomes readable from the register. For example, if
the DSP writes data into the COM data register, a NOP instruction should precede reading the RD bit low
from the COM status register. Figure 2-6 is a block diagram of a generic COM port (although the DSP
Slave Processor register names are shown for clarity).
Control bus
Host Controller
Interrupt
address first/last address middle
address
COM Status
COM Data Register COM Data Register
Register
address (DCS)
address (DCD)
Slave Interrupt
Slave Processor bus
From the software’s perspective, the transfer of data through the COM ports is much like that of the Control
Port. The Host Controller operates as the master and the slave processor operates as the slave.
This will store the DSP’s DCD COM port register data at the address pointed to by map_ptr, and then
post-increment the MAP pointer map_ptr to be ready for the next transfer.
STR
WR
Data
MAP data1 data2
reg.
RD
Slave reads Slave writes data Slave reads COM Slave reads COM
data register register to clear STR data register and data register and
stores at (MAP) stores at (MAP+1)
The Controller begins reading a message from a slave by writing the read address (MAP) to the data reg-
ister that signifies the first/last data word. This sets the STR and WR flags in the status register. The DSP
should read the address from the data register (which clears the WR bit), get the data pointed to by the
MAP, and writes that data into the COM data register (which clears the STR bit).
STR
WR
Data
MAP data1 data2
reg.
RD
Slave reads Slave writes data stored at Slave writes COM data
data register MAP to COM Data reg. register with (MAP+1) data
The Controller can terminate a read transfer by reading from the first/last data register address. A read
from this address does not cause RD to go high. Figure 2-8 is a timing diagram illustrating a read transfer.
For a DSP, the Controller’s read transfers can be supported by copying the MAP data to a DSP pointer
variable map_ptr, and using the following command when a byte is received:
dcd = *map_ptr, map_ptr++;
This will store the data, pointed to by map_ptr, into the DSP’s DCD COM Port register, and then post-
increment the MAP pointer map_ptr to be ready for the next transfer.
The DSP can set the INT flag to inform the Controller that it requires servicing. This flag is read/writable by
both the DSP and the Controller. Once the Controller services the slave, it should clear the INT flag.
The MAP value is 8 bits, which spans 256 bytes of the MOST Processor register space. The MOST Pro-
cessor register space spans 1024 bytes, or four pages of 256 bytes each. The last byte in each page is
reserved for switching pages. Therefore, if the Host Controller writes the MAP to FFh (RCF = FFh), and
then writes RCM to 0, 1, or 3 (page 2 is reserved); then the MOST Processor switches to the respective
memory page. When the MAP is auto-incrementing and reaches the end of a page, it wraps to the begin-
ning of the same page.
Control/Status
Control Bus
33h
DRM CK
CMCS
RM CK
RD[2:0]
MX1 M X0
SR0 Dividers
11
RX
10
SCK PLL Processor Clocks
01
XTO
00
XTI CM CS.MX[1:0] = 00
FLT
LOCK PLL Locked. When set, indicates that the PLL is properly locked onto the source. LOCK will go
low immediately when the source stops toggling. LOCK will also go low if an out-of-lock condi-
tion is detected on the source.
When out of lock, the Control Port still operates; however, Source data is not transferred.
Once lock is reestablished, three frames are required for Source data to be transferred prop-
erly.
ASC Automatic Switch. When set and the PLL source is not the crystal, causes the MX[1:0] bits to
change to the crystal (00) when the PLL loses lock (LOCK = 0). When MX[1:0] are changed to
00, the crystal starts to oscillate. The crystal start-up time can be quite long and will cause the
PLL to drop in frequency until the oscillator stabilizes.
PLD PLL Disable. When set, the PLL is pulled to its nominal low frequency.
XTL[1:0] Crystal oscillator divider. These bits allow the crystal oscillator to be one of three frequencies
for a given network sample frequency (Fs).
00 - 512×Fs
01 - 384×Fs
10 - 256×Fs
11 - Reserved
MX[1:0] PLL Multiplexer input select. Selects the source to the PLL. When using NetServices software,
a crystal is required even in timing-slave nodes since the node can be set as a timing-master
for diagnostics if the ring goes down.
00 – Crystal oscillator. If not selected, the oscillator is automatically disabled to save power.
01 – SCK (Source Port serial bit clock)
10 – RX (network receiver – timing-slave device)
11 – SR0 (SPDIF Source Port input)
Power can be minimized during normal operation by turning off the chip resources that are not being used.
The DSP processor has a run bit which, when cleared, turns off the DSP processor’s clock. This reduces
the power consumption of the processor to the DC power of the memories. Each data converter has an
enable bit. When not enabled, the converter is in a low-power state.
OR
MUX
MUX
< 10 pF
C1 = C2 = 18 - 22 pF to PLL to PLL
XTO XTO
C1
20 kΩ 300 Ω
2 MΩ
2 MΩ
CMOS output
XTAL
XTI 3.3 mA/V XTI 3.3 mA/V
C2
The crystal frequency can be 256xFs, 384xFs, or 512xFs; selected via the CMCS.XTL[1:0] bits. The load
capacitors should typically be in the range of 18 pF to 22 pF. For more information on crystals, see
Section 8.4.
CMCS.XTL[1:0] 10 01 00
Units
Fs 256x 384x 512x
38 kHz 9.728 14.592 19.456 MHz
44.1kHz 11.2896 16.9344 22.5792 MHz
48 kHz 12.288 18.432 24.576 MHz
Table 2-33: Crystal Oscillator Frequencies
16Fs
SCK ÷ 8Fs
4Fs
2Fs
Fs
8-bit
counter 0.5Fs
0.25Fs
0.125Fs
0.0625Fs
MSB LSB
MOST Processor
Control Bus
FS8
FS4
FS2
FS1
FSHALF
FS4TH
FS8TH
FS16TH
USART0
Control U0C
AD1/CS/IOA3/UFR0 Logic 52h
AD0/SDIN/URX0 1
SDA/SDOUT/UTX0
SCL/SCLK/UCK0 0
shift register Control
Logic shift register shift register
CPFD
CPFD Control Port Format Disable. When clear, the Control Port formats listed in this section are
enabled. If set, the Control Port formats are disabled and the Control Port can be configured
for USART0 (U0C.USEN set) or the four pins can be used as EGPIO port IOA[3:0] (U0C.USEN
clear)
FAST Fast mode enable. When the Control Port is a master (CPMM set), FAST determines the clock-
ing serial port clocking frequency as shown below:
With FAST clear the approximate clocking frequency is 88.2 kHz when Fs = 44.1 kHz, and
96 kHz when Fs = 48 kHz.
With FAST set, the approximate clocking frequency is 295.8 kHz when Fs = 44.1 kHz, and
310.6 kHz when Fs = 48 kHz.
NACK No Acknowledge. Reading this bit does not read what was written. The read bit going high can
generate an interrupt, if enabled. Writing NACK to zero clears the interrupt condition.
When the Control Port is configured as a slave port (CPMM clear):
NACK is set when the external master device is performing a read operation and does not
acknowledge the transfer. Software can write this bit to zero after reading CP. When con-
figured as a slave port, software should never write NACK to one.
When the Control Port is configured as a master port (CPMM set):
NACK is set when writing an external device and it does not acknowledge the transfer. In
I2C format, software should set NACK to one to keep the Control Port from acknowledging
the next (last) transfer. Once the “no acknowledge” is transmitted, NACK will read back
one and must be cleared in software. The data in CP must be read before clearing NACK
or another eight clocks will be sent out. In GSPI format, NACK should be set for full-duplex
communications, since it will keep CP reads from generating 8 clocks (only writes will
generate 8 clocks). When using GSPI in one direction, NACK is used to stop the last trans-
fer from generating clocks.
I2CF SPI or I2C format. When set, the Control Port uses the I2C format. When clear, the Control
Port uses the SPI format indicated by the GSPI bit. I2CF is initially set by the value of the
SCL/SCLK pin when RST is de-asserted or at initial power-up.
GSPI Generic SPI. When set, and I2CF is clear, the Control Port interface uses a generic SPI format
(GSPI). When GSPI is clear (Oasis-specific SPI, OSPI), the data format matches the I2C format
and the WR and RD bits work as in I2C format. The Control Port must be a slave in OSPI mode.
CPOL Clock Polarity, in generic SPI format only. When GSPI is set and I2CF is clear, this bit deter-
mines the SCLK clock polarity as indicated in Figure 2-24.
CPHA Clock Phase, in generic SPI format only. When GSPI is set and I2CF is clear, this bit determines
the SCLK clock phase as indicated in Figure 2-24. When in slave mode and CPHA is clear, CS
must be brought high between each data byte transferred.
STR Start. Reading indicates if a start condition has been detected on the bus. In master mode,
writing to 0 clears the bit and writing to 1 causes a Start condition to be transmitted. If a STR
condition is detected on the bus, an interrupt can be generated in I2C and GSPI-slave formats.
When the Control Port is configured as a slave port (CPMM clear):
In I2C format, STR is set when an I2C Start bit is detected on the bus followed by an
address matching 01000xy, where xy is set via the AD1 and AD0 pins, respectively. In
both SPI formats, STR going high indicates that the CS pin fell. STR is cleared by writing to
the CP register (STR is read-only and cannot be cleared by writing to 0). Writing STR to 1
has no effect.
When the Control Port is configured as a master port (CPMM set):
In I2C format, STR is set only after an I2C Start bit is detected on the bus. In GSPI format,
2
STR is always low. STR is cleared by writing STR to zero. In I C format, writing STR to one
causes a Start bit to be transmitted onto the bus. Once the bit is transmitted, STR will be
read as one, indicating a Start condition was seen on the bus.
WR Write data bit. When the Control Port is not in generic SPI mode (GSPI clear):
When in slave mode, WR is set when data is transferred from the serial input shift register to
the CP register; and WR is cleared when the Controller reads the CP register or explicitly
writes WR to 0. Writing WR to 1 has no effect.
RD Read data bit. When the Control Port is not in generic SPI mode (GSPI clear):
When in slave mode, RD is set when data is transferred from the CP register to the shift regis-
ter, to be shifted out of the chip; and RD is cleared when the Controller writes the CP reg-
ister or explicitly writes RD to 0. Writing RD to 1 has no effect.
When in master mode, RD is set when data is transferred from the shift register to the CP reg-
ister, and RD is cleared when the Controller reads CP or explicitly writes RD to 0.
D[7:0] Control Port bi-directional data register when the Control Port is enabled and in any format
except USART0.
When the Control Port is configured as a slave port (CPS.CPMM clear):
Reading or writing the CP register after CPS.WR or CPS.RD is set, clears the particular sta-
tus bit, clearing the interrupt condition.
When the Control Port is configured as a master port (CPS.CPMM set):
Writing the CP register causes 8 clocks to be transmitted in GSPI and 9 clocks in I2C.
Reading the CP register also causes 8 clocks to be transmitted in GSPI and 9 clocks in
I2C format. However in I2C format, CPS.NACK should be written immediately after reading
the second to last transfer from CP. This will cause the part to not-acknowledge the last
transfer. Once the last byte is in CP, it must be read BEFORE clearing CPS.NACK (or
another 9 clocks will be transmitted). For GSPI format, if CPS.NACK is set before reading
the last word in CP, no more clocks will be generated. Then CP should be read, followed
by clearing CPS.NACK.
The following slave protocol is recommended for data transfers in the I2C and Oasis-specific SPI (OSPI)
formats, as the Control Port hardware is optimized to support this protocol. A generic SPI format is also
provided to allow custom data formats.
When the part is a Control Port slave device (CPS.CPMM clear), the first data word written by the external
system (after the chip address byte) is a Memory Address Pointer (MAP), which determines where the
second data byte is to be stored/retrieved. The MAP should be incremented after the second-byte data
transfer to be ready for the next byte. If more data is to be transferred, the bytes are transferred to/from
memory sequentially with the MAP being incremented after every transfer. This scenario provides efficient
transfer of a byte, or a block of bytes by only providing the MAP once, initially.
Figure 2-14 illustrates an external system write sequence that writes data to the Controller’s memory.
Using this protocol, the external system (System) first writes the address byte where the LSB indicates a
read or a write sequence. For the I2C format the 7-bit address must match the Control Port address for the
CPS.STR bit to go high. For the OSPI format, the address is ignored and CPS.STR goes high when the CS pin
goes low. The Controller, through either polling the CPS register or through the Control Port interrupt,
reads CPS. Since STR is high, the Controller knows that the System is accessing the Control Port but
doesn’t know yet whether it’s a read or a write sequence. In case it’s a read sequence, the Controller takes
the data stored at the previous MAP and stores it in the CP register. Writing CP causes the CPS.STR bit to
fall. When the System writes the next byte, the CPS.WR bit goes high, and the controller should interpret this
first byte to be a new MAP byte, and store the data as the new Memory Address Pointer. When CP is read
CPS.WR
Previous
CP (MAP) data
New MAP Data1 Data2
CPS.STOP
Controller writes
Controller reads CP Controller reads CP Controller reads CP and
CP with data from
and stores first byte and stores second stores third byte (Data2)
previous MAP
as new MAP byte (Data1) at MAP at MAP+1 address
address
Indicates to Controller
that the external system
is finished sending data
Figure 2-14: Control Port I2C and OSPI Write Sequence
by the Controller, CPS.WR is cleared. When the System writes the next byte, CPS.WR goes high again and
the Controller should interpret this new byte as actual data and store it at the location pointed to by the
MAP byte. The Controller should then increment the MAP byte to be ready for the next byte received.
When the System finishes writing all the data, it sends a STOP bit for the I2C format, or raises the CS pin for
the OSPI format. This causes the CPS.STOP bit to go high signaling the Controller that this sequence is
over. The Controller should write the CPS.STOP bit to zero clearing it.
External system sends START bit External system sends
and correct address in I2C format, or STOP bit in I2C format, or
CS falls in an SPI format. CS rises in an SPI format.
External system External system
External system
starts shifting out the starts shifting out the
starts shifting out the
next byte (Data1) next byte (Data2)
next byte (Data3)
CPS.STR
CPS.RD
CPS.STOP
Figure 2-15: Control Port I2C and OSPI Read Sequence (slave)
CPS.WR
CPS.STOP
If the external system is clocking the data too fast, the Control Port hardware will stretch the clock (SCL pin)
while CPS.STR is high, or if CPS.WR remains high and a new byte is in the shift register waiting to be trans-
ferred to the CP register. This prevents the external system I2C master from continuing until SCL is
R/W
R/W
AD1
AD0
AD1
AD0
SDA S 0 1 0 0 0 0 A MAP A S 0 1 0 0 0 1 A Data1 A Data2 P
CPS.WR
CPS.RD
CPS.STOP
External
System: Acknowledge Acknowledge Acknowledge Acknowledge
CPS.STR
CPS.WR
CPS.STOP
External
Data read from (MAP) Data read from (MAP+1)
System: Acknowledge Acknowledge Acknowledge
CPS.STR
CPS.WR
CPS.RD
CPS.STOP
CPS.NACK
External Write
Memory Address Data to store Data to store
System Part Address Pointer at (MAP) at (MAP+1)
SCLK
CS
CPS.STR
CPS.WR
CPS.STOP
Figure 2-20: Control Port OSPI Write Sequence
The CPS.STR bit is set when the CS pin goes low, and is cleared when the Controller writes the CP register.
The address, in the first byte sent by the external system, is arbitrary and not checked by the Control Port
hardware. In the address byte, only the R/W bit has any significance, and determines how the Control Port
RD and WR bits respond. If the OSPI slave device does not have enough time (or does not respond)
between CS going low and the first byte shifting out, the first byte received by the OSPI master will be old
data. Since the SPI format has no provision for stretching the clock, interrupt latencies should be mini-
mized, and external system code should be written with this issue in mind. When the external System
drives CS high, the CPS.STOP bit rises indicating the end of a transfer. An OSPI write sequence is illustrated
in Figure 2-20. The SCLK polarity and phase are fixed as depicted in the Figure (in the GSPI format, SCLK
is configurable). An OSPI read sequence is illustrated in Figure 2-21.
R/W
SDIN x x x x x x x 0 MAP x x x x x x x 1
SCLK
CS
Control Port:
Data from (MAP) Data from (MAP+1)
CPS.STR
CPS.WR
CPS.RD
CPS.STOP
SCLK
CPOL = CPHA = 1
CS
IFR.ICP
CPS.STR
CPS.STOP
SCLK
CPOL = CPHA = 0
CS
* * *
IFR.ICP
CPS.STR
CPS.STOP
* One to three interrupts can occur, caused by: 8 clock cycles, STOP, STR
The relationship between SCLK and the data can be programmed using two bits in the CPS register: CPOL
and CPHA. SCLK must be stable and the correct polarity, as illustrated in Figure 2-24, when CS transitions.
CS
CPS.CPOL = 0
SCLK CPS.CPHA = 0
CPS.CPOL = 0
SCLK CPS.CPHA = 1
SCLK CPS.CPOL = 1
CPS.CPHA = 0
SCLK CPS.CPOL = 1
CPS.CPHA = 1
In GSPI format, an internal counter counts 8 SCLK bit periods and then sets the Control Port interrupt bit
IFL.ICP. Reading or writing CP clears this interrupt. The counter is reset when CS is high. The Controller can
use IFL.ICP to service the Control Port. The data protocol for this format is left entirely to the user. If polling
is desired, Controller software can be written to logically OR the STR, RD and WR bits in the CPS register,
and when found high, the Control port needs servicing. Using the RD and WR bits in this manner requires
the Controller write CP each time the Control Port is serviced.
USART1
Control U1C
DCS/IOB3/UFR1 Logic 53h
DAD0/DSDIN/URX1 1
DSDA/DSDOUT/UTX1
DSCL/DSCLK/UCK1 0
shift register Control
Logic shift register shift register
DPFD
Program control is diverted to the Debug Port interrupt vector (location 0x0000C) whenever any of the sta-
tus bits (DCPS bits STOP, STR, WR, NACK, RD) goes high. If the debug interrupt is enabled (IER.DIEN set), the
debug interrupt service routine must clear the condition causing the interrupt (clear the DCPS bit as
described below), before exiting the ISR.
DPFD Debug Port Formats Disable. When clear, the Debug Port formats listed in this section are
enabled. If set, the Debug Port formats are disabled and the Debug Port can be configured for
USART1 (U1C.USEN set) or the four pins can be used as EGPIO port IOB[3:0] (U1C.USEN clear).
FAST Fast mode enable. When the Debug Port is a master (DPMM set), FAST determines the clocking
serial port clocking frequency as shown below:
With FAST clear the approximate clocking frequency is 88.2 kHz when Fs = 44.1 kHz, and
96 kHz when Fs = 48 kHz.
With FAST set, the approximate clocking frequency is 295.8 kHz when Fs = 44.1 kHz, and
310.6 kHz when Fs = 48 kHz.
NACK No Acknowledge. Reading this bit does not read what was written. The read bit going high can
generate an interrupt, if enabled. Writing NACK to zero clears the interrupt condition.
When the Debug Port is configured as a slave port (DPMM clear):
NACK is set when the external master device is performing a read operation and does not
acknowledge the transfer. Software can write this bit to zero after reading DCP. When
configured as a slave port, software should never write NACK to one.
When the Debug Port is configured as a master port (DPMM set):
NACK is set when writing an external device and it does not acknowledge the transfer. In
I2C format, software should set NACK to one to keep the Debug Port from acknowledging
the next (last) transfer. Once the “no acknowledge” is transmitted, NACK will read back
one and must be cleared in software. The data in DCP must be read before clearing NACK
or another eight clocks will be sent out. In GSPI format, NACK should be set for full-duplex
communications, since it will keep DCP reads from generating 8 clocks (only writes will
generate 8 clocks).
DPMM Debug Port Master Mode enable. When clear, the Debug Port is a slave port. When set, the
Debug Port is a master port and FAST selects the clocking speed used. The OSPI format is not
supported. In addition, I2C multi-master format is not supported.
I2CF SPI or I2C format. When set, the Debug Port uses the I2C format. When clear, the Debug Port
uses the SPI format indicated by the GSPI bit. I2CF is initially set by the value of the
DSCL/DSCLK pin when RST is de-asserted or at initial power-up.
GSPI Generic SPI. When set, and I2CF is clear, the Debug Port interface uses a generic SPI format
(GSPI). When GSPI is clear (Oasis-specific SPI, OSPI), the data format matches the I2C for-
mat and the WR and RD bits work as in I2C format. The Debug Port must be a slave port when
configured for OSPI mode.
CPOL Clock Polarity, in generic SPI format only. When GSPI is set and I2CF is clear, this bit deter-
mines the SCLK clock polarity as indicated in Figure 2-24.
CPHA Clock Phase, in generic SPI format only. When GSPI is set and I2CF is clear, this bit deter-
mines the DSCLK clock phase as indicated in Figure 2-24. When in slave mode and CPHA is
clear, DCS must be brought high between each data byte transferred.
STR Start. Reading indicates if a start condition has been detected on the bus. When in master
mode, writing to 0 clears the bit and writing to 1 causes a Start condition. If a STR condition is
detected on the bus, an interrupt can be generated in I2C and GSPI-slave formats.
When the Debug Port is configured as a slave port (DPMM clear):
In I2C format, STR is set when an I2C Start bit is detected on the bus, followed by an
address matching 010001z, where z is set via the DAD0 pin. In both SPI formats, STR
going high indicates that the DCS pin fell. STR is cleared by writing to the DCP register
(STR is read-only and cannot be cleared by writing to 0). Writing STR to 1 has no effect.
When the Debug Port is configured as a master port (DPMM set):
In I2C format, STR is set only after an I2C Start bit is detected on the bus. In GSPI format,
2
STR is always low. STR is cleared by writing STR to zero. In I C format, writing STR to one
causes a Start bit to be transmitted onto the bus. Once the bit is transmitted, STR will be
read as one, indicating a Start condition was seen on the bus.
WR Write data bit. When the Debug Port is not in generic SPI mode (GSPI clear):
When in slave mode, WR is set when data is transferred from the serial input shift register to
the DCP register; and WR is cleared when the Controller reads the DCP register or explic-
itly writes WR to 0. Writing WR to 1 has no effect.
When in master mode, WR is set when data is transferred from DCP to the serial shift register,
to be shifted out; and WR is cleared when the Controller writes DCP with the next word, or
explicitly writes WR to 0.
D[7:0] Debug Port bi-directional data register when the Debug Port is enabled and in any format
except USART1.
When the Debug Port is configured as a slave port (DCPS.DPMM clear):
Reading or writing the DCP register after DCPS.WR or DCPS.RD is set, clears the particular
status bit, clearing the interrupt condition.
When the Debug Port is configured as a master port (DCPS.DPMM set):
Writing the DCP register causes 8 clocks to be transmitted in GSPI and 9 clocks in I2C.
Reading the DCP register also causes 8 clocks to be transmitted in GSPI and 9 clocks in
I2C format. However in I2C format, DCPS.NACK should be written immediately after read-
ing the second-to-last transfer from DCP. This will cause the part to not-acknowledge the
last transfer. Once the last byte is in DCP, it must be read BEFORE clearing DCPS.NACK
(or another 9 clocks will be transmitted). For GSPI format, if DCPS.NACK is set before read-
ing the last word in DCP, no more clocks will be generated. Then DCP should be read,
followed by clearing DCPS.NACK.
See the Control Port Section for an functional description of how the Debug Port operates. The differences
are that the Debug port can only set the LSB of the port address in the I2C format, the interrupt vector is
unique for the Debug Port, the registers are DCPS and DCP instead of CPS and CP, and the pins used
have the same name as the Control Port with a ‘D’ prefix attached. In addition, the Debug Port is attached
to USART1; whereas the Control Port is attached to USART0. Since the interrupt is non-maskable and the
Debug Port pins powering-up can generate initial conditions, (generally the DCPS.STOP bit is set) a Debug
Interrupt Routine is required, even if the Debug Port is unused. The following is an example of a dummy
interrupt routine that will clear out any initial interrupt flags that get set.
//--------------------------------------
// Dummy Debug Interrupt Routine
//--------------------------------------
Dummy_Debug_Int_Routine:
*sp = acc; // push ACC on stack
sp += 2;
2.3.5 USARTs
The Control Port and the Debug Port can be configured for USART operation. USART0 is connected to the
Control Port and USART1 is connected to the Debug Port. Through a programmable divider, standard
BAUD rates are supported (1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 230400).The clock
source for the USARTs is configurable, based on the UnC.CKSL[1:0] bits: 256xFs, 384xFs, 512xFs. For tim-
ing-slave devices, the entire chip is frequency locked to the Network Fs; therefore, the BAUD rate gener-
ated is relative to Fs. If the chip is out-of-lock, the BAUD rate will drift with the PLL, which can cause errors
when the USART is configured for asynchronous operation (assuming the device connected to the USART
is not also frequency locked to Fs).
The USART can be configured for asynchronous or synchronous operation. Asynchronous operation sup-
ports BAUD rates of up to 230400; whereas, synchronous operation supports BAUD rates up to 1 Mbit.
The synchronous format uses start and stop bits to delineate the bytes.
UCKn
TXI Transmit Status. When set, The U0TX.UTD[7:0] bits are free to be loaded with the next byte to
transmit. TXI can be cleared by writing U0TX. TXEN set can also set IFL.ICP and can generate an
interrupt if IER.IECP is set. When initially coming out of reset, the TXI bit will be clear even
though the U0TX.UTD[7:0] bits will be empty. After the initial data is written to U0TX.UTD[7:0], and
the UART starts transmitting the data, TXI will be set.
RXI Receive Status. When set, The U0RX.URD[7:0] bits contain a received byte. RXI can be cleared
by reading U0RX. RXEN set can also set IFL.ICP and can generate an interrupt if IER.IECP is set.
TXEN Transmit Interrupt Enable. When set, and USEN is set, the USART0 transmit port empty bit TXI
sets IFL.ICP and can generate an interrupt if IER.IECP is set. When clear, the transmit Interrupt
will not set IFL.ICP and TXI can be used in a polling fashion.
RXEN Receive Interrupt Enable. When set, and USEN is set, the USART0 receive port full bit RXI sets
IFL.ICP and can generate an interrupt if IER.IECP is set. When clear, the receive Interrupt will not
set IFL.ICP and RXI can be used in a polling fashion.
SYTX Synchronous Transmit signal. Must be 0.
USEN USART0 enable. When set, and the regular Control Port formats are disabled (CPS.CPFD set),
USART0 is enabled. When clear, USART0 is disabled and the pins can be used as IOA[3:0] if
CPS.CPFD is set.
CKSL[1:0] Clock Select. Selects the clock source used for the divider chain U0DV.
00 - 256Fs
01 - 384Fs
10 - 512Fs
11 - Reserved.
SYEN Synchronous Enable. When set, the data format is synchronous. CKMTR determines whether
this device is the synchronous master or slave device. Synchronous data is output on the fall-
ing edge of UCK0 and valid on the rising edge of UCK0. In synchronous mode, no parity is gen-
erated. When SYEN is clear, USART0 operates as a UART (asynchronously), and the UCK0
and UFR0 pins are free to used as EGPIO pins IOA0 and IOA3.
D[15:0] The following table indicates the dividers needed to support standard BAUD Rates. The maxi-
mum BAUD rate for asynchronous operation is 230400, and the maximum BAUD rate for syn-
CKSL × Fs
chronous operation is 1000000 (1 MBAUD). The formula is U0DV[15:0] = ----------------------------------- – 1 .
Target BAUD
Target UnDV[15:0]
BAUD Fs = 44.1 kHz Fs = 48 kHz
Rate 256xFs 384xFs 512xFs 256xFs 384xFs 512xFs
1200 24BFh 371Fh 497Fh 27FFh 3BFFh 4FFFh
2400 125Fh 1B8Fh 24BFh 13FFh 1DFFh 27FFh
4800 092Fh 0DC7h 125Fh 09FFh 0EFFh 13FFh
9600 0497h 06E3h 092Fh 04FFh 077Fh 09FFh
19200 024Bh 0371h 0497h 027Fh 03BFh 04FFh
38400 0125h 01B8h 024Bh 013Fh 01DFh 027Fh
57600 00C3h 0125h 0187h 00D4h 013Fh 01A9h
115200 0061h 0092h 00C3h 0069h 009Fh 00D4h
230400 0030h 0048h 0061h 0034h 004Fh 0069h
Table 2-41: UnDV Values for Standard BAUD Rates
RB Received break. When set, indicates that a break was detected (all space). Cleared by writing
RB to 0.
OE Overrun Error. When set, indicates that a new data byte was lost due to the URD[7:0] being full.
This bit is sticky and cleared by writing to 0.
PE Parity Error. Only possible in Asynchronous mode, U0C.SYEN clear. When PE is set, indicates
that parity was in error since the last time PE was cleared. Cleared by writing PE to 0.
FE Framing Error. FE set indicates a stop bit was not received at the expected bit time.
RDF When set, URD[7:0] contain a received data byte. Cleared by reading U0RX.
URD[7:0] USART0 received data. RDF set indicates new data is available.
TSB Transmit Send Break. When set, the UTX0 pin continually sends the space character. (Sets
the FE and RB bits in receiving device.)
UTD[7:0] USART0 Transmit Data. U0C.TXI set indicates that new data can be loaded into UTD[7:0].
TXI Transmit Status. When set, The U1TX.UTD[7:0] bits are free to be loaded with the next byte to
transmit. TXI can be cleared by writing U1TX. If TXEN is set when TXI goes high, a Debug Inter-
rupt will occur if IER.DIEN is set. When initially coming out of reset, the TXI bit will be clear even
though the U1TX.UTD[7:0] bits will be empty. After the initial data is written to U1TX.UTD[7:0], and
the UART starts transmitting the data, TXI will be set.
RXI Receive Status. When set, The U1RX.URD[7:0] bits contain a received byte. RXI can be cleared
by reading U1RX. If RXEN is set when RXI goes high, a Debug Interrupt will occur if IER.DIEN is
set.
TXEN Transmit Interrupt Enable. When set (and USEN is set), the USART1 transmit port empty bit TXI
causes a Debug Port interrupt if IER.DIEN is set. When clear, TXI going high does not cause a
Debug Interrupt and can be used in a polling fashion.
RXEN Receive Interrupt Enable. When set, and USEN is set, the USART1 receive port full bit RXI
causes a Debug Port interrupt if IER.DIEN is set. When clear, RXI going high does not cause a
Debug Interrupt and can be used in a polling fashion.
SYTX Synchronous Transmit signal. Must be 0.
USEN USART1 enable. When set, and DCPS.DPFD set (Debug Port Formats disabled), enables
USART1. When clear, USART1 is disabled and the pins can be used as IOB[3:0] if DCPS.DPFD
is set.
CKSL[1:0] Clock Select. Selects the clock source used for the divider chain U1DV.
00 - 256Fs
01 - 384Fs
10 - 512Fs
11 - Reserved.
CKMTR Clock Master. When in synchronous mode (SYEN set), CKMTR set enables the synchronous
clock (set by U1DV) to be output on UCK1. When CKMTR is clear (clock slave), UCK1 is an
input for the synchronous clock, and the data direction bit for IOB0 (EDD1.GPOB0) must be clear
(set to input).
PMD[1:0] Parity Mode. Only valid when parity is enabled (PEN set), and in asynchronous mode (SYEN
clear).
00 - Even Parity. Number of transmitted ones is even.
01 - Odd Parity. Number of transmitted ones is odd.
10 - Space. Parity is fixed as a space.
11 - Mark. Parity is fixed as a mark.
PEN Parity Enable. When set and in asynchronous mode (SYEN clear), parity is enabled and a par-
ity character is added between the data and the stop bit. The type of parity is selected via
PMD[1:0].
U1DV[15:0] See Table 2-41 for the divider needed to support standard BAUD rates. The maximum BAUD
rate for asynchronous operation is 230400, and the maximum BAUD rate for synchronous
CKSL × Fs
operation is 1000000 (1 MBAUD). The formula is U1DV[15:0] = ----------------------------------- – 1
Target BAUD
RB Received break. When set, indicates that a break was detected (all space). Cleared by writing
RB to 0.
OE Overrun Error. When set, indicates that a new data byte was lost due to the URD[7:0] being full.
This bit is sticky and cleared by writing to 0.
PE Parity Error. Only possible in Asynchronous mode, U1C.SYEN clear. When PE is set, indicates
that parity was in error since the last time PE was cleared. Cleared by writing PE to 0.
FE Framing Error. FE set indicates a stop bit was not received at the expected bit time.
RDF When set, URD[7:0] contain a received data byte. Cleared by reading U1RX.
URD[7:0] USART1 received data. RDF set indicates new data is available.
TSB Transmit Send Break. When set, the UTX1 pin continually sends the space character. (Sets
the FE and RB bits in receiving device.)
UTD[7:0] USART1 Transmit Data. U1C.TXI set indicates that new data can be loaded into UTD[7:0].
Control Bus
2Fh 31h
TMOD GPC
32h
2Eh
DDR
TMR 64xFs
Logic
Logic
To save pins, all the GPIO are multiplexed with other functions. The GPA[3:0] and GPB[3:0] can be used by
either the Host Controller or DSP0. For the Host Controller, they are just GPIO and serve no other pur-
pose. For DSP0, the pins can be either enhanced GPIO or Asynchronous Source Port A. For DSP0 to
have control over the GPA[3:0] and GPB[3:0] pins, the Host Controller must leave them configured as
inputs. In rev. G or greater, when the GPIO is configured as an output by either DSP0 or the Host Control-
ler, DSP0’s IPOT register controls the output type (open-drain or driven in both directions). In revisions
prior to G, the Host Controller’s GPIO outputs are always open-drain.
The GPC[3:0] and GPD[3:0] pins can be used by either the Host Controller or DSP1. For the Host Controller,
GPC[3:2] can be GPIO or TMR[1:0], and the GPD[3:0] pins can generate interrupts. For DSP1, the pins can
be either enhanced GPIO or Asynchronous Source Port B. For DSP1 to have control over the GPC[3:0] and
GPD[3:0] pins, the Host Controller must leave them configured as inputs. In rev. G or greater, when the
GPIO is configured as an output by either DSP1 or the Host Controller, DSP1’s IPOT register controls the
output type (open-drain or driven in both directions). In revisions prior to G, the Host Controller’s GPIO out-
puts are always open-drain.
GPD0 and GPD1 have associated capture registers: CAP0 and CAP1. When the pin is configured to be
edge sensitive (GPC.LVn clear), the corresponding capture register is loaded with the contents of the GP
Timer when the interrupt occurs. The capture registers are not affected when GPDn is configured as level-
sensitive (GPC.LVn set).
GPD[3:0] I/O data for the GPD[3:0] pins. DDR.GPDOE[3:0] enables the pin as an output. These pins can
also interrupt the Host Controller. As an interrupt, the polarity, and whether its level- or edge-
sensitive, is controlled via GPC.IP[3:0] and GPC.LV[3:0] bits, respectively. The interrupt is enabled
via IER.IED[3:0] with the status in IFL.ID[3:0]. If these pins are left as inputs, then DSP1 can use
the GPD port as its own GPIO or as Source Port B1.
GPC[3:0] I/O data for the GPC[3:0] pins. DDR.GPCOE[3:0] enables the pin as an output. GPC3 can also be
the TMR1 output, enabled via GPC.TOE1. GPC2 can also be the TMR0 output, enabled via
GPC.TOE0. The timer interrupt IFL.ITMR0 is generated by the rising edge of TMR0. If these pins
are left as inputs, then DSP1 can use the GPC port as its own GPIO or as Source Port B0.
GPB[3:0] I/O data for the GPB[3:0] pins. DDR.GPBOE[3:0] enables the pin as an output. If these pins are
left as inputs, then DSP0 can use the GPB port as its own GPIO or as Source Port A1.
GPA[3:0] I/O data for the GPA[3:0] pins. DDR.GPAOE[3:0] enables the pin as an output. If these pins are
left as inputs, then DSP0 can use the GPA port as its own GPIO or as Source Port A0.
TOE1 Timer 1 Output Enable. When set, changes the GPC3 pin to the TMR1 output. The DDR.GPCOE3
bit must still be set to use TMR1. Once enabled, OP1 sets the output polarity. When the GP
Timer value matches CMP1, TMR1 changes state.
TOE0 Timer 0 Output Enable. When set, changes the GPC2 pin to the TMR0 output. The DDR.GPCOE2
bit must still be set to use TMR0. Once enabled, OP0 sets the output polarity. When the GP
Timer value matches CMP0, TMR0 changes state. A rising edge of TMR0 can also generate
an interrupt (IFL.ITMR0).
OP[1:0] Timer Output Polarity for TMR1 and TMR0 pins. When clear, the corresponding pin is low while
the GP Timer value is less than or equal to the corresponding CMPn register value. When set,
the corresponding pin is high while the GP Timer value is less than or equal to the correspond-
ing CMPn value.
LV[3:0] Level-sensitive Interrupt type. When set, the corresponding GPDn interrupt is level sensitive
and the IFL.IDn bit is read-only. The interrupt must be cleared externally. When LVn is clear, the
IFL.IDn bit is edge-sensitive and cleared by writing a 0 to the IFL.IDn bit.
IP[3:0] Interrupt polarity. When set, the GPDn pin is active high (rising edge, or high, generates inter-
rupt). When IPn is clear, the GPDn pin is active low (falling edge, or low, generates interrupt).
GPDOE[3:0] GPD[3:0] output enables. When set, the corresponding GPDn pin is an output and, in rev. G or
greater, DSP1’s IPOT.GPPTDn bits control the output driver type. When clear, the GPDn pin is an
input if DSP1 hasn’t configured it as an output through the corresponding EDD.GPODn bit.
GPCOE[3:0] GPC[3:0] output enables. When set, the corresponding GPCn pin is an output and, in rev. G or
greater, DSP1’s IPOT.GPPTCn bits control the output driver type. When clear, the GPCn pin is an
input if DSP1 hasn’t configured it as an output through the corresponding EDD.GPOCn bit.
GPBOE[3:0] GPB[3:0] output enables. When set, the corresponding GPBn pin is an output and, in rev. G or
greater, DSP0’s IPOT.GPPTBn bits control the output driver type. When clear, the GPBn pin is an
input if DSP0 hasn’t configured it as an output through the corresponding EDD.GPOBn bit.
GPAOE[3:0] GPA[3:0] output enables. When set, the corresponding GPAn pin is an output and, in rev. G or
greater, DSP0’s IPOT.GPPTAn bits control the output driver type. When clear, the GPAn pin is an
input if DSP0 hasn’t configured it as an output through the corresponding EDD.GPOAn bit.
Final Product Data Sheet © Copyright 2001-2003 Oasis SiliconSystems DS8805FP5
Page 76 Restricted Access
RFPR RX FIFO Pointer Release. Only valid when MJCE is set. When RFPR is clear, the RX FIFO
Pointers are held in reset, where the pointers are equidistant. When RFPR is set, the RX FIFO
Pointers are free to track the data, where the incoming FIFO pointer is clocked from the RX
recovered clock and the outgoing FIFO pointer is clocked from an internal non-jittered clock.
When MJCE is set, software must toggle RPFR after any unlock-to-lock sequence to maximize
the distance between the read and write pointers. Toggling this bit may or may not cause a
momentary unlock event (which should be ignored). Leaving this bit low also may not cause
unlock events.
MJCE Timing-Master Jitter Control Enable. When MJCE is set in a timing-master (bXCR.MTR set), a
receive FIFO is used to recover data from the RX pin, and software must manage the reset of
the pointers to maximize the peak-to-peak jitter tolerance of a master node. When MJCE is set,
software must use RFPR to reset the FIFO pointers every time lock is achieved. When MJCE is
clear, the MOST transceiver operates in a normal automatic jitter tolerance mode that requires
no software intervention.
NETD Network Disable. When set, TX and RX can be used as GPIO IOG2 and IOG3, respectively.
ERRD ERR pin Disable. When set, ERR can be used as EGPIO IOG1.
EDMEN External Data Memory Enable for DSP0, when RGEN.XME is set and MMPC.XMQ is clear. Then
EDMEN set enables the external data memory port. EDMEN clear configures the IOE[15:0] and
IOF[10:0] pins to be used as EGPIO.
2.3.8 EGPIO
The OS8805 has the ability to configure almost all digital IO pins for its regular functions or as Enhanced
GPIO pins. There are a total of 64 GPIO pins GPA[3:0], GPB[3:0], GPC[3:0], GPD[3:0], IOA[3:0], IOB[3:0],
IOC[5:0], IOD[1:0], IOE[15:0], IOF[10:0], and IOG[4:0], however they are multi-functions pins.
Although the GPIO pins of OS8805 (GPA[3:0], GPB[3:0], GPC[3:0], and GPD[3:0]) are multiplexed with the
new DSP source ports, the default is that the GPIO pins of OS8805 function the same in the OS8804. The
remaining GPIO pins operate as the extended GPIO (EGPIO) where the function of EGPIO is described in
this section.
Each EGPIO pin is controlled by three control signals: the data direction GPOxn bit, the data polarity or
driver type GPPTxn bit, and the EGPIO sticky or output disable GPSDxn bit.
GPOxn
0 - input
1 - output
GPSDxn
EGPIO
GPDxn
(write) Pin
0 - open drain
0 1 - CMOS
0 GPPTxn
GPDxn 1 Q
SET
S
(read) 1 0 - active high/high pulse
Q CLR
R 1 - active low/low pulse
The table below summarizes the conditions in which each GPIO and EGPIO port can be configured and
the default function of each port.
The GPA[3:0] and GPB[3:0] are shared between the Host Controller and DSP0. The GPC[3:0] and GPD[3:0]
are shared between the Host Controller and DSP1. The DSPs have their own set of registers which control
the functionality of these pins and they are implemented as extended GPIOs. When the DDR bit of the
Host Controller of the corresponding GPIO pin is low, the DSPs has control of the direction of the GPIO
pin.
In the event that both the DDR of the corresponding pin of the Host Controller and the DSPs are set, the
Host Controller has priority of the GPIO pin over the DSPs. In other words, the data of the Host Controller
is presented on the GPIO pin.
GPDxn GPIO Data registers. When configured as an output, the data written to this bit is output to the
respective pin. The data read is the value at the pin and may not be the value written. When
configured as an input, displays the data from the pin, either directly or captured, based on the
polarity selected.
GPDEn GPIO Data registers. When configured as an output, the data written to this bit is output to the
respective pin. The data read is the value at the pin and may not be the value written. When
configured as an input, displays the data from the pin, either directly or captured, based on the
polarity selected.
GPDxn GPIO Data registers. When configured as an output, the data written to this bit is output to the
respective pin. The data read is the value at the pin and may not be the value written. When
configured as an input, displays the data from the pin, either directly or captured, based on the
polarity selected.
GPOxn Output Enable for corresponding IOxn pin. When IOxn is configured as a GPIO, this corre-
sponding bit determines whether the pin is a general purpose input or output.
0 - Corresponding IOxn pin is an input.
IPOT1.GPPTxn determines input polarity.
ISOD1.GPSDxn determines whether input is sticky or not.
1 - Corresponding IOxn pin is an output.
IPOT1.GPPTxn determines output driver type (CMOS or open-drain).
ISOD1.GPSDxn is an output disable/enable.
If the Control Port formats are enabled (CPS.CPFD clear), IOA3 can be configured as an output when using
GSPI master mode to act as the external device chip select, and must be configured as an input in all other
cases. If the Control Port is used in USART synchronous slave mode (CPS.CPFD clear, U0C.USEN and
U0C.SYEN set and U0C.CKMTR clear), IOA0 must be configured as input. If the Control Port is used in USART
asynchronous mode (CPS.CPFD and U0C.SYEN clear, and U0C.USEN set), IOA0 and IOA3 can be used as
GPIO.
Likewise, if the Debug Port formats are enabled (DCPS.DPFD clear), IOB3 can be configured as an output
when using GSPI master mode to act as the external device chip select, and must be configured as an
input in all other cases. If the Debug Port is used in USART synchronous slave mode (DCPS.DPFD clear,
U1C.USEN and U1C.SYEN set and U1C.CKMTR clear), IOB0 must be configured as input. If the Debug Port is
used in USART asynchronous mode (DCPS.DPFD and U1C.SYEN clear, and U1C.USEN set), IOB0 and IOB3
can be used as GPIO.
GPOEn Output Enable for corresponding IOEn pin. When IOEn is configured as a GPIO, this corre-
sponding bit determines whether the pin is a general purpose input or output.
0 - Corresponding IOEn pin is an input.
IPOT2.GPPTEn determines input polarity.
ISOD2.GPSDEn determines whether input is sticky or not.
1 - Corresponding IOEn pin is an output.
IPOT2.GPPTEn determines output driver type (CMOS or open-drain).
ISOD2.GPSDEn is an output disable/enable.
GPOxn Output Enable for corresponding IOxn pin. When IOxn is configured as a GPIO, this corre-
sponding bit determines whether the pin is a general purpose input or output.
0 - Corresponding IOxn pin is an input.
IPOT3.GPPTxn determines input polarity.
ISOD3.GPSDxn determines whether input is sticky or not.
1 - Corresponding IOxn pin is an output. When IOG3 is an output, it can only be configured as
open-drain, IPOT3.GPPTG3 doesn’t affect the pin.
IPOT3.GPPTxn determines output driver type (CMOS or open-drain).
ISOD3.GPSDxn is an output disable/enable.
GPPTxn Input polarity or output driver type for corresponding IOxn pin when configured as a GPIO.
When IOxn pin is configured as an input (EDD1.GPOxn clear), this bit sets the polarity:
0 - active high input (non-inverting) or high-pulse capture if sticky
1 - active low input (inverting) or low-pulse capture if sticky
When IOxn pin is configured as an output (EDD1.GPOxn set), this bit sets the output driver type:
0 - Open-drain output (only driven low)
1 - CMOS output (driven both high and low)
GPPTEn Input polarity or output driver type for corresponding IOEn pin when configured as a GPIO.
When IOEn pin is configured as an input (EDD2.GPOEn clear), this bit sets the polarity:
0 - active high input (non-inverting) or high-pulse capture if sticky
1 - active low input (inverting) or low-pulse capture if sticky
When IOEn pin is configured as an output (EDD2.GPOEn set), this bit sets the output driver type:
0 - Open-drain output (only driven low)
1 - CMOS output (driven both high and low)
GPPTxn Input polarity or output driver type for corresponding IOxn pin when configured as a GPIO.
When IOxn pin is configured as an input (EDD3.GPOxn clear), this bit sets the polarity:
0 - active high input (non-inverting) or high-pulse capture if sticky
1 - active low input (inverting) or low-pulse capture if sticky
When IOxn pin is configured as an output (EDD3.GPOxn set), this bit sets the output driver type.
When IOG3 is an output, it can only be configured as open-drain, IPOT3.GPPTG3 doesn’t
affect the pin.
0 - Open-drain output (only driven low)
1 - CMOS output (driven both high and low)
GPSDxn Input sticky or output disable for corresponding IOxn pin when configured as a GPIO.
When IOxn pin is configured as an input (EDD1.GPOxn clear), this bit sets sticky or not.
0 - EGPD1.GPDxn reflects the IOxn pin, after polarity (IPOT1.GPPTxn).
1 - EGPD1.GPDxn is sticky and captures a high or low pulse (based on IPOT1.GPPTxn)
on IOxn. Once set, cleared by writing EGPD1.GPDxn to zero (assuming pin is in inactive
state).
When IOxn pin is configured as an output (EDD1.GPOxn set), this bit controls output enable:
0 - The IOxn pin is enabled and driven, based on IPOT1.GPPTxn.
1 - The IOxn pin is disabled, high impedance.
GPSDEn Input sticky or output disable for corresponding IOEn pin when configured as a GPIO.
When IOEn pin is configured as an input (EDD2.GPOEn clear), this bit sets sticky or not.
0 - EGPD2.GPDEn reflects the IOEn pin, after polarity (IPOT2.GPPTEn).
1 - EGPD2.GPDEn is sticky and captures a high or low pulse (based on IPOT2.GPPTEn)
on IOEn. Once set, cleared by writing EGPD2.GPDEn to zero (assuming pin is in inactive
state).
When IOEn pin is configured as an output (EDD2.GPOEn set), this bit controls output enable:
0 - The IOEn pin is enabled and driven, based on IPOT2.GPPTEn.
1 - The IOEn pin is disabled, high impedance.
GPSDxn Input sticky or output disable for corresponding IOxn pin when configured as a GPIO.
When IOxn pin is configured as an input (EDD3.GPOxn clear), this bit sets sticky or not.
0 - EGPD3.GPDxn reflects the IOxn pin, after polarity (IPOT3.GPPTxn).
1 - EGPD3.GPDxn is sticky and captures a high or low pulse (based on IPOT3.GPPTxn)
on IOxn. Once set, cleared by writing EGPD3.GPDxn to zero (assuming pin is in inactive
state).
When IOxn pin is configured as an output (EDD3.GPOxn set), this bit controls output enable:
0 - The IOxn pin is enabled and driven, based on IPOT3.GPPTxn.
1 - The IOxn pin is disabled, high impedance.
VREF
1 35h
DCD
POT[7:0] DC ADC
MUX
0
8
CAL
DCC
DMS[2:0]
34h
Control Bus
The DCC register contains three bits which control the analog multiplexer and a sample bit (SAM). The out-
put of the multiplexer is sampled onto a capacitor approximately 1 µs after DCC.SAM goes high. This sam-
pled value is converted to a 12-bit value in approximately another 1 ms. After the conversion is complete,
the ready signal DCC.RDY goes high. The ready signal sets the DC ADC data ready interrupt bit IFL.IADC.
Since there is a delay between the time DCC.SAM goes high and the output of the mux is sampled, DCC.SAM
and the mux control bits DCC.DMS[2:0] can be changed at the same time. In addition, the mux can be
changed after the sampling process is complete, but before the conversion process is complete.
The interrupt resolution control bits DCC.IRES[2:0] specify the resolution at which DCC.RDY goes high, the
conversion is stopped, and the interrupt occurs.
RDY Data Ready. When set, indicates that the DCD register has valid data in it. The resolution
which causes RDY to go high is specified by IRES[2:0]. When RDY goes high, an interrupt can be
generated (IFL.IADC) if the interrupt enable bit IER.IEADC is set. When the DCD register is read,
RDY is cleared.
CAL Calibration. When set, the voltage reference is fed directly to the DC ADC input so that the
VREF error can be determined. Since setting CAL only selects the VREF voltage, subtracting
out the offset error must be done in Controller software.
PDN Power-down. When set, the DC ADC is powered down.
IRES[2:0] Interrupt resolution. Sets the resolution at which the interrupt IFL.IADC is generated.
000 – 12 bit
001 – 11 bit
010 – 10 bit
011 – 9 bit
100 – 8 bit
101 – 7 bit
110 – 6 bit
111 – 5 bit
SAM Start Sampling. Approximately 1 µs after SAM is set, the selected input is sampled. SAM is
automatically cleared. The conversion must finish (RDY high) before another conversion can
be started. If SAM is set before a conversion is complete, the current conversion is lost, and a
new conversion is started.
DMS[2:0] DC Measurement ADC Mux Select. Selects the DC input to be converted. Since the sampling
occurs approximately 1 µs after SAM is set, SAM and DMS[2:0] can be changed in the same reg-
ister write.
000 – POT0 pin
001 – POT1 pin
010 – POT2 pin
011 – POT3 pin
100 – POT4 pin
101 – POT5 pin
110 – POT6 pin
111 – POT7 pin
RES[2:0] Resolution of the DCD[11:0] bits. The conversion cycles through the resolutions until it reaches
the resolution set in DCC.RES[2:0] bits. RES[2:0] are updated as the DCD[11:0] bits are updated
when the DCC.IRES[2:0] resolution is reached, conversion is stopped and DCC.RDY is set. When
DCD is read, the DCC.RDY bit is cleared.
000 – 12 bit
001 – 11 bit
010 – 10 bit
011 – 9 bit
100 – 8 bit
101 – 7 bit
110 – 6 bit
111 – 5 bit
DCD[11:0] Two’s complement DC ADC measurement result. Resolutions below 12 bits are LSB-justified
(smaller numbers) and sign-extended to the full 12 bits, as shown in the Table below.
Figure 2-31 illustrates the transfer function when configured for 12-bit resolution.
approx. DCD[11:0]
Resolution RES[2:0]
96Fs cycles Positive Number Negative Number
5 bits 31 111 00000000RRRR 11111111RRRR
6 bits 63 110 0000000RRRRR 1111111RRRRR
7 bits 127 101 000000RRRRRR 111111RRRRRR
8 bits 255 100 00000RRRRRRR 11111RRRRRRR
9 bits 511 011 0000RRRRRRRR 1111RRRRRRRR
10 bits 1023 010 000RRRRRRRRR 111RRRRRRRRR
11 bits 2047 001 00RRRRRRRRRR 11RRRRRRRRRR
12 bits 4095 000 0RRRRRRRRRRR 1RRRRRRRRRRR
The ’R’ characters are the non-sign resolution binary bits
Table 2-73: DC ADC Resolution
(2047) 7FFh
12-bit code
(0) 000h
(-2048) 800h
0 VREF 2×VREF
Volts
Figure 2-31: DC ADC Transfer Function (12-bits)
ACR
Routing Bus
MUX
PWMOE PWM DAC Output Enable. When set, the PWM0 pin outputs a PWM signal representative of
the data sent to the PWMDR register by DSP0. When clear, the PWM0 output is muted (AC
ground).
ENPWM Enable PWM DAC. When set, the PWM0 DAC is enabled. When clear, the PWM0 DAC is
powered down and the PWM0 pin can be used as GPIO IOD0 pin.
AMS[1:0] Audio ADC Mux Select. Selects stereo analog inputs to the Audio ADC.
00 – AD0L, AD0R pins
01 – AD1L, AD1R pins
10 – AD2L, AD2R pins
11 – Reserved.
ENMPX Enable MPX ADC. When set, the MPX ADC is enabled. When clear, MPX is powered down.
ENMIC Enable Mic ADC. When set, the Mic ADC is enabled. When clear, Mic is powered down.
ENADL Enable Left Analog ADC. When set, the left Analog ADC is enabled. When clear, the left Ana-
log ADC is powered down.
ENADR Enable Right Analog ADC. When set, the right Analog ADC is enabled. When clear, the right
Analog ADC is powered down.
ENDAC[3:0] Enables for DAC3 through DAC0. When set, the corresponding DACx is enabled.
When clear, DACx is powered down and the output pin is at analog ground (DC zero).
PWM1OE PWM1 DAC Output Enable. When set, the PWM1 pin outputs a PWM signal representative of
the data sent to the PWM1DR register by DSP0. When clear, the PWM1 output is muted (AC
ground).
ENPWM1 Enable PWM1 DAC. When set, the PWM1 DAC is enabled. When clear, the PWM1 DAC is
powered down and the PWM1 pin can be used as GPIO IOG4.
DFS[1:0] DSP0 Frequency Select bits. Selects the operating speed of the DSP. These bits must be con-
figured before (in a different I/O cycle) RUN is set.
00 - 768×Fs
01 - 960×Fs
10 - 1536xFs
11 - 1344×Fs (default)
DM[25:16] The upper 10 bits of DSP0’s Program memory. Used, in conjunction with D0PDL.DM[15:0], as
the data portal when the Controller is accessing DSP Program memory.
RUN Set for normal operation. When clear, the DSP is in a low power state and the operating speed
can be selected through DFS[1:0]. In addition, Program memory can be filled by the Controller.
Once the programs are downloaded, D0PC should be programmed to 0, DFS[1:0] should be
configured, and (in a different cycle) RUN should be set to start DSP execution.
AI When set, the D0PC increments after a write (WR) or a read (RD).
WR Write DSP0 Program memory (write only). When WR is set, the DM[25:0] data (D0PCR.DM[25:16]
+ D0PDL.DM[15:0]) is written to the address specified by D0PC. WR is auto-cleared after the oper-
ation is complete.
RD Read DSP0 Program memory (write only). When RD is set, the DM[25:0] data (D0PCR.DM[25:16] +
D0PDL.DM[15:0]) is read from the address specified by D0PC. RD is auto-cleared after the opera-
tion is complete.
DFS[1:0] DSP1 Frequency Select bits. Selects the operating speed of the DSP. These bits must be con-
figured before (in a different I/O cycle) RUN is set.
00 - 768×Fs
01 - 960×Fs
10 - 1536xFs
11 - 1344×Fs (default)
DM[25:16] The upper 10 bits of DSP1’s Program memory. Used, in conjunction with D1PDL.DM[15:0], as
the data portal when the Controller is accessing DSP memory.
RUN Set for normal operation. When clear, the DSP is in a low power state and the operating speed
can be selected through DFS[1:0]. In addition, Program memory can be filled by the Controller.
Once the programs are downloaded, D1PC should be programmed to 0, DFS[1:0] should be
configured, and (in a different cycle) RUN should be set to start DSP execution.
AI When set, the D1PC increments after a write (WR) or a read (RD).
WR Write DSP1 Program memory (write only). When WR is set, the DM[25:0] data (D1PCR.DM[25:16]
+ D1PDL.DM[15:0]) is written to the address specified by D1PC. WR is auto-cleared after the
operation is complete.
RD Read DSP1 Program memory (write only). When RD is set, the DM[25:0] data (D1PCR. DM[25:16]
+ D1PDL. DM [15:0]) is read from the address specified by D1PC. RD is auto-cleared after the
operation is complete.
RCD[7:0] Refresh Counter Divider. When ARE is set, these bits form a divider of 1 to 256 which, along
with the RCP[1:0] bits, determine the refresh rate in DSP clock cycles (typically 1344xFs).
RCP[1:0] Refresh Counter Prescaler. When ARE is set, RCP[1:0], along with the RCD[7:0] bits, divide down
the DSP clock to generate an automatic DRAM refresh (CAS-before-RAS) rate.
00 – prescale divider of 64
01 – prescale divider of 8
10 – prescale divider of 1
11 – Reserved.
ARE Automatic Refresh Enable. When set, enables automatic CAS-before-RAS DRAM refresh.
The refresh rate is the DSP clock rate (typically 1344Fs), divided by the Refresh Counter
Divider bits RCD[7:0] + 1 then divided by the prescale bits RCP[1:0].
(RCD[7:0] + 1) × <RCP[1:0]>
The formula is: ---------------------------------------------------------------------------- s . Once a refresh request is made, the refresh will
<DnPCR.DFS[1:0]>
occur after the current external memory cycle has finished. When MMS is clear, ARE must be
clear.
MT Memory Timing. External Data Memory timing control. For exact timings, see the External Data
Memory Interface tables in the Electrical Characteristics Section.
0 – Fast Timing
1 – Slow Timing
BW External Data Bus Width. Along with the MWW bit, determines the number of external chips
needed for a given data memory size.
0 – 8-bit bus width. For a 16-bit word, two accesses are made; whereas once access is made
for an 8-bit word.
1 – 4-bit bus width. The External Memory Controller will make two accesses to get an 8-bit
word and four accesses to get a 16-bit word.
MWW Memory Word Width. Along with the BW bit, determines the number of external chips needed
to support a given memory size.
0 – word size is 8 bits
1 – word size is 16 bits
MCS
MWR
XMC.BW = 1
BSn+OFFn nibble 0 nibble 1 nibble 2 nibble 3
MWR
XMC.BW = 0
BSn+OFFn byte 0 byte 1
17 2
WRn 16-bit word
BSn+OFFn+0
BSn+OFFn+1
BSn+OFFn+2
BSn+OFFn+3
BSn+OFFn+0
BSn+OFFn+1
BSn+OFFn+2
BSn+OFFn+3
Figure 2-33: External Data Memory Port with 16-bit words (XMC.MWW set)
MCS
MWR
XMC.BW = 1
BSn+OFFn nibble 0 nibble 1
MWR
XMC.BW = 0
BSn+OFFn byte 0
9 2
WRn 16-bit word
BSn+OFFn+0
BSn+OFFn+1
BSn+OFFn+2
BSn+OFFn+3
BSn+OFFn+0
BSn+OFFn+1
BSn+OFFn+2
BSn+OFFn+3
Figure 2-34: External Data Memory Port with 8-bit words (XMC.MWW clear)
The Watchdog timer powers up enabled. Therefore, if the counter reaches its terminal
count, it will reset the chip. If it is not used, it must be explicitly disabled by setting
RGEN.WDD.
If the PLL is not locked, the time-out period will depend on the state of the FLT pin. If it is low, the time-out
period can be up to four times longer than normal.
The RST pin is level sensitive and must be low when power is applied to the device. If RST is low and the
power supply is above 2.7 to 3.0 V, the internal chips reset is active. This clears the CMCS.PD bit and takes
the chip out of the zero-power state.
The reset generator has a control and status register, RGEN, which allows the Host Controller to select
which features can cause a reset and indicates the source of the previous reset. Five control bits deter-
mine which events can cause a reset, and six status bits indicate the cause of the previous reset. The sta-
tus bits are only reset by writing the bits to zero (sticky) and they are not cleared by any reset source.
GPA2D GPA2 reset disable. When CMCS.PD is set and GPA2D is clear, two transitions (falling then rising
edge) on the GPA2 pin will cause an internal reset thereby clearing the CMCS.PD bit and power-
ing up the part. When GPA2D is set, transitions on GPA2 have no effect and will not wake up the
device. This bit is only reset by RST or by the power-supply monitor if the voltage is below
specification.
GPA1D GPA1 reset disable. When CMCS.PD is set and GPA1D is clear, two transitions (falling then rising
edge) on the GPA1 pin will cause an internal reset thereby clearing the CMCS.PD bit and power-
ing up the part. When GPA1D is set, transitions on GPA1 have no effect and will not wake up the
device. This bit is only reset by RST or by the power-supply monitor if the voltage is below
specification.
GPA0D GPA0 reset disable. When CMCS.PD is set and GPA0D is clear, two transitions (falling then rising
edge) on the GPA0 pin will cause an internal reset thereby clearing the CMCS.PD bit and power-
ing up the part. When GPA0D is set, transitions on GPA0 have no effect and will not wake up the
device. This bit is only reset by RST or by the power-supply monitor if the voltage is below
specification.
RXD RX reset disable. When CMCS.PD is set and RXD is clear, two transitions (falling then rising
edge) on the RX pin will cause an internal reset thereby clearing the CMCS.PD bit and powering
up the part. When RXD is set, transitions on RX have no effect and will not wake up the device.
This bit is only reset by RST or by the power-supply monitor if the voltage is below specifica-
tion.
WDD Watchdog timer disable. When clear, the Watchdog timer, WDT, counts up and resets the
device when it reaches all ones. The Host Controller must write WDT before all ones is
reached to prevent a reset. If WDD is set, the Watchdog timer is disabled.
XME External memory enable. This bit is initialized by a pull-up/pull-down on the XME/PCS pin.
When clear, the Host Controller uses external Program memory and the internal memory is
disabled. When set, the Host Controller uses internal memory, allowing DSP0 to use the exter-
nal memory port if desired (MMPC.XMQ and GCTL.EDMEN bits). Changing XME causes an internal
reset to be generated, which resets all the on-chip peripherals, and will reset the Host Control-
ler if the MMPC.RSTD bit is clear.
Final Product Data Sheet © Copyright 2001-2003 Oasis SiliconSystems DS8805FP5
Page 98 Restricted Access
Host
Controller Clock Manager GPIO and
DC ADC Control Port
(Cougar) and PLL Timer
Control Bus
Debug
Port COM COM
COM Port Port
Port
External
Memory
Controller DSP0 DSP1 Source Source MOST
DSP0 I/O (Gazelle) (Gazelle) Ports Converters Processor
Bus
Routing Bus
Figure 3-1: Routing Bus
DSP1 Receive
50h DSP0 Receive DAC1
58h
60h DAC2
68h
70h DAC3
78h
DSP1 Transmit
DSP0 Transmit
The special address reference F8h forces zero’s to any desired output channel. Placing F8h in an MRT
register tells the MOST Processor to output zero (0x00) for that particular destination byte. This may be
used to force unused channels to zero (mute) or as a temporary remedy to mute all output peripheral chan-
nels when lock is lost.
The MRT filled with the source addresses for this example is illustrated in Figure 3-4. The addresses to fill
in the MRT are gotten from Figure 3-3.
To send the Mic data to the MOST Network, the Host Controller would have to write, through the MOST
COM port, location 04h as the MAP (Memory Address Pointer). Then the Controller would write 67h, which
goes to location 04h, and 66h, which goes to location 05h. For MOST Network synchronous data greater
than one byte (channel), the most significant byte generally goes to the lowest location.
The second step is to get the MOST Network received stereo audio data from synchronous channels 00h-
03h and send them to DAC0 and DAC1. The MOST Network receive addresses are placed in the MRT at
the DAC0 and DAC1 destinations. Therefore, MRT locations for DAC0, 47h and 46h, must be programmed
with the left channel addresses from the MOST received synchronous data, 00h and 01h, respectively.
Likewise, the MRT locations for DAC1, 57h and 56h, must be programmed with the right channel
addresses from the MOST Network, 02h and 03h, respectively.
FSY
SCLK
The last peripheral routing involves sending the left and right audio ADCs out on the MOST Network. This
example uses the MRT locations 20h-23h. The standard ordering calls for left before right and most-signif-
icant byte first (at lowest address). Therefore, using Figure 3-3 addressing, the Left Audio ADC MS-Byte
address (47h) is placed at MRT 20h and the LS-Byte address (46h) is placed at MRT 21h. For the Right
Audio ADC, the MS-Byte address (57h) goes in MRT location 22h, and the LS-Byte address (56h) goes in
MRT location 23h.
Figure 3-2 and Figure 3-3 depict the Source Port signals supporting the maximum of eight bytes each. The
full eight bytes are used when the Source Ports are programmed for 64 bits per frame (bSDC1.NBR[1:0] =
00). Table 3-3 depicts the MOST Routing Table locations for all the different bit-per-frame formats sup-
ported on SX0 and SX1 and Table 3-4 depicts the MOST Routing Addresses for SR0 and SR1.
Bits per Byte
Signal
Frame First Last
*64 - in/out 40h 48h 50h 58h 60h 68h 70h 78h
48 - out 40h 48h 58h 60h 68h 78h
SX0 32 - out 40h 58h 60h 78h
*32 - in 40h 50h 60h 70h
SPDIF 40h 48h 50h 58h 60h 68h 70h 78h
*64 - in/out 41h 49h 51h 59h 61h 69h 71h 79h
48 - out 41h 49h 59h 61h 69h 79h
SX1
32 - out 41h 59h 61h 79h
*32 - in 41h 51h 61h 71h
* When SCK is an input (in), the clock is assumed continuous (not a gated clock).
Table 3-3: Source-Port MOST Routing Table for SX0, SX1
FSY
SCLK I/O:
64
SX0 (1) 40h (41h) 48h (49h) 50h (51h) 58h (59h) 60h (61h) 68h (69h) 70h (71h) 78h (79h)
SR0 (1) 40h (41h) 48h (49h) 50h (51h) 58h (59h) 60h (61h) 68h (69h) 70h (71h) 78h (79h)
SX0 (1) 40h (41h) 48h (49h) 58h (59h) 60h (61h) 68h (69h) 78h (79h)
SR0 (1) 40h (41h) 50h (51h) 58h (59h) 60h (61h) 70h (71h) 78h (79h)
32
SX0 (1) 40h (41h) 58h (59h) 60h (61h) 78h (79h)
SR0 (1) 50h (51h) 58h (59h) 70h (71h) 78h (79h)
SX0 (1) 40h (41h) 50h (51h) 60h (61h) 70h (71h)
SR0 (1) 48h (49h) 58h (59h) 68h (69h) 78h (79h)
However, if the left and right samples are swapped, so MRA 5Ah is the left sample and 7Ah is the right
sample, then MRT46/47 = 5Ah/5Bh and MRT65/57 = 7Ah/7Bh, the routing limitation is avoided, and the
stereo sample is coherent. Therefore, this routing limitation can be avoided by judicious use of the MRA
values when routing to MRT locations 40h to 47h.
For the transmitted SPDIF data on SX0, the Z preamble is transmitted every 192 SPDIF frames. If the con-
trol byte received from the Routing bus contains the SBK bit, then the transmitted data will be resynchro-
nized to the SBK bit, by transmitting the Z preamble in the next transmitted frame on SX0.
Source data is transmitted across the Most Network MSB-first. Since S/PDIF data is transmitted LSB-first,
each byte is bit-reversed before transmission. Therefore, data bytes received from SR0 are bit-reversed
before transmitting across the Routing bus. Likewise, bytes received from the Routing bus are bit-reversed
before transmitting out the SX0 pin.
The SPDIF receiver checks for parity and bi-phase coding errors. If an error occurs, the validity bit (V) of
the erred sub-frame is automatically set.
MOST Network synchronous data that is greater than one byte (channel) generally places the most signif-
icant byte in the lowest MRT location. To place the 16 most significant bits of SPDIF left data from the
received SR0 pin on the MOST Network, channels 0 and 1 and the right SPDIF data on channels 2 and 3;
the received-SPDIF most-significant-byte address 50h would be placed in the MRT table location 00h and
the middle-byte address 48h would be placed in MRT location 01h. For the right channel, the received-
SPDIF address 70h would be placed in MRT location 02h, and SPDIF address 68h in MRT location 03h.
Restricted Access
X Left SF Y Right SF Z Left SF Y Right SF X Left SF Y Right SF X
SX0 Pre-amble LSB Audio Data MSB V U C P Pre-amble LSB Audio Data MSB V U C P Pre-amble
bit-reversed
MOST System On Chip
Left LS byte Left middle byte Left MS byte CUV Right LS byte Right middle byte Right MS byte CUV
SX0 MRT
locations
40h 48h 50h 58h 60h 68h 70h 78h
SR0 MRA
addreses
40h 48h 50h 58h 60h 68h 70h 78h
Page 113
DS8805FP5
OS8805 MOST System On Chip
3.2.3 MOST Configuration Registers
For the MOST Processor registers, a prefix is added to the register name to help discern between byte and
word registers, as well as buffers. A prefix of ‘b’ indicates a byte-wide register. A prefix of ‘w’ indicates a
16-bit word-wide register, and a prefix of ‘m’ indicates a multi-byte buffer.
APREN Asynchronous Packet Receive Enable. This bit must be clear on revisions prior to G, which do
not support asynchronous packets.
0 – MOST Processor ignores received Asynchronous Packets.
1 – Enables reception of Asynchronous Packets. MOST Processor high-speed bit MMPC.RFS1
must be set to meet the proper timing when APREN is set.
bXSR.EXL
SET
S Q
Unlocked
bXSR.MXL
bXSR.ME
ERR
parity error
bi-phase error bXSR.ERR
bXSR.MSL S
SET
Q
SET
S Q
bXSR.ESL
Write ESL to 0 R CLR
Q
bIE.IERR
Power-up
Transceiver ready S
SET
Q RCS.INT
bMSGS.ERR
SET
S Q
Write bMSGC.RERR to 1 R CLR
Q
R CLR
Q
bIE.IALC IFL.IMST
bMPR or bMDR changes S
SET
Q Host
bMSGS.ALC Controller
Write bMSGC.RALC to 1 R CLR
Q
Interrupt
IER.IEMST
bIE.IMTX
Control message SET
S Q
transmission complete
bMSGS.MTX
Write bMSGC.RMTX to 1 R CLR
Q
bIE.IMRX
Ctrl message received. SET
S Q
mRCMB full
bMSGS.MRX
Write bMSGC.RMRX to 1 R CLR
Q
NP[7:0] Node Position. Represents the chip’s physical node position in the network. Enumeration
starts with 00h at the timing-master node. The timing-slave node connected to the timing-mas-
ters TX pin, has node position 01h, and so on. Nodes in all-bypass mode (bXCR.ABY clear) are
invisible to the Network and do not increment NP[7:0]. Sets the node’s physical address to
0x400 + NP[7:0]. Not valid until after Network lock (bCM2.LOK) is established.
GA[7:0] Group Address. Sets the nodes group address (group-cast) to 0x300 + GA[7:0]. A Control mes-
sage sent to the group address is received by all nodes that have their bGA register set to the
same value. C8h is not allowed in bGA as this is the Broadcast address (3C8h) for all nodes.
NA[15:8] Node Address High. The high portion of the Logical address, bits 11 through 8. Together with
bNAL, it forms the 12-bit Logical address used for Control messages. The default address
after reset is 0FFFh. Valid addresses are 0001h - 02FFh.
NA[7:0] Node Address low. The lower byte of the Logical address, bits 7 through 0. Together with
bNAH, it forms the 12-bit Logical address used for Control messages. The default address
after reset is 0FFFh. Valid addresses are 0001h - 02FFh.
D[7:0] Node Delays. Indicates the number of Synchronous Source data node delays between this
node and the timing-master node. If this node is not in Source data bypass mode (bXCR.SBY
clear), it will increment bNDR and pass the value to the next node. The time delay per node is
two frames. Only valid after lock (bCM2.LOK) is established.
D[7:0] Maximum Position. Indicates the total number of nodes in the network. A change of this regis-
ter sets bMSGS.ALC and generates an interrupt if bIE.IALC is set. Nodes in all-bypass mode
(bXCR.ABY clear) are invisible to the Network and not counted. Only valid after lock (bCM2.LOK)
is established and Network initialization is complete. Valid bMPR values are 0-63, where 0
indicates 64 nodes in the ring.
D[7:0] Maximum Delay. Indicates the total number of node delays for synchronous source data within
the Network. A change of this register sets bMSGS.ALC and generates an interrupt if bIE.IALC is
set. Nodes in Source-Data bypass mode (bXCR.SBY set) are not counted as they add no
source delay. Only valid after lock (bCM2.LOK) is established and Network initialization is com-
plete.
SAC[3:0] Synchronous Area Count – in quadlets. Can only be modified in the timing-master device
(bXCR.MTR set), and only valid after lock (bCM2.LOK) is established. Specifies the number of
quadlets reserved for synchronous data. The rest of the 15 quadlets may be used for asyn-
chronous data. Therefore, this value specifies the boundary between synchronous and asyn-
chronous data. In a timing-slave device, this register is read-only. Valid values are from 06h to
0Fh inclusive, where:
06h – 6 quadlets for synchronous data and 9 for asynchronous data (minimum value).
0Fh – All 15 quadlets for synchronous data and no asynchronous data. Although the chip sup-
ports 0Fh (no asynchronous data), the MOST Specification requires at least one quadlet
be reserved for asynchronous data, making the maximum 0Eh.
The default value is NOT valid. This register MUST be programmed to a valid value for
proper Network operation.
Whenever bSBC is changed, the timing-master node must send the De-allocate All system Control message
to initialize the mCRA properly.
The mCRA contains the current allocation status for each MOST Network synchronous byte, or channel.
The valid table size is based on the bSBC value (how many quadlets are reserved for synchronous data),
where the last valid byte is calculated as follows:
last mCRA byte = 380h + (bSBC × 4) - 1
In each byte, the MSB (most significant bit) is interpreted separately from the lower seven bits. Timing-
slave nodes (bXCR.MTR clear) must ignore the MSB, which can only be interpreted by the timing-master
node. In the timing-master, the MSB set indicates a channel is in use, and the MSB clear indicates a chan-
nel is not in use. The lower seven bits contain the Connection Label, which is loaded into each byte (phys-
The SrcAdr is the Source Address (the Node Address of the device sending the message), the TrgAdr is
the Target Address. The MOST Control message Length parameter supports lengths of up to 4095 bytes,
which is greater than the eleven bytes of the MOST Spec. Control message. The Length parameter is indi-
rectly coded in the TelID and TelLen fields.
In addition, the Length field is generally hidden when CF messages are described. Since only one of a par-
ticular FBlock exists in a typical system, the Instance ID can also be omitted, and is coded as 0. This would
make the MOST Spec Control message appear as follows:
SrcAdr -> TrgAdr: FBlockID.FktID.OpType(Parameter)
A variant listed in the MOST Specification lists functions which are in a device. The actual device is termed
DeviceID and would be the target address (TrgAdr) when sending a command to that function in that
particular device. The format follows:
DeviceID.FBlockID.InstID.FktID.OpType.Length(Parameter)
A Control message is transmitted through the mXCMB buffer and received through the mRCMB buffer.
The relationship between the normal Control message above, and the buffers are illustrated in Figure 3-11.
This Figure illustrates the alignment of the Control message to the buffers, but does not indicate all the
information required to send an actual message.
Control Message Data Area = 17 bytes
Parameters
16 bit 8 bit 8 bit 12 bit 4 bit 4 bit 4 bit 8 bit 8 bit 8 bit
Op Tel Tel ...
DeviceID FBlockID InstID FktID Data 0 Data 1 Data 11
Type ID Len
mXCMB: XTAH XTAL XCD0 XCD1 XCD2 XCD3 XCD4 XCD5 XCD6 ... XCD16
C2h C3h C4h C5h C6h C7h C8h C9h CAh D4h
mRCMB: RCD0 RCD1 RCD2 RCD3 RCD4 RCD5 RCD6 ... RCD16
A3h A4h A5h A6h A7h A8h A9h B3h
The following registers are used to send and receive Control messages. Control messages send are
divided into two groups: normal - where the transmit message type is 00h, and system - where the transmit
message type is anything other than 00h.
STX Start Transmission. When set, starts transmission of a control message previously written into
the Transmit Control Message Buffer, mXCMB. When the transmission starts, STX is cleared
automatically. The result is indicated by the bMSGS.TXR bit.
RBE Receive Buffer Enable. When set, the Receive Control Message Buffer, mRCMB, is free to
receive a new message. RBE is automatically cleared when the MOST Processor finishes the
releasing procedure. RBE should only be set after the current message has been read or if the
received message is to be ignored.
RES MOST Processor reset. When set, the MOST Processor resets all of the MOST Processor,
including bXCR, the COM ports, and the MOST Routing Table (MRT).
SAI Start Address Initialization. When set, starts address verification using the address previously
written into the mXCMB as target address. After the address is verified as unique in the net-
work, it is stored in the Node Address register bNAH, bNAL. The result of address initialization
is indicated by the bMSGS.TXR bit. SAI is automatically cleared.
RALC Reset Allocation change interrupt. When set, the Allocation Change Interrupt bit, bMSGS.ALC is
cleared. RALC is automatically cleared.
RERR Reset Error and Power-on after start-up interrupt. When set, the bMSGS.ERR bit is cleared.
RERR is automatically cleared.
RMTX Reset Message Transmit interrupt. When set, the bMSGS.MTX bit is cleared. RMTX is automati-
cally cleared.
RMRX Reset Message Receive interrupt. When set, the bMSGS.MRX bit is cleared. RMRX is automati-
cally cleared.
bRTYP Received Control message type. bRTYP indicates the type of address used to send the mes-
sage.
00h – Logical addressing (address in bNAH/bNAL).
01h – Physical addressing (0x400 + bNPR).
02h – Broadcast addressing (0x3C8).
03h – Groupcast addressing (0x300 + bGA).
bRSAH Source Address high. High-nibble of the logical address of the device which sent the mes-
sage.
bRSAL Source Address low. Low-byte of the logical address of the device which sent the message.
RCD[16:0] Received Control message bytes. When a message is received, bMSGS.RBS is set which locks
this buffer from further writing and indicates that a message was received. To unlock this
buffer for the next message, bMSGC.RBE must be set.
D[7:0] Time between transmit Control message retries. Specifies the number of Control message
periods to wait before attempting a retry. The minimum value is 03h. The time for one control
message is (approximately):
363 µs at Fs = 44.1 kHz
333 µs at Fs = 48 kHz.
D[7:0] Transmission Retry. Total number of attempts at transmitting a Control message, if the trans-
mission fails. The minimum value is 01h. The default value of 06h indicates 5 retries (plus the
initial attempt).
XCD[16:0] Transmit Control message. When this transmit buffer is loaded, then bMSGC.STX should be set,
causing the message to be transmitted. The transmission result is indicated by bMSGS.TXR with
the status in bXTS.
XTS[7:0] Transmission results. Reflects the results of the last control message transmission.
00h – Transmission failed. Target device did not respond.
10h – Transmission successful.
11h – Transmission successful, but receiving device doesn’t support the message type used.
Nodes with bNC.RWD set will return this response to a Remote Write system message.
20h – Transmission failed. Wrong CRC.
21h – Transmission failed. Target device receive buffer full.
To enable Async. Packet reception on the OS8805, the bNC.APREN and the MMPC.RFS1 bits
must both be set.
The bAPAH register keeps the higher address part (bits 15 through 8) of the alternate address for packets
received. The default alternate packet address after reset is 0x0F0F. The bAPAH register cannot be the
same value as bNAH. When a node receives a packet, it checks the target address high byte against its
bNAH value. If they do not match, the alternate packet address registers are checked. bAPAH and bAPAL
can be used as an asynchronous packet groupcast address to allow multiple nodes to receive the same
message. However, using this register for groupcast addressing does not have the same protection and
acknowledges that are associated with the Control message groupcast addressing.
The value in this register specifies the number of data bytes (in quadlets) sent when transmitting a packet,
and includes the data bytes along with the two source address bytes. Therefore, the length value is calcu-
lated as follows:
number of data bytes + 2
bPDLT = roundup ------------------------------------------------------------------
4
Valid values for bPLDT are 0x01 to 0x0D. If the length value is rounded up (fractional), then the extra filler
bytes at the end of the packet should be set to 0x00. For example, sending three data bytes takes two qua-
dlets, because two source address bytes are used. Three filler bytes exist at the end of the packet, which
should be filled with zeros. bPLDT does not include the CRC bytes, which are automatically generated by
the part.
The value in bPPI determines the priority of a transmitted packet, used in arbitration of the asynchronous
portion of the MOST Network source data. Valid values are 0x01 to 0x07, where 0x01 stands for the high-
est priority level.
RAF Reset Packet Rejected status (mARP full) bit bPCTS.AF. When the RAF bit is set, the bPCTS.AF bit is
cleared. RAF must not be set unless bPCTS.AF is set. The RAF bit is cleared automatically.
RAC Reset Packet Rejected status (CRC failed) bit bPCTS.AC. When the RAC bit is set, the bPCTS.AC bit is
cleared. RAC must not be set unless bPCTS.AC is set. The RAC bit is cleared automatically.
RATX Clear Packet Transmitted bit. When the RATX bit is set, the bPCTS.ATX bit is cleared. If both
bPCTS.ATX and bPCTS.ARX are clear, the Host Controller’s RCS.AINT bit is cleared. RATX must not
be set unless bPCTS.ATX is set. The RATX bit is cleared automatically.
RARX Unlock the Asynchronous Receive Packet Buffer mARP, and clear packet received interrupt.
Setting the RARX bit clears the bPCTS.ARX bit and unlocks the Asynchronous Receive Packet
Buffer mARP. If both bPCTS.ATX and bPCTS.ARX are clear, the Host Controller’s RCS.AINT bit is
cleared. When the bPCTS.ARX bit is set, mARP contains a packet and is locked until the RARX
bit unlocks it. While locked, mARP will not receive any other packets. RARX must not be set
unless bPCTS.ARX is set. The RARX bit is cleared automatically.
ASTX Start packet transmission. When the ASTX bit is set, the part starts arbitrating for the asynchro-
nous channel to transmit the current packet in mARP. The ASTX bit is cleared automatically
when the transmission is finished.
AF Packet rejected, mARP full. When the AF bit is set, it indicates that the last reception failed
because the packet receive buffer mARP is full (locked). mARP is unlocked by setting the
RARX bit to 1 after having read its contents. The AF bit is cleared by setting the bPCTC.RAF bit.
AC Packet rejected, CRC failed. When the AC bit is set, it indicates that the last reception failed
due to a bad CRC value. The AC bit is cleared by setting the bPCTC.RAC bit.
ATX Packet transmitted event. When the ATX bit is set, it indicates that a packet transmission is
completed. ATX will be set after the last byte of a packet is processed. The Host Controller’s
RCS.AINT bit will be set shortly after the ATX bit is set. The ATX bit is cleared by setting the
bPCTC.RATX bit.
ARX Packet received event. When the ARX bit is set, it indicates that a packet has been received
and that mARP is locked. Shortly after the ARX bit is set, the Host Controller’s RCS.AINT bit will
be set. The ARX bit is cleared by setting the bPCTC.RARX bit.
As long as the bPCTS.ARX bit is set, no reception of further packets is possible. Clearing the
bPCTS.ARX bit unlocks mARP. The contents of mARP can then be overwritten by the next
packet.
The Asynchronous Receive Packet buffer contains the last packet which was successfully received.
bARTH/bARTL Received Target Address High/Received Target Address Low. The target address to which
the received packet was sent. Either the logical node address (bNAH/bNAL) or the alternate
packet address (bAPAH/bAPAL).
bASAH/bASAL Source Address High/Source Address Low. The logical address of the sending node.
The origin of the packet data in the MOST Network.
bARD[0:47] Asynchronous Receive Data Bytes 0 to 47. These bytes contain the actual packet data that
was received.
Final Product Data Sheet © Copyright 2001-2003 Oasis SiliconSystems DS8805FP5
Page 130 Restricted Access
bATAH/bATAL
Target Address High/Target Address Low. These bytes contain the target address of the node
to send the packet to. This should be the logical node address or the alternate packet address
of the receiving/target node.
bAXD[0:47] Asynchronous Transmit Data Bytes 0 to 47. These bytes contain the packet data to be sent. If
the number of bytes to be sent is not divisible by 4, it is recommended to add filler bytes (gen-
erally 0x00).
RCS.AINT set
Write bPPI,
No bPCTC == 0 ? bit ARX set? No
Write bATAH/bATAL
Read bPCTS
Read data from mARP
Write data to mAXP
Finished
of the other Source Peripheral routing blocks. The available blocks are the Source Ports, the Source Con-
verters, or the other DSP. Therefore, to double the bandwidth through one of the DSPs, one of the other
blocks is disabled, and the DSP uses the disabled block’s Routing addresses by enabling the DSP’s Sec-
ondary Routing Port. Then the DSP can use its Secondary Routing Port through DR1 and DX1.
SPR[5:0] Source Port Routing. The only valid values are listed below.
17h - Source Port Routing Enabled.
3Dh - Source Port Routing Disabled. DSP0 or DSP1 port can use the Source Ports Routing
locations/addresses to double the bandwidth between the Routing bus and the DSP.
FPR[5:0] Source Converter (ADCs and DACs) Routing. The only valid values are listed below.
1Dh - Source Converter Routing Enabled.
3Dh - Source Converter Routing Disabled. DSP0 or DSP1 port can use the Source Converter
Routing locations/addresses to double the bandwidth between the Routing bus and the
DSP.
D0RP[5:0] DSP0 Primary MOST Routing Port Address. The only valid values are listed below.
19h - DSP0 primary MOST Routing Port, DR/DX registers, enabled.
3Dh - DSP0 primary MOST Routing Port disabled. DSP1’s secondary MOST Routing port,
registers DX1/DR1, can use DSP0’s Routing locations/addresses to double the band-
width between the Routing bus and the DSP1.
D0RS[5:0] DSP0 Secondary MOST Routing Port address. The only valid values are listed below.
3Dh - DSP0 secondary MOST Routing Port disabled. To change to any other value, one of the
other routing ports must be disabled first.
17h - DSP0 secondary MOST Routing Port, DR1/DX1 registers, enabled. SPR[5:0] must be set
to 3Dh (both Source Ports disabled).
1Bh - DSP0 secondary MOST Routing Port, DR1/DX1, enabled. D1RP[5:0] must be set to 3Dh
(DSP1’s primary MOST Routing Port disabled).
1Dh - DSP0 secondary MOST Routing Port, DR1/DX1 registers, enabled. FPR[5:0] must be set
to 3Dh (all Source Converter, ADCs and DACs, routing disabled).
D1RP[5:0] DSP1 Primary MOST Routing Port Address. The only valid values are listed below.
1Bh - DSP1 primary MOST Routing Port, DR/DX registers, enabled.
3Dh - DSP1 primary MOST Routing Port disabled. DSP0’s secondary MOST Routing port,
registers DX1/DR1, can use DSP1’s Routing locations/addresses to double the band-
width between the Routing bus and the DSP0.
D1RS[5:0] DSP1 Secondary MOST Routing Port address. The only valid values are listed below.
3Dh - DSP1 secondary MOST Routing Port disabled. To change to any other value, one of the
other routing ports must be disabled first.
17h - DSP1 secondary MOST Routing Port, DR1/DX1 registers, enabled. SPR[5:0] must be set
to 3Dh (both Source Ports disabled).
19h - DSP1 secondary MOST Routing Port, DR1/DX1, enabled. D0RP[5:0] must be set to 3Dh
(DSP0’s primary MOST Routing Port disabled).
1Dh - DSP1 secondary MOST Routing Port, DR1/DX1 registers, enabled. FPR[5:0] must be set
to 3Dh (all Source Converter, ADCs and DACs, routing disabled).
As an example, to double DSP0’s Routing bus bandwidth, one of the following must be disabled:
• DSP1’s Primary Routing bus bandwidth (bD1RP = 3Dh),
• the Source Converter’s Routing bus bandwidth (bFPR = 3Dh), or
• the Source Port’s Routing bus bandwidth (bSPR = 3Dh).
For this example, it is assumed that the Source Converters (ADCs and DACs) are not used; therefore, their
Routing bus bandwidth is disabled (bFPR = 3Dh). Then DSP0’s Secondary MOST Routing Port is enabled
by connecting bD0RS to the Source Converter’s Routing addresses (bD0RS = 1Dh). This changes the
MOST Routing Registers from those listed in Figure 3-2 to those illustrated in Figure 3-13, where the DAC
Routing Table locations are replaced by DSP0’s Secondary MOST Routing Port DR1. Now DSP0 has two
Routing Ports to transfer data from the Routing bus to DSP0, thereby doubling the Routing bandwidth.
Similarly, the MOST Routing Addresses change from those listed in Figure 3-3 to those listed in
Figure 3-14, where the ADC Routing Addresses are replaced by DSP0’s Secondary MOST Routing Port
DX1. This supports the other direction (DSP0 to Routing bus) for the Secondary Routing port, DX1.
48h
DSP1 Transmit Primary
50h
58h
60h
68h
70h
78h
SR1
Shift Register
SR0
Shift Register
bSDC1
82h SR0 SR1
FSY
MRT: 40h, 48h, MRT: 41h, 49h,
Timing 50h, 58h, 51h, 59h,
and
Format Routing Bus 60h, 68h, 61h, 69h,
70h, 78h 71h, 79h
SCK
8Ch SX0 SX1
bSDC2
SX0
Shift Register
SX1
Shift Register
The Global Timer GTR and peripheral routing are synchronized to the SCK signal. Therefore, SCK must be
configured properly for GTR and peripheral routing to operate. If the bSDC1.MOD[1:0] bits are not set to 11
(Source Port enabled), then SCK must be configured as an output, or SCK and FSY can remain inputs as
long as external clocks of the proper frequency are applied.
SR0-SX0 can be configured as an SPDIF transceiver. When configured as the timing-master (bXCR.MTR
set), the SPDIF data can be clocked in synchronously, or the PLL can recover a clock from it. The
CMCS.MX[1:0] bits select the source of the PLL and determine the clocking for the entire chip. As a timing-
slave node, the PLL recovers a clock from the MOST data; therefore, SPDIF data must be clocked in syn-
chronously.
EDG Active edge of SCK. Indicates the edge where inputs are sampled and output data is valid.
0 – SCK falling edge is where inputs are sampled and outputs are valid.
1 – SCK rising edge is where inputs are sampled and outputs are valid.
MUT Mute. When clear, SX0 and SX1 outputs are digitally muted (signal at ground).
When configured as an SPDIF transceiver, FSY is synchronized to the SPDIF data. The edge of FSY that
identifies a left sample, as determined by bSDC1.POL, occurs between the left preamble and the LSB of the
left sample. Data is transferred in bytes starting at this point.
FSY
SCLK Output:
64
48
32
Control Bus
17h-18h
Left L. Pointer R. Pointer Right
Vector RAM RAM Vector
08h-09h
RAM 64 x 25 64 x 25 RAM COM Port
11h 3Fh
2048 x 14 2048 x 18 TCNT
10h-11h
Addr./Ctrl.
Addr./Ctrl.
Addr./Ctrl.
Addr./Ctrl.
Data
Data
Presets 0/1
Data
54h-57h
Timers 0/1
17h
GPA[3:0] D0PCR
DSP0 20h-23h
D0PC
19h ADC Volume
(Gazelle)
50h-53h
GPB[3:0] 18h SPCA
D0PDL 48h
24h-27h Source Port A
DAC Volume
40h-43h
Addr./Ctrl.
DSP1 13h-14h
GTR XMC ACR SPCB
FIFO Port 49h
Global Timer
12h
GTR DFDS DLDS Source Port B
44h-47h
1Ah 15h
Program
RAM
DSP0 I/O Bus
1Ch 4Ch 19h 1Bh
20h - 39h
PWMDR PWM1D DR/DX DR1/DX1
MOST Routing Port MOST Routing Port
External
Data Memory high low high low
PWM DAC
PWM DAC
Routing Bus
PWM1
MA[]
MD[7:0]
control
PWM
17h-18h
Left L. Pointer R. Pointer
Vector RAM RAM Vector
08h-09h
RAM 64 x 25 64 x 25 RAM COM Port
11h 3Fh
2048 x 14 2048 x 18 TCNT
10h-11h
Addr./Ctrl.
Addr./Ctrl.
Addr./Ctrl.
Addr./Ctrl.
Data
Data
Presets 0/1
Data
1Eh COM Port 3Bh-3Eh
54h-57h
Timers 0/1
1Ah
GPC[3:0] D1PCR
DSP1 20h-23h
D1PC
1Ch ADC Volume
GPD[3:0]
(Gazelle)
SPCA
50h-53h
1Bh 48h
D1PDL
24h-27h Source Port A
DAC Volume
Addr./Ctrl.
40h-43h
Data
36h
DSP0 13h-14h
GTR SPCB
FIFO Port 49h
Global Timer
12h
Program GTR DFDS DLDS Source Port B
44h-47h
RAM 1Ah 15h
DR/DX DR1/DX1
MOST Routing Port MOST Routing Port
high low high low
2048 x 26 bits
MRT & MRA: 45h, 4Dh, 44h, 4Ch,
55h, 5Dh, 54h, 5Ch,
65h, 6Dh, 64h, 6Ch,
Routing Bus 75h, 7Dh 74h, 7Ch
4.1 Architecture
The OS8805 DSP core consists of a Program memory, two Vector (data) memories, two Pointer memo-
ries, a program controller, an interrupt controller, two address generation units, and an execution unit. The
Program memory is 26 bits wide and 2048 locations deep. The Vector memory is divided into left and right
sides. The left Vector memory is 14 bits wide and 2048 locations deep and the right Vector memory is
18 bits wide and 2048 locations deep. The Pointer memory is also divided into left and right sides. Both
Pointer memories are 25 bits wide and 64 locations deep
Program memory stores the application program and the Data memories store data and coefficients for
digital signal processing. As illustrated in Figure 4-3, a 26-bit instruction word in Program memory is com-
prised of an 8-bit opcode, followed by two 9-bit operands. The 9-bit operand is further divided into a 3-bit
memory type field (Control), and a 6-bit address field. The left and right Pointer memories store address
pointer values, which consists of an 11-bit address field, a 6-bit update field, and an 8-bit modulo field.
Different functional blocks in the execution unit are provided to support the digital signal processing opera-
tion. A fast single-cycle multiply-and-accumulate supports arithmetic-intensive digital signal processing
algorithms. A bit manipulation unit and a shifter support data packing, extraction and scaling. Two data
address generation units support normal and specialized address modes, and calculate data memory
addresses. Lastly, a DSP I/O data bus interfaces to the on-chip peripherals.
24 17 16 11 10 0
modulo update address Pointer Memories
Left and Right
8 bits 6 bits 11 bits
13 0
data Left Vector Memory
14 bits
17 0
data Right Vector Memory
18 bits
25 24 16 15 8 7 0
Rm left operand right LSBs opcode Program Memory
9 bits 8 bits 8 bits
Rm right operand
9 bits
Figure 4-3: DSP Memory Architecture
The Gazelle DSP employs a four-stage pipeline: a fetch stage, a read pointer stage, a read data stage and
an execute stage. Since long sequences of operations are broken down into smaller portions, higher per-
formance of the processor can be achieved.
The following sections supply a general overview and describe the variations of Gazelle that are specific to
the OS8805. The differences are restricted to memory, I/O registers, condition codes, and interrupts. For
detailed description and programming information on the Gazelle DSP, see the Gazelle User’s Manual.
The loop control logic contains: the start register which stores the 11-bit start address location of the loop,
the end register which stores the 11-bit end address location of the loop, and the count register which
stores the 16-bit repeat value. There are no shadow registers for CNT, STRT, and END. They must be
saved on the general purpose stack to support nested loops and loops within multiple ISR’s.
The count, start, and end registers (and associated logic) enable blocks of program code to be looped and
single word instructions to be repeated without any cycles lost to overhead. If the PC value is equal to the
end address and the count value is greater than zero, the PC will jump to the start address. A “repeat”
instruction is formed by setting the start and end addresses, of a loop instruction, to the same value.
The GTR flags and peripheral routing are synchronized to SCK. If the Source Port is
enabled (bSDC1.MOD[1:0] not set to 11), then SCK must be configured as an output, or SCK
and FSY must have the proper external clocks applied when configured as inputs.
The interrupt vectors are spaced eight words apart starting with the FS8 vector at 008h. The reset vector is
000h. The Vector table is illustrated in Figure 4-4. The interrupt enable register contains the bits to inde-
pendently enable each interrupt (except the COM and FIFO Ports). If an interrupt occurs when it is dis-
abled, it becomes pending until that interrupt is enabled.
The FIFO Port has a unique interrupt vector; however, it shares the interrupt enable and priority settings
with the COM Port interrupt. For the FIFO Port to generate an interrupt, the IER.IECP must be set and the
DFLS.IMSK bit must be clear. The interrupt can be used solely for the FIFO Port by setting the DCS.CIM mask
bit, which masks COM Port interrupts. This allows the COM Port to be polled, while the DSP FIFO port
uses the interrupt line.
When Async. Source Port (SP) 0 is disabled, the GPIO interrupt vector is shared with the GPIO pin and
Async. SP 1. When Async. SP 0 is enabled, the interrupt vector only services the Async. Source Ports as
the GPIO pin is part of SP 0. The GPIO priority affects both the GPIO pin and the Async. Source Ports.
The Host Controller setting DDnCS.TRINT or a TRAP instruction execution can cause the Debug interrupt.
All interrupts, except the GPIO and COM Port, have fixed priority. The GPIO interrupt priority is program-
mable. The GPIO interrupt services the Asynchronous Source Ports, when enabled. When the Async.
Source Port 0 is disabled, the GPIO interrupt is used for GPA0 on DSP0 or GPC0 on DSP1. The COM port
interrupt priority can be programmed as either the second-highest or lowest. When the COM port interrupt
is the second-highest priority, it is higher than any other interrupt including GPIO, but not the Debug inter-
Final Product Data Sheet © Copyright 2001-2003 Oasis SiliconSystems DS8805FP5
Page 146 Restricted Access
0x000 Reset
Reset vector
vector
0x004 Reset vector
8xFs Global
0x008 Reset vector Timer vector
0x00C Reset vector
4xFs Global
0x010 Reset vector Timer vector
0x014 Reset vector
2xFs Global
0x018 Reset vector Timer vector
0x01C Reset vector
0x020 Reset
Fs Global Timer vector
vector
0x024 Reset vector
1/4Fs vector
0x028 Reset Global Timer vector
0x02C Reset vector
0x030 Reset
1/64Fsvector
Timer vector
0x034 Reset vector
0x038 Reset
COM Port vector
vector
0x03C Reset vector
0x040 Reset
GPIO vector
and Async. Source Ports vector
0x044 Reset vector
0x048 Reset
FIFO Port vector
vector
0x04C Reset vector
0x050 Reset
Debugvector
vector
0x054 Reset vector
rupt vector. When the COM port interrupt is the lowest priority, it is lower than any other interrupt including
GPIO. The COM Port interrupt enable and priority are shared with the FIFO Port, however, the interrupt
vector is unique. Interrupt priority should not be changed without first disabling the associated interrupt and
servicing any pending interrupts; otherwise, the wrong interrupt vector could be selected when reenabling
the interrupt. The Debug interrupt vector is non-maskable and has the highest priority.
Interrupt Interrupt Vector Priority
Debug 50h 0 (highest)
8Fs 08h 1
4Fs 10h 2
2Fs 18h 3
Fs 20h 4
4th 28h 5
64th 30h 6
COM and FIFO Port 38h and 48h second-highest or lowest
GPIO pin and Async. Source Ports 40h programmable
Table 4-8: DSP Interrupt Priority
GPOL GPIO Polarity. When clear, the GPIO is rising-edge or active high. This bit provided for back-
wards compatibility. Newer software should use register IPOT to set the polarity of GPA0 for
DSP0 or GPC0 for DSP1. See Figure 4-15.
LEV GPIO Level Sensitive. When clear, GPIO is edge-sensitive. Cleared by writing a zero to
EGPD.GPDA0 for DSP0 and EGPD.GPDC0 for DSP1. This bit provided for backwards compatibil-
ity. Newer software should use register ISOD to set level or edge-sensitive configuration of
GPA0 for DSP0 or GPC0 for DSP1. See Figure 4-15.
PRI[2:0] Priority level of GPIO. Sets the priority at which the GPIO interrupt occurs. The GPIO interrupt
must be disabled (IEGP clear), and any pending interrupt cleared, before changing these bits.
000 – Lower than 7
001 – between 7 and 6
010 – between 6 and 5
011 – between 5 and 4
100 – between 4 and 3
101 – between 3 and 2
110 – between 2 and 1
111 – higher than 1 but lower than 0
CPHI COM Port and FIFO port Priority High. When clear, the COM port and FIFO Port have the low-
est priority. When set, the COM Port and FIFO Port have the second-highest priority. The
COM Port interrupt must be disabled (IECP clear), and any pending interrupt cleared, before
changing this bit.
IEGP Interrupt Enable for GPIO and Async. Source Ports.
When Async. Source Port 0 is enabled, IEGP set enables the interrupt with the status available
in register DTC.
When Async. Source Port 0 is disabled, IEGP allows GPA0 for DSP0 or GPC0 for DSP1 to gen-
erate an interrupt, or Async. Source Port 1. For GPIO, the level/edge and polarity should be
set via the EGPIO IPOT and ISOD registers (see Figure 4-15). The interrupt priority is pro-
grammable through the PRI[2:0] bits.
IE1FS Interrupt Enable at Fs rate. When set, causes an interrupt on the rising-edge of the GTR.FS1 bit,
which vectors to memory location 020h and has a priority of 4.
IE2FS Interrupt Enable at two times Fs. When set, causes an interrupt on the rising-edge of the
GTR.FS2 bit, which vectors to memory location 018h and has a priority of 3.
IE4FS Interrupt Enable at four times Fs. When set, causes an interrupt on the rising-edge of the
GTR.FS4 bit, which vectors to memory location 010h and has a priority of 2.
IE8FS Interrupt Enable at eight times Fs. When set, causes an interrupt on the rising-edge of the
GTR.FS8 bit, which vectors to memory location 008h and has a priority of 1.
The TRAP instruction is a software interrupt and can be used for debugging. The TRAP instruction cannot
be placed in the three instructions after a delay jump, delay jump to subroutine, return, return from inter-
rupt, I/O write to PC or PCI. TRAP can also not be the second word of a two-word instruction. During the
execution phase of the TRAP instruction, the PC is loaded with the Debug interrupt vector and the DSPn
Trap Shadow PC register, on the Control bus, is loaded with the TRAP instruction address location. In addi-
tion, SR is loaded into TSSR. Software must restore SR when returning from a debug interrupt. The first
RETI after a Debug Interrupt copies the Trap Shadow PC (visible on the Control bus) value back to the
PC; however, no other registers are swapped. All interrupts are disabled once the TRAP instruction is exe-
cuted and while in the Debug interrupt service routine. The Host Controller can also cause the Debug inter-
rupt vector to be fetched by setting the DDnCS.TRINT bit.
When an interrupt occurs (other than the Debug Interrupt), the ISPC is loaded with the interrupt vector.
The instruction fetched during the interrupt is not executed. For the first three cycles of an interrupt service
routine, the SPC will specify the program memory location. At the end of the third cycle of the interrupt ser-
vice routine, the PC and ISPC are swapped, and ACCH, ACCL, and SR are swapped with their respective
shadow registers. When returning from an interrupt, the contents of PC are swapped with ISPC, and the
contents of ACCH, ACCL, and SR are swapped with their respective shadow registers.
Interrupts can be long or short. Short interrupts cannot be interrupted. They are either the highest priority
ISR or they are seven or less instructions long. Short interrupts use the shadow registers as a hardware
stack. A short interrupt is exited by executing a return from interrupt instruction (RETI).
TSSR[15:0] Trap Shadow Status Register. The Debug Interrupt is fetched and TSSR is loaded with SR
when a TRAP instruction is executed, or the Host Controller sets DDnCS.TRINT. The program-
mer must restore SR manually when leaving the Debug Interrupt (RETI).
A second set of MOST Routing Ports exist which can double the bandwidth between the DSP and the
Routing bus; however, other Routing bus ports must be disabled to enable this port. This Routing port is
enabled through the MOST Processor registers by first disabling the external Source Ports, the Source
Converters, or the other DSP’s routing port.
1Bh DR1 Second MOST Routing Port Receive Data (read only) DSPs
Bit Label Description Default
Second MOST Routing Port receive data. This routing port is disabled by
17..2 DR1 0000h
default and must be enabled through the MOST Processor before using.
1,0 rsvd Reserved, Write to 0 00
Table 4-19: DR1 Register
1Bh DX1 Second MOST Routing Port Transmit Data (write only) DSPs
Bit Label Description Default
Second MOST Routing Port transmit data. This routing port is disabled by
17..2 DX1 0000h
default and must be enabled through the MOST Processor before using.
1,0 rsvd Reserved, Write to 0 00
Table 4-20: DX1 Register
The STR, RD, and WR flags are read-only by the Controller and DSP. They provide handshaking between
the Controller and the DSP during data transfers. They are set when the Controller accesses the data reg-
ister and are cleared when the DSP accesses the data register. A low-to-high transition of any of these
flags can generate the DSP COM port interrupt. Since the status flags must cross clock boundaries
between the DSP and the Host Controller, a one-cycle delay exists between when the DSP causes a sta-
tus bit to change and when the change can be read from the status register. As an example, if the DSP is
writing the data register to clear the DCS.RD bit, a NOP should be inserted before reading DCS to compen-
sate for the clock-boundary delay. To illustrate the example:
// assumes DCS.RD is set due to Host Controller reading COM register.
dcd = acch; // DSP clears the DCS.RD bit (after one-cycle delay) by writing DCD
nop; // Compensates for the one-cycle delay
acch = dcs; // Read the correct status bits. RD should now be clear.
The DSP alerts the Host Controller that it needs servicing by setting the DCS.INT. A low-to-high transition of
INT can generate the DSP COM Port interrupt in the Controller, if the IER.IEDSPn bit is set. For the DSP,
when DCS.CIM is set, the COM Port interrupt from the Host Controller is masked, which allows the COM
Port to be used in a polling fashion while the DSP FIFO port uses the shared interrupt. When DCS.CIM is
clear, the COM port can generate an interrupt to the DSP, when service is required.
Debug functions in the DSP are supported through two methods. One method is to insert a TRAP instruc-
tion in the DSP Program memory, and the other is when the Host Controller interrupts the DSP using a
non-maskable highest priority DSP debug interrupt, DDnCS.TRINT. In the first case the TRAP is typically put
in the DSP Program memory by the Host Controller, when the external debugger places a break point at
that location in the DSP program. The TRAP instruction could also be a part of the DSP program in this
case. Typically the first time the user puts a break point in the DSP program, the Host Controller interrupts
DSP using the debug interrupt and puts a TRAP instruction at that location.
DEPTH[3:0]Sets the depth of the FIFO for sending data to the other DSP. When the sum of this depth and
the other DSP depth, set by DFFS.DEPTH[3:0], is greater than 15, software handshaking is
required to prevent overwriting of data. Valid values are 0 to 15 (depth of 1 to 16 words).
IMSK When IMSK is clear and IER.IECP is set, an interrupt is generated when either DFFS.STR or
DFFS.WR go high, which indicates that the other DSP has filled the FIFO to a depth of
DFFS.DEPTH[3:0]. The interrupt priority is set by IER.CPHI and the interrupt vector is 048h.
STR Set when the last word is written to the DFSD register, filling the FIFO to the DEPTH[3:0] setting.
When STR is set, an interrupt is generated on the other DSP, if its interrupt mask is clear
(DFFS.IMSK clear) and IER.IECP is set. STR is cleared when the other DSP reads the last word
out of the FIFO (reading its DFRD register the number of times specified by its
DFFS.DEPTH[3:0]).
WR Set when the last word is written to the DFWD register, filling the FIFO to the DEPTH[3:0] set-
ting. When WR is set, an interrupt is generated on the other DSP, if its interrupt mask is clear
(DFFS.IMSK clear) and IER.IECP is set. WR is cleared when the other DSP reads the last word out
of the FIFO (reading its DFRD register the number of times specified by its DFFS.DEPTH[3:0]).
15h DFFS FIFO Port Far Status register (read only) DSPs
Bit Label Description Default
17..8 rsvd Reserved, Write to 0 00h, 00
7..4 DEPTH[3:0] Far end FIFO port Depth 0000
3 IMSK Far end FIFO port Interrupt Mask 0
2 STR Far end FIFO port start status 0
1 WR Far end FIFO port write status 0
0 rsvd Reserved, Write to 0 0
Table 4-26: DFFS Register
DEPTH[3:0]The depth of the FIFO set by the other DSP. This depth defines how many reads are required
to empty the FIFO, thereby clearing DFFS.WR or DFFS.STR which caused the interrupt (if
enabled). Since the DSPs are running off independent clocks, these bits are not reliable if the
other DSP is in the process of writing them.
13h DFSD FIFO Port Start Data register (write only) DSPs
Bit Label Description Default
FIFO Port Start Data. Writing to this register loads a word into the FIFO. If
the write fills the FIFO to the depth indicated by the DFLS.DEPTH[3:0] bits,
17..0 DFSD[17:0] 00h, 00
the DFLS.STR bit is set, and can generate an interrupt to the other DSP if
its FIFO Port interrupt is enabled (DFFS.IMSK clear and IER.IECP set).
Table 4-27: DFSD Register
14h DFWD FIFO Port Write Data register (write only) DSPs
Bit Label Description Default
FIFO Port Write Data. Writing to this register loads a word into the FIFO.
If the write fills the FIFO to the depth indicated by the DFLS.DEPTH[3:0]
17..0 DFWD[17:0] bits, the DFLS.WR bit is set, and can generate an interrupt to the other 00h, 00
DSP if its FIFO Port interrupt is enabled (DFFS.IMSK clear and IER.IECP
set).
Table 4-28: DFWD Register
14h DFRD FIFO Port Read Data register (read only) DSPs
Bit Label Description Default
FIFO Port Read Data. Reading this register removes a word from the
FIFO. When the last word in the FIFO is read (based on
17..0 DFRD[17:0] 00h, 00
DFFS.DEPTH[3:0]), the DFFS.WR or DFFS.STR bit (which ever was high)
will then be cleared.
Table 4-29: DFWD Register
DDIV0[14:0] Divider value for DSP Timer 0. The Timer 0 counter counts up at a 3072xFs rate, and when
the counter reaches the DDIV0[14:0] value, the counter generates a pulse and resets the
3072
counter. To achieve a clock that is a certain ratio to Fs, DDIV0[14:0] = ------------- – 1 . To achieve a
ratio
50 % duty cycle, the DDIV0[14:0] value should be set to half the required ratio (twice the fre-
quency) minus one, and then set DTC.T0D2E, which will divide the result by two. Timer 0 can be
output as the Async Source Port bit clock SCKxn by setting DSnC.CKOE. When used as SCKxn
output, the valid values (assuming DTC.T0D2E is set) are listed in Table 4-36. When Source Port
0 is set for S/PDIF, DDIV0[14:0] must be set to twice the S/PDIF bit clock frequency if DTC.T0D2E
is clear, or four times the bit-clock frequency if DTC.T0D2E is set.
DDIV1[14:0] Divider value for DSP Timer 1. The Timer 1 counter counts up at a rate set by the output of
Timer 0, and when the counter reaches the DDIV1[14:0] value, the counter generates a pulse
and resets the counter. To achieve a clock that is a certain ratio to Fs,
Timer 0 output
DDIV1[14:0] = -------------------------------------- – 1 . To achieve a 50 % duty cycle, the DDIV1[14:0] value should be
ratio
SP1TXI Source Port x1 Transmit Interrupt Status. When set, this bit indicates that Source Port x1’s
Transmit registers DS1X0 - DS1X3 are empty and ready for loading. The rising edge of SP1TXI
generates an interrupt to the GPIO interrupt vector when IER.IEGP is set. SP1TXI is cleared by
writing any one of the DS1X0 - DS1X3 registers or directly clearing SP1TXI.
SP0TXI Source Port x0 Transmit Interrupt Status. When set, this bit indicates that Source Port x0’s
Transmit registers DS0X0 - DS0X3 are empty and ready for loading. The rising edge of SP0TXI
generates an interrupt to the GPIO interrupt vector when IER.IEGP is set. SP0TXI is cleared by
writing any one of the DS0X0 - DS0X3 registers or directly clearing SP0TXI.
SP1RXI Source Port x1 Receive Interrupt Status. When set, this bit indicates that Source Port x1’s
Receive registers DS1R0 - DS1R3 are full and ready to be read. The rising edge of SP1RXI
generates an interrupt to the GPIO interrupt vector when IER.IEGP is set. SP1RXI is cleared by
reading any one of the DS1R0 - DS1R3 registers or directly clearing SP1RXI.
The DSnC.DEL, DSnC.FPOL, and DSnC.EDG bit combinations allow the support of different formats on the
Source Ports.
For the case where SCKxn and FSYxn are outputs, the following tables lists the valid combinations of timer
and Source Port settings to get the desired number of bits per Fs period. When set for more than one inter-
rupt per Fs, the GPIO input bit attached to the particular FSYxn pin indicates when FSYxn changes state.
The DSP can use this data to determine which of the interrupts is occurring during an Fs period. For DSP0,
FSYA0 is connected to GPA1 and, for DSP1, FSYB0 is connected to GPC1.
DS0X3-DS0X0 + DS0R3-DS0R0 +
128 † 000Bh 1 003Fh 1 7Fh
DS1X3-DS1X0 DS1R3-DS1R0
DS0X3-DS0X0 + DS0R3-DS0R0 +
256 † 0005h 1 007Fh 2 7Fh
DS1X3-DS1X0 DS1R3-DS1R0
DS0X3-DS0X0 + DS0R3-DS0R0 +
512 † 0002h 1 00FFh 4 7Fh
DS1X3-DS1X0 DS1R3-DS1R0
* For SCLKxn assumes DTC.T0D2E set, and for FSYxn assumes DTC.T1D2E set. To load the DDIVn registers,
the values listed must be shifted up by four as the register bits are MSB-aligned in the DDIVn registers.
† 128-bit mode, where Source Port x1 registers are cascaded/used; therefore, Source Port x1 is not available.
Table 4-36: Valid Output Clocking Combinations for Async. Source Ports
Each of the two Source Ports are independent from each other. Source Port x0 and Source Port x1 have
their respective DSnC.DEL, DSnC.FPOL, DSnC.EDG, DSnC.CKOE, and DSnC.BPI[6:0] controls. However, if both
Source Ports are configured to have SCKxn and FSYxn as outputs, the SCKxn and FSYxn frequency and the
DSnC.BPI[6:0] bits need to be the set the same for both ports, since there is only one set of timers. When
both sets of Source Port clocks are configured as output, only one interrupt is needed since transmit and
receive are synchronized. In addition, DSnC.CHAIN can chain the SCKxn and FSYxn inputs together for both
Source Ports, to minimize the number of interrupt. When DS1C.CHAIN is set, the SCKx0 and FSYx0 signals
are used for both Source Ports.
The maximum number of bits per interrupt is 128. When the DSnC.BPI[6:0] is set to 7Fh, Source Port x0 and
Source Port x1 are cascaded. When configured to output SCKxn and FSYxn, the timers outputs are used for
both ports. When the Source Port clocking are configured to be inputs, SCKxn and FSYxn control each port
(unless chained). All four interrupts occur simultaneously when in 128-bit mode (Source Ports cascaded).
For received data, each must be cleared by reading at least one register in each of the received data
blocks (DS0R3-DS0R0 and DS1R3-DS1R0 blocks). Likewise, for transmitted data, each must be cleared
by writing at least one register in each of the received data blocks (DS0X3-DS0X0 and DS1X3-DS1X0
blocks). In addition DS0xn block contains the most significant set of data for both transmit and receive
directions
SRx0
SXx1
SRx0
SXx1
In the OS8805, the DTC.SP0TXI, DTC.SP1TXI, DTC.SP0RXI, and DTC.SP1RXI bits are OR’d with the GPIO inter-
rupt. Therefore, when a DSP GPIO interrupt occurs, software must examine the EGPIO and the DTC reg-
isters to determine the source of the interrupt. If a DTC interrupt exists, at the end of the interrupt routine
BOTH the transmit and receive interrupts should be checked and cleared, as either one set could block
further interrupts from occurring.
40h DS0R0 DSP Source Port 0, Receive word 0 (read only) DSPs
Bit Label Description Default
DSP Source Port 0:
In 32-bit mode, second of two words in,
17..2 DS0R[15:0] 0000h
In 64- and 128-bit modes, fourth of four/eight words in,
from pin SRA0 for DSP0 and pin SRB0 for DSP1.
1,0 rsvd Reserved, Write to 0 00
Table 4-37: DS0R0 Register
42h DS0R2 DSP Source Port 0, Receive word 2 (read only) DSPs
Bit Label Description Default
DSP Source Port 0: (not used in 32-bit mode)
17..2 DS0R[47:32] In 64- and 128-bit modes, second of four/eight words in, 0000h
from pin SRA0 for DSP0 and pin SRB0 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-39: DS0R2 Register
43h DS0R3 DSP Source Port 0, Receive word 3 (read only) DSPs
Bit Label Description Default
DSP Source Port 0: (not used in 32-bit mode)
17..2 DS0R[63:48] In 64- and 128-bit modes, first of four/eight words in, 0000h
from pin SRA0 for DSP0 and pin SRB0 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-40: DS0R3 Register
44h DS1R0 DSP Source Port 1, Receive word 0 (read only) DSPs
Bit Label Description Default
DSP Source Port 1:
In 32-bit mode, second of two words in,
17..2 DS1R[15:0] In 64-bit mode, fourth of four words in, 0000h
In 128-bit mode, eighth of eight words in,
from pin SRA1 for DSP0 and pin SRB1 for DSP1.
1,0 rsvd Reserved, Write to 0 00
Table 4-41: DS1R0 Register
45h DS1R1 DSP Source Port 1, Receive word 1 (read only) DSPs
Bit Label Description Default
DSP Source Port 1:
In 32-bit mode, first of two words in,
17..2 DS1R[31:16] In 64-bit mode, third of four words in, 0000h
In 128-bit mode, seventh of eight words in,
from pin SRA1 for DSP0 and pin SRB1 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-42: DS1R1 Register
47h DS1R3 DSP Source Port 1, Receive word 3 (read only) DSPs
Bit Label Description Default
DSP Source Port 1: (not used in 32-bit mode)
In 64-bit mode, first of four words in,
17..2 DS1R[63:48] 0000h
In 128-bit mode, fifth of eight words in,
from pin SRA1 for DSP0 and pin SRB1 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-44: DS1R3 Register
40h DS0X0 DSP Source Port 0, Transmit word 0 (write only) DSPs
Bit Label Description Default
DSP Source Port 0: (not used in 32-bit mode)
17..2 DS0X[15:0] In 64- and 128-bit modes, fourth of four/eight words out, 0000h
from pin SXA0 for DSP0 and pin SXB0 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-45: DS0X0 Register
41h DS0X1 DSP Source Port 0, Transmit word 1 (write only) DSPs
Bit Label Description Default
DSP Source Port 0: (not used in 32-bit mode)
17..2 DS0X[31:16] In 64- and 128-bit modes, third of four/eight words out, 0000h
from pin SXA0 for DSP0 and pin SXB0 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-46: DS0X1 Register
42h DS0X2 DSP Source Port 0, Transmit word 2 (write only) DSPs
Bit Label Description Default
DSP Source Port 0:
In 32-bit mode, second of two words out
17..2 DS0X[47:32] 0000h
In 64- and 128-bit modes, second of four/eight words out,
pin SXA0 for DSP0 and pin SXB0 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-47: DS0X2 Register
43h DS0X3 DSP Source Port 0, Transmit word 3 (write only) DSPs
Bit Label Description Default
DSP Source Port 0:
17..2 DS0X[63:48] In 32-, 64-, and 128-bit modes, first of two/four/eight words out 0000h
from pin SXA0 for DSP0 and pin SXB0 for DSP1.
1,0 rsvd Reserved, Write to 0 00
Table 4-48: DS0X3 Register
45h DS1X1 DSP Source Port 1, Transmit word 1 (write only) DSPs
Bit Label Description Default
DSP Source Port 1: (not used in 32-bit mode)
In 64-bit mode, third of four words out,
17..2 DS1X[31:16] 0000h
In 128-bit mode, seventh of eight words out,
from pin SXA1 for DSP0 and pin SXB1 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-50: DS1X1 Register
46h DS1X2 DSP Source Port 1, Transmit word 2 (write only) DSPs
Bit Label Description Default
DSP Source Port 1:
In 32-bit mode, second of two words out
17..2 DS1X[47:32] In 64-bit mode, second of four words out, 0000h
In 128-bit mode, sixth of eight words out,
from pin SXA1 for DSP0 and pin SXB1 for DSP1
1,0 rsvd Reserved, Write to 0 00
Table 4-51: DS1X2 Register
47h DS1X3 DSP Source Port 1, Transmit word 3 (write only) DSPs
Bit Label Description Default
DSP Source Port 1:
In 32- and 64-bit modes, first of two/four words out,
17..2 DS1X[63:48] 0000h
In 128-bit mode, fifth of eight words out,
from pin SXA1 for DSP0 and pin SXB1 for DSP1.
1,0 rsvd Reserved, Write to 0 00
Table 4-52: DS1X3 Register
BPI[6:0] Number of bits per interrupt. The settings for SCLKx0 and FSYx0 are dependent on the BPI[6:0]
settings. Valid BPI[6:0] values are:
00h - Source Port x0 is disabled. The pins can be used for GPIO. For DSP0 BPI[6:0] set to zero
enables GPIO pins GPA[3:0]. For DSP1 BPI[6:0] set to zero enables pins GPC[3:0].
1Fh - Source Port x0 enabled, with 32 bits per interrupt. Registers DS0X3-DS0X2 and DS0R1-
DS0R0 are used. Not allowed when in S/PDIF mode (SPEN enabled).
3Fh - Source Port x0 enabled, with 64 bits per interrupt. Registers DS0X3-DS0X0 and DS0R3-
DS0R0 are used.
7Fh - Source Port x0 enabled, with 128 bits per interrupt (128-bit mode). DS1C.BPI[6:0] must
equal 7Fh as Source Port x1’s registers are cascaded to get all 128 bits per interrupt. For
transmitting, registers DS0X3- DS0X0 contain the most significant 64 bits and DS1X3-
DS1X0 contain the least significant 64 bits. For receiving, registers DS0R3-DS0R0 con-
tain the most significant and DS1R3-DS1R0 contain the least significant 64 bits.
SPLK S/PDIF Lock status. When Source Port x0 is configured for S/PDIF format (SPEN set), SPLK is
set, indicating in lock, when three consecutive left preambles are correctly received. SPLK is
cleared when two consecutive left preambles are not received correctly.
EDG Active edge of SCKA0 for DSP0 or SCKB0 for DSP1. EDG clear is data valid on the falling edge
and changing on the rising edge. EDG set is data valid on the rising edge and changing on the
falling edge.
DEL Delay from FSYx0 edge. When set, the MSB starts one SCKx0 clock period after FSYx0 edge
(Philips I2S style). When clear, the MSB starts at the FSYx0 edge.
FPOL Polarity of FSYx0. When 0, the start of frame is FSYx0 going low. When FPOL is set, the start of
a frame is FSYx0 going high.
SPEN S/PDIF enabled. When set, Source Port x0 is configured to input and output S/PDIF data.
BPI[6:0]must be set to 64 or 128 bits per interrupt. When SPEN is set, the DSP timers are used
for transmitting the S/PDIF signal; therefore, Source Port x1 is internally forced to use the
same timing (DS1C.CHAIN must be clear), or must use externally derived timing (DS1C.CKOE
clear).
CKOE Clock Output enable. When set, the DSP timers are output on the FSYx0/SCKx0 pins, where
DSP timer 0 goes to the SCKx0 pin and timer 1 goes to the FSYx0 pin. If the CHAIN bit is clear,
then SRx0/SXx0 are clocked using the DSP timers. If CHAIN is set when CKOE is set, SRx0/SXx0
are clocked from SCKx1/FSYx1 and SCKx0/FSYx0 just output the DSP timer clocks. When CKOE
is clear, FSYx0/SCKx0 are inputs.
BPI[6:0] Number of bits per interrupt. The settings for SCLKx1 and FSYx1 are dependent on the BPI[6:0]
settings. Valid BPI[6:0] values are:
00h - Source Port x1 is disabled. The pins can be used for GPIO. For DSP0 BPI[6:0] set to zero
enables GPIO pins GPB[3:0]. For DSP1 BPI[6:0] set to zero enables pins GPD[3:0].
1Fh - Source Port x1 enabled, with 32 bits per interrupt. Registers DS1X3- DS1X2 and
DS1R1-DS1R0 are used.
3Fh - Source Port x1 enabled, with 64 bits per interrupt. Registers DS1X3- DS1X0 and
DS1R3-DS1R1 are used.
7Fh - Source Port x1 enabled, with 128 bits per interrupt. DS0C.BPI[6:0] must equal 7Fh as
Source Port x0’s registers are cascaded to get all 128 bits per interrupt. For transmitting,
DS0X3- DS0X0 and DS1X3-DS1X0 are used as mentioned in the DS0C.BPI[6:0] bit
description. For receiving, DS0R3-DS0R0 and DS1R3-DS1R0 are used.
EDG Active edge of SCKA1 for DSP0 or SCKB1 for DSP1. EDG clear is data valid on the falling edge
and changing on the rising edge. EDG set is data valid on the rising edge and changing on the
falling edge.
DEL Delay from FSYx1 edge. When set, the MSB starts one SCKx1 clock period after FSYx1 edge
(Philips I2S style). When clear, the MSB starts at the FSYx1 edge.
FPOL Polarity of FSYx1. When 0, the start of frame is FSYx1 going low. When FPOL is set, the start of
a frame is FSYx1 going high.
CHAIN Chain FSYx1/SCKx1 with other port (FSYx0/SCKx0). Source Port x0 clocks (FSYx0/SCKx0) are
also the timing source for Source Port x1. Therefore, either the internal DSP timers must be
output on the Source Port x0 clocks, or externally derived clocks must be input on
FSYx0/SCKx0. CHAIN must also be cleared when cascading the two Source Ports in 128-bit
mode (BPI[6:0] = 7Fh).
SPEN S/PDIF enabled. Must only be set when Source Port x0 is configured for 128-bit per interrupt
S/PDIF operation (DS0C.BPI[6:0] set to 7Fh).
The Source Port interrupt is OR’d with the GPIO interrupt; therefore, the Source Port interrupt priority is
configurable via the IER.PRI[2:0] bits. Since the Source Port pins for both DSPs are shared with the Host
Controller, the corresponding interrupt enables for the GPIO function must be disabled when the Source
Ports are in use. For both DSP0 and DSP1, when Source Port x0 is in use, the DSP GPIO interrupt is auto-
matically disabled in hardware since the SCKx0 pin of the Source Port x0 is shared as the EGP0 of the
DSPs, which can triggered the DSP GPIO interrupt. For the Host Controller, when DSP1 is using Source
Port x0, the Host Controller timer interrupts must be disabled in software.
DS0X3-DS0X0 + DS0R3-DS0R0 +
2x 128 256 † 0005h* 1 003Fh 1 7Fh
DS1X3-DS1X0 DS1R3-DS1R0
DS0X3-DS0X0 + DS0R3-DS0R0 +
4x 256 512 † 0002h* 1 007Fh 2 7Fh
DS1X3-DS1X0 DS1R3-DS1R0
DS0X3-DS0X0 + DS0R3-DS0R0 +
8x 512 1024 † 0002h 1 00FFh 4 7Fh
DS1X3-DS1X0 DS1R3-DS1R0
* For Timer 0, assumes DTC.T0D2E set (except the 8x case); and for Timer 1, assumes DTC.T1D2E set.
† 128-bit mode, where Source Port x1 registers are cascaded/used; therefore, Source Port x1 is not available.
When in 128-bit mode, all four interrupts occur and must be cleared by reading or writing the appropriate block of
registers.
Table 4-55: Valid S/PDIF Clocking Combinations for Async. Source Port 0
The first three columns in Table 4-55 use the Source Port in 64-bit per interrupt mode, and the last three
columns use 128-bit per interrupt mode by cascading the two source ports together.
Figure 4-9 illustrates the S/PDIF data stream alignment with respect to the Async. Source Port data
registers for 64-bit per interrupt mode. For the transmitted bit stream on SXx0, the required preambles are
generated automatically. The preamble portion of the data must be zero for proper preamble transmission:
• Left preamble bits: DS0X[7:4] = 0000 (bits 9-6 of register DS0X0).
To force a Block preamble, set bits: DS0X[7:4] = 0110, which is also resync the internal block counter
that generates a Block preamble once every 192 frames.
• Right preamble bits: DS0X[39:36] = 0000 (bits 9-6 of register DS0X2).
For the received bit stream on SRx0, the left preamble indicates when a new CS block starts. The preamble
portion of the received data is:
• Left preamble bits: DS0R[7:4] (bits 9-6 of register DS0R0) =
1010 - left preamble
0110 - block preamble
• Right preamble bits: DS0R[39:36] = 0110 (bits 9-6 of register DS0R2).
Figure 4-10 illustrates the S/PDIF data stream alignment with respect to the Async. Source Port data
registers for 128-bit per interrupt mode, with the two Source Ports cascaded. For the transmitted bit stream
on SXx0, the four preamble portions of the data must be zero for proper preamble transmission:
• Left preamble bits: DS0X[7:4] = DS1X[7:4] = 0000 (bits 9-6 of registers DS0X0 and DS1X0).
To force a Block preamble, set the bits to 0110, which is also resync the internal block counter.
• Right preamble bits: DS0X[39:36] = DS0X[39:36] = 0000 (bits 9-6 of registers DS0X2 and DS1X2).
For the received bit stream on SRx0, the left preamble indicates when a new CS block starts. The preamble
portion of the received data is:
• Left preamble bits: DS0R[7:4] or DS1R[7:4] (bits 9-6 of register DS0R0 or DS1R0) =
1010 - left preamble
0110 - block preamble
• Right preamble bits: DS0R[39:36] = DS1R[39:36] = 0110 (bits 9-6 of register DS0R2 and DS1R2).
Restricted Access
X Left SF Y Right SF Z Left SF Y Right SF X Left SF Y Right SF X
bit-reversed
LSB MSB PCUV MSB PCUV
LSB
MOST System On Chip
Page 171
DS8805FP5
Downloaded from Arrow.com.
Page 172
OS8805
bit-reversed bit-reversed
LSB MSB PCUV LSB MSB PCUV LSB MSB PCUV LSB MSB PCUV
Figure 4-10: DSP Async. Source Port S/PDIF Alignment - 128 Bits/Interrupt
DS8805FP5
Restricted Access
OS8805 MOST System On Chip
When transmitting complete S/PDIF data (including the preambles) to the Source Port SX0, the Left and
Right preambles must be set to 0000 and the Block preamble must be set to 0001. These values also hold
true when transmitting complete S/PDIF data across the MOST Network to an OS8104 or OS8804 Source
Port. When receiving complete S/PDIF data from any of these sources, the preambles must be converted
to the values listed above for transmitting out the DSP’s Asynchronous Source Port.
When transmitting and receiving S/PDIF data, the interrupts for each direction cannot be aligned;
therefore, independent ISRs are needed for transmit and receive.
Control Bus
MA[9:0] 29h
XMC
MRAS
MCAS
MRD External
Data
MWR Memory
(1 M x 4) MD[3:0]
MA16
Control Bus
SA15 29h
MA[14:0] XMC
MCS
External
MRD Data
MWR Memory
External SRAM
DSP0 I/O Bus
Controller DSP0
(32 k x 4)
MD[7:4]
MD[3:0]
(32 k x 4)
memory interface. If GCTL.EDMEN is clear, the interface can be used as EGPIO by the Host Controller. The
XMC and GCTL registers reside on the Control bus and must be configured by the Host Controller. See
the XMC register in the Host Controller section for more information on configuring the external memory port
for DSP0 data memory.
The DSP accesses the external data memory port through a set of 16-bit I/O registers. The port communi-
cates with external memory through either a 4- or 8-bit data bus. The external data memory port divides 8-
or 16-bit data from the DSP into bytes or nibbles before writing to external memory. Likewise, the port
assembles 8- or 16-bit words for the DSP from byte or nibble data from external memory. See Figure 2-33
on page 95 and Figure 2-34 on page 96, for examples of how external memory is addressed.
Up to 512k 16-bit words can be stored in two external DRAM’s and up to 64k 16-bit words can be stored in
external SRAM’s. External DRAM can be automatically refreshed. The refresh and the read/write timing
can be adjusted.
DSP0
(Gazelle)
Data
Σ increment
Data Split
Merge
Physical Address
Generator Control and Timing
MA[9:0]
MD[7:4]
MD[3:0]
(SRAM)
MA[]
(DRAM)
MRD
(SRAM)
MCS
(DRAM)
MCAS
MRAS
MWR
An access to external memory can take many DSP0 instruction cycles to complete, and can be interrupted
by refresh cycles when using DRAM. Once an access is started (read or write), trying to read the results
(read from 28h, 29h, 2Ah, 2Ch, 2Dh, or 2Eh) or start a new access (write to 21h, 22h, 25h, 26h, 34h, 35h,
36h, or 37h) will stall the DSP until the memory cycle completes. Once stalled, the DSP cannot be inter-
rupted. Table 4-64 indicates the number of DSP cycles required to complete a transaction once the exe-
cute cycle of the instruction that caused the operation occurs. Two cycles are needed to calculate the
address, and two cycles are needed at the end of the operation (both included in the table below). There-
2Ah RD0++ Read 0, Start Read with Post Increment (read only) DSP0
Bit Label Description Default
RD0++ contains data from a previous read operation, a new read
17..2 D[15:0] 0000h
operation is started, and B0AD[19:0] is post-incremented.
1,0 rsvd Reserved, Write to 0 00
Table 4-73: RD0++ Register
2Eh RD1++ Read 1, Start Read with Post Increment (read only) DSP0
Bit Label Description Default
RD1++ contains data from a previous read operation, a new read
17..2 D[15:0] 0000h
operation is started, and B1AD[19:0] is post-incremented.
1,0 rsvd Reserved, Write to 0 00
Table 4-76: RD1++ Register
35h WR0++ Write 0, Start Write with Post Increment (write only) DSP0
Bit Label Description Default
Writing WR0++ starts a write operation using the base-0 registers with
17..2 D[15:0] 0000h
the data in WD0 and then post-increments B0AD[19:0].
1,0 rsvd Reserved, Write to 0 00
Table 4-82: WR0++ Register
37h WR1++ Write 1, Start Write with Post Increment (write only) DSP0
Bit Label Description Default
Writing WR1++ starts a write operation using the base-1 registers with
17..2 D[15:0] 0000h
the data in WD1, and then post-increments B1AD[19:0].
1,0 rsvd Reserved, Write to 0 00
Table 4-84: WR1++ Register
When DSP0 writes to either Write register (WR0+- or WR0++), the data stored in WD0[15:0] is stored in
external memory using the address generated by the Base 0, Offset 0, and Modulo 0 registers. Writing to
WR1++ initiates the same procedure as writing to WR0+- except B0AD[19:0] is post incremented by one.
Writing to WR1+- or WR1++ initiates the same procedure as writing to WR0+- or WR0++, except the
Base 1, Offset 1, and Modulo 1 registers are used.
Since the processor will be waiting between writes, this time could be filled with useful instructions. The fol-
lowing is an example of how to read a block of data.
bsl1 = low_base_value; // set low base address
bsh1 = high_base_value; // set high base address
mod1 = modulo_value; // set modulo
off1++ = offset_value; // set offset, start read, and post increment
data0 = rd1++; // read 1st word, start next read, and post increment
data1 = rd1++; // read 2nd word, start next read, and post increment
data2 = rd1++; // read 3rd word, start next read, and post increment
data3 = rd1; // read last word
External memory can be used to create circular delay buffers. Each sample period a new data word over-
writes the oldest sample in the buffer. Each sample period many samples with fixed delays are read from
the buffer. The following is an example.
// during initialization set base and modulo
bsl1 = low_base_value; // set low base address
bsh1 = high_base_value; // set high base address
mod1 = modulo_value; // set modulo
// pop registers
pop rd1;
pop mod1;
pop off1;
pop bsh1;
pop bsl1;
reti;
If an interrupt occurs while the processor is waiting for a read or write to complete, control immediately
jumps the ISR. After an ISR completes, the processor will not return to a wait state. The ISR must be long
enough to ensure that a read or write, that started before the interrupt, will complete by the time the ISR
finishes.
Control Bus
DSP0
4Ah 28h
Low-Pass Filter ACR2 ACR
program
1Ch
PWMD
8xFs
PWM1 DAC
PWM1D
4Ch
3rd-order Noise PWM External
PWM1
Shaper Modulator Analog
Filter
GPDxn General Purpose IO bits for the GPxn pins. These bits are GPIO when DSnC.BPI[6:0] = 000000.
The Host Controller can also control these pins and override the DSP for output control.
GPDA0 can generate an interrupt if enabled (IER.IEGP set).
When configured as an output (EDD.GPOxn set), the value written to this bit is driven out the
corresponding pin when the output is enabled (ISOD.GPSDxn clear), based on output driver
type (IPOT.GPPTxn). Data read is directly from the pin.
When configured as an input (EDD.GPOxn clear), the polarity is controlled by IPOT.GPPTxn and
the data can be sticky (ISOD.GPSDxn set) or not. When sticky, the register bit is cleared by
writing it to 0 (assuming the pin is inactive).
GPOxn Output Enable for corresponding GPxn pin. When GPxn is configured as a GPIO and the corre-
sponding Host Controller DDR bit is clear, this corresponding bit determines whether the pin is
a general purpose input or output. The Host Controller can override the DSP for output control
through its DDR register.
0 - Corresponding GPxn pin is an input.
IPOT.GPPTxn determines input polarity.
ISOD.GPSDxn determines whether the input is sticky or not.
1 - Corresponding GPxn pin is an output.
IPOT.GPPTxn determines output driver type (CMOS or open-drain).
ISOD.GPSDxn is an output disable/enable.
GPPTxn Input polarity or output driver type for corresponding GPxn pin when configured as a GPIO.
When GPxn pin is configured as an input (EDD.GPOxn clear), this bit sets the polarity:
0 - Active high input (non-inverting) or high-pulse capture, if sticky
1 - Active low input (inverting) or low-pulse capture, if sticky
When GPxn pin is configured as an output for DSP0 (EDD.GPOxn set) or the Host Controller
(EDD1.GPOxn set on rev. G or greater), this bit sets the output driver type:
0 - Open-drain output (only driven low)
1 - CMOS output (driven both high and low)
GPSDxn Input sticky or output disable for corresponding GPxn pin when configured as a GPIO.
When GPxn pin is configured as an input (EDD.GPOxn clear), GPSDxn sets sticky or not.
0 - EGPD.GPDxn reflects the GPxn pin, after polarity (IPOT.GPPTxn).
1 - EGPD.GPDxn is sticky and captures a high or low pulse (based on IPOT.GPPTxn)
on GPxn. Once set, cleared by writing EGPD.GPDxn to zero when input pin is in the
inactive state.
When GPxn pin is configured as an output (EDD.GPOxn set), this bit controls output enable:
0 - The GPxn pin is enabled and driven, based on IPOT.GPPTxn.
1 - The GPxn pin is disabled, high impedance.
Restricted Access
GPIO.GPxDn (Host Controller)
(Host Controller write) DDR.GPxOEn
IER.IEGP
0 - interrupt disabled Write GPDxn to zero
1 - Interrupt enabled
MOST System On Chip
Page 187
DS8805FP5
OS8805 MOST System On Chip
4.6.4 DSP1 EGPIO
The GPC[3:0] and GPD[3:0] are shared between the Host Controller and the DSP1. The DSP has its own
set of registers which control the functionality of these pins and they are implemented as extended GPIOs.
On revision G or greater, when the DDR bit of the Host Controller of the corresponding GPIO pin is low, the
DSP has control of the direction of the GPIO pin. When the GPIO is configured as an output by either the
DSP or the Host Controller, the IPOT register controls the output type (open-drain or driven in both direc-
tions).
The GPIO have the alternate function of Asynchronous Source Ports. Each set of four GPIO are grouped
and can be an Asynchronous Source Port, or GPIO. If DSnC.BPI[6:0] is set to all zeros, then the Asynchro-
nous Source Port is disabled and the four pins may be used as GPIO. Therefore, DS0C.BPI[6:0] enables
Source Port B0 or GPC[3:0], and DS1C.BPI[6:0] enables Source Port B1 or GPD[3:0].
In the event that both the DDR of the corresponding pin of the Host Controller and the DSP are set, the
Host Controller has priority of the GPIO pin over the DSP. In this case, the data of the Host Controller is
presented on the GPIO pin. DSP1’s Asynchronous Source Ports have higher priority than EGPIO logic
(either the Host Controller’s or the DSPs).
GPDxn General Purpose IO bits for the GPxn pins. These bits are GPIO when DSnC.BPI[6:0] = 000000.
The Host Controller can also control these pins and override the DSP for output control.
GPDC0 can generate an interrupt if enabled (IER.IEGP set).
When configured as an output (EDD.GPOxn set), the value written to this bit is driven out the
corresponding pin when the output is enabled (ISOD.GPSDxn clear), based on output driver
type (IPOT.GPPTxn). Data read is directly from the pin.
When configured as an input (EDD.GPOxn clear), the polarity is controlled by the IPOT.GPPTxn bit
and the data can be sticky (ISOD.GPSDxn set) or not. When sticky, the register bit is cleared
by writing it to 0 (assuming the pin is inactive).
Common-mode rejection can be improved by connecting 0.1 µF and 1 µF bypass capacitors between the
VREFS pin and AGND, and setting the ADACn.SEDE bit for the particular DAC. Although these capacitors
help in differential mode, significant dynamic range improvements are seen when using the DACs in a sin-
gle-ended fashion.
GMIC
MOST Port
high low
MRT AR: 67h 66h
Routing Bus
GMPX
4th-Order 96xFs Low-pass and
Cascaded Decimation Filter
Delta-Sigma
270 Ω MPX
Input Gain Modulator 4xFs
270 pF 0 to +26 dB MOST Port
high low
MRT AR: 1 - 4Fh 4Eh
2 - 5Fh 5Eh
3 - 6Fh 6Eh
4 - 7Fh 7Eh
Routing Bus
470 Ω AD0L
Control Bus
470 pF
DSP1 I/O Bus
22h
23h
28h
57h
56h
90 %
VDDD
trspw
RST
tcpsrs tcphrs
Configuration
valid
Pins
Figure 6-1: Reset and Configuration Pins
tapwd tpwmx
RX
tpwmn
50 % 50 %
(Bit Period) trxbp
TX
tjm, tjs
PCS
tpas tpah
tpmws tpmwh
trpds trpdh
data data data
MD[7:0] valid valid valid
Read Operation
twpds twpdh
MD[7:0] valid write data valid write data valid write data
Write Operation
PCS
tpas tpah
tpmws tpmwh
trpds trpdh
data data
MD[7:0] valid valid
Read Operation
twpds twpdh
trrasl
MRAS
trcslrsl
trcasl
MCAS
MD[7:0]
MRD and
MWR
Figure 6-6: DRAM Refresh (CAS-before-RAS) Timing (XMC.MMS = 1)
MCAS
trascas tcash
tmdrs tmdrh
tmdrs tmdrh
Write Operation
MRD or
MWR
tmcsl tmcsh
tmars
tmarh
MCS
MRD
tmdrs
tmrldv tmavdv
tmdrh
MWR
tmcswh
tmdws tmdwh tmdws
tfsyv
FSY
(internal)
tfsys tfsyh
FSY
(external)
tsckl tsckh
SCK
tsrs tsrh
SR[1:0]
tsxv
SX[1:0]
tdfsys tdfsyh
FSYxn
(external)
tdsckl tdsckh
SCKxn
tdsrs tdsrh
SRxn
tdsxv
SXxn
TJ = -40 to 150 °C; VDDD,VDDA = 3.3 V ±5 %; GNDD,GNDA = 0.0 V; PLL locked at 44.1 kHz;
Load Capacitance = 30 pF
GSPI Master mode (CPS.CPMM/DCPS.DPMM set)
Slow Speed Fast Speed
Parameter
Symbol CPS/DCPS.FAST clear CPS/DCPS.FAST set Unit
Min Max Min Max
SCLK frequency (Note 2) fscl 100 350 kHz
SCLK low time tscll 4 1 µs
SCLK high time tsclh 4 1 µs
SCLK low to CS high setup tsklcsh 1 1 µs
CS low to SCLK rise (Note 1) tcss 1 1 µs
CS low to SDOUT valid tcdv 250 250 ns
CS high time tcht 1 0.25 µs
SDIN valid to SCLK rising (Note 1) tsds 500 250 ns
SDIN hold from SCLK rising (Note 1) tsdh 500 250 ns
SCLK falling to SDOUT valid (Note 1) tsdv 1 0.5 µs
CS high to SDOUT Hi-Z tsdz 1 1 µs
Notes:
1. In GSPI mode the SCLK polarity and phase are programmable. The parameters and are illustrated for GSPI
mode with CPS.CPOL = CPS.CPHA = 0. See Section 2.3.3.3 on page 60 for more information.
2. The typical clock frequency when FAST is clear is 88.2 kHz when Fs = 44.1 kHz, and 96 kHz when Fs = 48 kHz.
When FAST is set, the typical clock frequency is 295.8 kHz when Fs= 44.1 khz, and 310.6 kHz when Fs = 48 kHz.
CS,
DCS
tcht
tcss tsclh tscll
tsklcsh
tsklcsl
SCLK,
DSCLK
tsds tsdh
SDOUT,
data valid data valid data valid
DSDOUT
TJ = -40 to 150 °C; VDDD, VDDA = 3.3 V ±5 %; GNDD,GNDA = 0.0 V; PLL locked at 44.1 kHz.
Master mode (CPS.CPMM/DCPS.DPMM set)
Slow Speed Fast Speed
Parameter
Symbol CPS/DCPS.FAST clear CPS/DCPS.FAST set Unit
Min Max Min Max
SCL frequency (Note 1) fscl 100 350 kHz
Bus free between transmissions
tbuf 4.7 1.3 µs
(SDA high time between start and stop)
Start condition hold time
tstah 4 0.6 µs
(SDA falling to SCL falling)
SCL low tscll 4.7 1.3 µs
SCL high tsclh 4 0.6 µs
SDA input hold from SCL falling tsdah 0 0 µs
SDA input valid to SCL rising tsdas 500 300 ns
Repeat Start condition setup time tstas 4.7 0.6 µs
SDA and SCL rise time tr 1 0.3 µs
SDA and SCL fall time tf 300 300 ns
Stop condition setup time
tstps 4 0.6 µs
(SCL rising to SDA rising)
Note:
1. The typical clock frequency when FAST is clear is 88.2 kHz when Fs = 44.1 kHz, and 96 kHz when Fs = 48 kHz.
When FAST is set, the typical clock frequency is 295.8 kHz when Fs= 44.1 khz, and 310.6 kHz when Fs = 48 kHz.
tscll tsclh
SCL,
DSCL
tstps tbuf tstah tsdas tsdah tstas
tuckh tuckl
UCKn
tucrxs tucrxh
tuctxv tuctxv
ESD
ESD
ESD
VREF
Figure 7-2: Pin-equivalent for Analog Audio Input pin - AAI
Internal signal
Analog Output Pads
VREF
ESD
Output enable
Figure 7-6: Pin-equivalent for Digital Output with high-Z control - DOUTZ
Output Pad
Internal signal
Output enable
ESD
Internal signal
I/O Pad
Internal signal
ESD
Internal signal
7.3 Pinout
The package designators are:
• lll - Lot Sequence Code
• r - Chip Revision Letter (also see MMPC.REV[3:0])
• yy - last two digits of Assembly Year
• ww - Assembly Work Week
XME/PCS/SA15
MA14/MCAS
MRAS/MCS
MWR/PMW
MRD/PA15
GNDD6
GNDD5
GNDS8
GNDS7
GNDS6
GNDS5
GNDS4
VDDD5
VDDD4
MA10
MA11
MA12
MA13
MD0
MD1
MD2
MD3
MA6
MA7
MA8
MA9
128
127
126
125
124
123
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
MA5 1 102 MD4
MA4 2 101 MD5
GNDS0 3 100 GNDS3
GNDD0 4 99 DAD0/DSDIN/URX1
VDDD0 5 98 PWM0
MA3 6 97 MD6
MA2 7 96 MD7
MA1 8 95 SCKA0
MA0 9 94 FSYA0
GNDD1 10 93 SXA0
VDDD1 11 92 GNDD4
AD0/SDIN/URX0 12 91 SRA0
AD1/CS/UFR0 13 90 SCKA1
lllryyww
SCL/SCLK/UCK0 14 89 FSYA1
SDA/SDOUT/UTX0 15 88 SXA1
GNDD7 16 87 SRA1
OS8805AQ
MA16 17 86 SCKB0
SX0 18 85 FSYB0
SX1 19 84 TMR0/SXB0
GNDD2 20 83 GNDD3
VDDD2 21 82 VDDD3
FSY 22 81 TMR1/SRB0
SCK 23 80 INT0/SCKB1
SR0 24 79 INT1/FSYB1
SR1 25 78 INT2/SXB1
TX 26 77 INT3/SRB1
RX 27 76 XTI
RMCK 28 75 XTO
ERR 29 74 DSDA/DSDOUT/UTX1
BOOT/PWM1 30 73 DSCL/DSCLK/UCK1
DCS/UFR1 31 72 TST1
RST 32 71 TST0
GNDA0 33 70 GNDA6
GNDA1 34 69 DA0
FLT 35 68 DA0B
GNDS1 36 67 GNDS2
VDDA0 37 66 DA1
POT7 38 65 DA1B
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
MIC
MPX
POT6
POT5
POT4
POT3
POT2
POT1
POT0
AD2R
AD1R
AD0R
VREFS
DA3B
DA2B
AD2L
VREF
AD1L
AD0L
GNDA2
VDDA1
GNDA4
VDDA2
GNDA5
DA3
DA2
GNDD6
GNDD5
GNDS8
GNDS7
GNDS6
GNDS5
GNDS4
VDDD5
VDDD4
IOE10
IOE11
IOE12
IOE13
IOE14
IOE15
IOF10
IOE6
IOE7
IOE8
IOE9
IOF9
IOF8
IOF0
IOF1
IOF2
IOF3
128
127
126
125
124
123
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
IOE5 1 102 IOF4
IOE4 2 101 IOF5
GNDS0 3 100 GNDS3
GNDD0 4 99 IOB2
VDDD0 5 98 IOD0
IOE3 6 97 IOF6
IOE2 7 96 IOF7
IOE1 8 95 GPA0
IOE0 9 94 GPA1
GNDD1 10 93 GPA2
VDDD1 11 92 GNDD4
IOA2 12 91 GPA3
IOA3 13 90 GPB0
lllryyww
IOA0 14 89 GPB1
IOA1 15 OS8805AQ 88 GPB2
GNDD7 16 87 GPB3
IOD1 17 86 GPC0
IOC2 18 85 GPC1
IOC4 19 84 GPC2
GNDD2 20 83 GNDD3
VDDD2 21 82 VDDD3
IOC1 22 81 GPC3
IOC0 23 80 GPD0
IOC3 24 79 GPD1
IOC5 25 78 GPD2
IOG2 26 77 GPD3
IOG3 27 76 XTI
IOG0 28 75 XTO
IOG1 29 74 IOB1
IOG4 30 73 IOB0
IOB3 31 72 TST1
RST 32 71 TST0
GNDA0 33 70 GNDA6
GNDA1 34 69 DA0
FLT 35 68 DA0B
GNDS1 36 67 GNDS2
VDDA0 37 66 DA1
POT7 38 65 DA1B
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
VREF
VREFS
MPX
VDDA1
AD2L
AD1L
VDDA2
AD0L
DA3B
DA2B
POT6
POT5
POT4
POT3
POT2
POT1
POT0
MIC
AD2R
AD1R
AD0R
GNDA2
GNDA4
GNDA5
DA3
DA2
A1 B
0.076 mm
Seating Plane
A2 0.25 mm
Gage Plane
L
K
L1
D
D1
D2 Pin 1
1 Identification
38
39
128
E E1 E2
103
64
65 102
e
A A1 A2 B c D D1 D2 e E E1 E2 L L1 K
Min 0.25 2.60 0.17 0.11 23.0 19.9 17.0 13.9 0.78 0°
Typ 0.33 2.70 0.22 23.2 20.0 18.5 0.50 17.2 14.0 12.5 0.88 1.60 3.5 °
Max 3.40 0.50 2.80 0.27 0.17 23.4 20.1 17.4 14.1 1.03 7°
Table 7-2: Package Outline Dimensions (mm)
A1 B
0.081 mm
Seating Plane
D A2 0.25 mm
Gage Plane
D1
D2 Pin 1
1 Identification
38 L
K
L1
39
128
Top Side
E E1 E2
103
64
65 102
10.145
Exposed Paddle
8.636 Centered on bottom
Bottom Side
10.1455
6.352
A A1 A2 B c D D1 D2 e E E1 E2 L L1 K
Min 0.05 1.35 0.19 21.80 19.90 15.80 13.90 0.50 0°
Typ 1.40 22.00 20.00 18.5 0.50 16.00 14.00 12.5 0.60 1.00
Max 1.60 0.15 1.45 0.27 22.20 20.10 16.20 14.10 0.75 7°
Table 7-3: Package Outline Dimensions (mm)
GNDD1 GNDA0
VDDD2
Hold
0.1 µ F
VDDA1
from controller 0.1 µ F
GNDD2
STATUS to controller GNDA2
FOR
DATA RX VDDA2
33 -100 Ω
MOST 0.1 µ F
OS8805
Short as possible
Network GNDA5
33 - 100 Ω VREF
10 µ F
FOX DATA TX
0.1 µ F
GNDA4
VDDD3
0.1 µ F 2.2 k Ω
GNDD3 FLT
†
0.1 µ F
VDDD4 GNDA1
0.1 µ F GNDS1
GNDS4
VREFS
VDDD5 1 µF
0.1 µ F 0.1 µ F
GNDD5 GNDA6
GNDS5 GNDS2
The FLT, VREFS, and VREF components should be placed as close as possible to the GNDAn pins to mini-
mize loop currents. To minimize vibration and shock effects on PLL locking, a metal-film capacitor (such as
Panasonic ECPU 16VDC / 0805 / ECPU1C104MA5) should be connected to the FLT pin through the series resis-
tor. Ceramic capacitors are more sensitive to shock and could cause unlock events in high-vibration envi-
ronments. In addition, the FLT pin is a high-impedance node; therefore, leakage current should be kept
below 1 µA, or average pulse-width distortion tolerance could be adversely affected. Conformal coating is
recommended for systems where condensation can occur. The analog and digital ground planes, if sepa-
rated, should be connected at one point on the board, under the part.
The distance between the Fiber Optic Receiver (FOR) unit and the OS8805 should be as short as possible
to minimize capacitance on the DATA line. Minimizing capacitance will shorten transition times out of the
FOR, thereby minimizing pulse width distortion and jitter.
Similar to the Power Supply Overview Diagram, Figure 8-1, the FOR controls power to the OS8805 and the
rest of the node. The MIC5236 regulator supplies the 5 V continuous power (5Vc) to the FOR as well as
the power-up circuit for the rest of the system. The power-up circuit controls the power supply for a 5 V
supply (5Vs), the OS8805 3 V supply (3Vs), and a 12 V switched supply (12Vs) that can be used for high-
powered peripherals. The 5 V switched supply powers the FOX as well as any analog circuitry that cannot
run from the 3 V supply. The time between the FOR STATUS line going low and the 3Vs/5Vs power being
stable should be well within tWakeUp time (currently 6 ms), as listed in the MOST Spec. (V2.1, Section 3.8)
for light at FOR input to light out at FOX output time.
The IOxn pin, selected for the HOLD signal, must power up as an input. Since the OS8805 IOxn pins are
5 V tolerant (even with no applied power), no extra protection is needed while the OS8805 is powered
down. Once the part is powered up, the IOxn should be configured as a digital output (CMOS-drive) and
driven high to "hold" the power-supply from turning off when light disappears at the FOR. The bCM2.NNAC
bit indicates when Network activity is lost, and should be periodically checked during normal operation.
When bCM2.NNAC goes high, the node should perform an orderly shut-down and then drive HOLD low to
allow the entire node to power-down.
The POTn input uses the DC ADC to measure the 12 V supply and react appropriately to the MOST-
defined levels (MOST Spec. V2.1, Section 4.7):
• Normal Operation
• Super Voltage
• Critical Voltage
• Low Voltage
The reaction to different power levels varies with the application but could include powering down power-
amps or motors in over- or under-voltage conditions to protect the devices.
The OS8805 internal Watchdog timer supports the Watchdog requirements of the MOST Spec (V2.1,
Section 4.6). If the Watchdog timer register, WDT, isn’t written before the timer counts down to 0, then the
OS8805 is reset, causing the MOST Transceiver to switch to all-bypass mode (bXCR.ABY clear). In addi-
tion, assuming the IOxn pin selected is an input at power-up, the Watchdog reset will release the HOLD
signal.
The RST pin illustrated is controlled by a MAX821 Voltage monitor. This circuit is only required if the node
must power up and initialize without any external stimulus on the RX or one of the GPAn pins. When the
OS8805 initially powers up, the CMCS.PD bit will be set by the internal Voltage monitor circuit. The part will
remain in power-down mode until two transitions occur on the RX or GPAn pins, as configured in the RGEN
register. If the node must do some initialization at power-up, a transition on the RST line will clear CMCS.PD
causing the OS8805 to power up. The MAX821 illustrated has a nominal threshold of 2.93 V. The SRT pin
Final Product Data Sheet © Copyright 2001-2003 Oasis SiliconSystems DS8805FP5
Page 236 Restricted Access
Restricted Access
EN FBK VIN VOUT
MIC4576 MIC29150
33 µH 10 µF
VIN
-5.0BT VOUT -3.3BT
VDDD1 VDDA0
RST
POTn
5Vc GNDD1 GNDA0
VDDD2 Host VDDA1
MMUN2111LT Controller 128k Flash
Port
Port
VIN VOUT GNDD2 GNDA2
DC
Memory
Debug
Control
ADC
(Cougar µC)
MIC5236 1 µF VDDD3 VDDA2
EN -5.0BM
GNDD3 GNDA5
15 kΩ BC848C
VDDD4 4k Data
Memory
Clock Manager OS8805
GNDS4
10 µH VREF 10 µF
47 kΩ
9 V - 16 V VDDD5
Async. DAC0 GNDA4
GNDD5 2k Program Memory
GNDS5
Source Port A
6KA24 470 µF
15 kΩ
DSP1
ground VDDD0 PWM0 DAC 2kx2 Data Memories DAC1
GNDD0 PWM1 DAC + 64x2 Pointers 2.2 kΩ
DAC2 FLT
GNDS0
GNDA1
MOST System On Chip
2k Program Memory
DAC3 GNDS1
Async.
(0 = Light on) DSP0
1 HOLD Source Port B
3 IOxn (D
2kx2 Data Memories
STATUS OUT
)
+ 64x2 Pointers Audio
10 µF FOR 4 50 - 100 Ω
RXOUT RX ADC L
Short as possible VREFS
2 MOST Network Audio
3Vs Transceiver MOST Processor ADC R GNDA6
MMUN2111LT 1 µF
5Vs 15 kΩ Mic. GNDS2
-3dB ADC
27 kΩ IOxn (DOUTD )
3 MPX
4 27 kΩ Source Ports
BIAS TX ADC
GNDD6
GNDD7
GNDD4
GNDS7
GNDS8
GNDS6
GNDS3
10 µF FOX MMUN2211LT
TXIN
1 under part
50 - 100 Ω
2
unmarked caps are 0.1 µF
Page 237
DS8805FP5
OS8805 MOST System On Chip
is set for a 1 ms RST low time. The RST low time should be small to allow the maximum amount of software
initialize time (and power-supply ramp time) to meet the FOR light-on to bXCR.ABY set (tWaitNodes in the
MOST Spec. V2.1, Section 3.8 - currently 100 ms) time period.
The Switch-To-Power circuitry is not included since it varies with OEMs. The OEM should be contacted to
determine the proper method to support Switch-To-Power. The Switch-To-Power detector is a diagnostic
mode used to force the node into ring-break diagnostics (MOST Spec. V2.1, Section 3.2.2.4). If the ring is
broken, then light will not be received at the node immediately down-stream from the break. No light
causes the node to power-down. When diagnostics needs to be performed on the broken ring, a method is
needed to override the power-down and cause the node to power-up even though no light is received at
the FOR. This override event is labeled Switch-To-Power.
For an OS8805 in a standard package at an ambient temperature of 85oC on a four-layer board, the esti-
mated junction temperature would be (referring to Thermal Characteristics on page 199):
TJ = 38 °C/W × 1.2 W + 85 °C = 131 °C
Estimating TJ with this technique in an application may be inaccurate due to differences between the test
environment and the system being measured. The heat from other devices, the size and shape of the
board and of the enclosure all corrupt the measurement. A more accurate measure of TJ can be made
through the parameter ΨJT. The formula for ΨJT is:
T J – TT
Ψ JT = ------------------
P
where TT is the temperature measured on the top of the package. The power dissipation of the device is
calculated as above. Solving for TJ gives:
TJ = Ψ JT × P + T T
For the OS8805 in the example above, the total power was:
P = IDD × VDD = 1.2 W
If TT were measured at 128 °C, the estimated junction temperature would be (referring to Thermal Charac-
teristics):
TJ = 2.5 °C/W * 1.2 W + 128 °C= 131 °C
It’s possible to get a more accurate estimate of the junction temperature using ΨJT because the thermal
probe is fastened to the device, so variations in the surrounding environment are less significant. Taking
the actual measurement can be more difficult since it has to be done for every device for which an estimate
of TJ is needed.
The negative resistance can be measured by placing a variable resistor (RVAR) in series with the crystal
and finding the largest resistor value where the crystal still starts up properly. This point would be just
below where the oscillator does not start-up or where the start-up time is excessively long.
Ideally oscillator margin should be greater than 10, and should be at least 5. Smaller oscillator margin can
affect the ability of the oscillator to start up.
The load capacitor, specified when ordering the crystal, is the series combination of the capacitance on
each leg of the crystal. This capacitance includes not only the added capacitors, but also PCB trace
(shunt) capacitance and chip pin capacitance. Larger capacitors also have a negative affect on oscillator
margin. In general, the external capacitors on each leg (C1 and C2) should be in the 12 to 22 pF range.
Name Value Description
Correlation Parallel Resonant Mode of oscillation
Osc. Mode Fundamental Oscillation mode or Operation mode.
CL 16-20 pF Recommended Load Capacitance.
Recommended Maximum Equivalent Series Resistance:
ESR 40 Ω When crystal frequency is 256Fs or 384Fs
20 Ω When crystal frequency is 512Fs
Drive Level 50 µW Typical Drive Level
TA -40 to 85 °C Operating temperature range
cut AT AT cut produces the best temperature stability.
Tolerance ±50 ppm Frequency tolerance at 25 °C. Typical value.
Table 8-2: Crystal Oscillator Specifications
The crystal cut and tolerance value listed in Table 8-2 are typical values and may be changed to suit differ-
ing system requirements. Higher ESR values, than those listed in the Table, run the risk of having start-up
problems and should be thoroughly tested before being used. Contact the crystal manufacturer for more
information.
• DSPs:
• Pointer memory changed from 24 to 25 bits wide, so the Address field supports the full address range
of Data memory. Therefore, the Mod and Update fields are shifted up by one bit.
• Although the Pointer memory address field increased to 11 bits, the pointer update ALU’s are only 10
bits; therefore, the upper address bit selects between two 1K pages of Vector memory and pointer
updates will not cross this page boundary. Vector memory data arrays should not cross the 1K
page boundary if the pointers used to access the array use pointer updates to move the pointer.
• Instruction change. The non-delayed jump to subroutine returns to the instruction immediately after
the sub. call (in the OS8804 it returned to the fourth instruction after the call).
• Instruction change. The TRAP instruction changed to call the (new) Debug interrupt vector instead of
clearing the DnPCR.RUN bit.
• For DSP0, GP8 (GPC0) is no longer connected, and IER.DD and IER.GPIO are not supported. For DSP0
GPIO interrupt capability, GPA0 can be used. See Figure 4-15.
• For DSP1, although GP9 (GPC1) is connected to DSP1, it can no longer generate an interrupt, and
IER.DD and IER.GPIO are not supported. For DSP1 GPIO interrupt capability, GPC0 can be used. See
Figure 4-15.
• Once RGEN.XME and MMPC.XMQ are set for DSP0 external memory port, the port must be explicitly
enabled by setting GCTL.EDMEN.
• DSPs:
• Increased Program memory to 2k (from 1280 words).
• Increased Left/Right Vector memories to 2k (from 512 words).
• Increased Left/Right Pointer memories to 64 (from 32).
• The External Data memory port is expanded to support 128k of SRAM memory.
• Added support for doubling the throughput between the DSPs and the Routing bus, by remapping
other ports.
• Added a FIFO port between DSPs.
• Added Dual Async. Source Ports between each DSP and the external system.
• Added an extra PWM DAC (PWM1) to DSP0.
• Added a Debug Interrupt vector (0x050) for the TRAP instruction as well as Host Controller debug
interrupts (DDnCS.TRINT).
• Each DSP has access to eight EGPIO pins, if not used for the Async Source Ports.
• Both DSPs can control the volume for the ADCs and DACs.
• Source Converters:
• Each Audio DAC can be operated in a single-ended mode (ADACn.SEDE). If any DAC is set for single-
ended mode, VREFS must be decoupled properly.
• Each Audio DAC can be software muted (ADACn.MUTE).
Section A.1 16. Added OS8804 variance that SPCH/DSPCH must be pushed or popped from the stack when
SPC/DSPC are pushed or popped.
DS8805AP4
1. Added IER.DRI bit
2. Added that IOG3 (RX), when configured as a GPIO output, only supports open-drain (CMOS
Chapter 2 not supported). The IPOT3.GPPTG3 bit has no effect on IOG3.
3. Changed the UnC.CKSL[1:0] = 11 setting to reserved.
4. Clarified VREFS pin and DACn.SEDE usage.
Chapter 4 7. The DDIV0 and DDIV1 DSP timer divider registers contain only 15 usable bits, DDIVn[14:0]. The
MSB must be set to 0.
Chapter 5 8. Clarified VREFS pin and DACn.SEDE usage.
9. Changed operating temperature range from Ambient to Junction
10. Clarified Maximum Input Voltage in Section 6.1 for Digital I/O pins configures for inputs vs.
outputs.
11. Updated thermal data
Chapter 6
12. Changes operating supply variation to 5 %
13. Updated power consumption and PWD/Jitter numbers
14. Added Flash program/erase cycle numbers
15. Updated Analog specifications
DS8805FP5
1. When the Control or Debug Ports are configured for I2C mode, added comment about initial
Chapter 2 power-up glitch on SDA, and added comment that CPS.STOP bits can occur before receiving
the first start bit and address byte.
2. Added comments about the SCK requirements for GTR to work properly.
Chapter 3 3. Added comments about the SCK requirements for GTR and Peripheral Routing to work
properlyCorrected bGA default value.
4. Added comments about the SCK requirements for GTR and MOST routing to work properly
Chapter 4
5. Removed DS0C.CHAIN (bit 6) as it does nothing
[email protected] [email protected]
[email protected] [email protected]
Technical Support
For technical support please refer to one of the following e-mail addresses:
[email protected]
[email protected]