iceproto.htm

mips架构的bootloader,99左右的版本 但源代码现在没人更新了

		<title>SerialICE Serial Communications Protcol</title>
	<h1 align=center>SerialICE Serial Communications Protcol</h1>

<!--INDEX "SerialICE Kernel" -->

This page describes the SerialICE Kernel that runs on the customer's
target board, and communicates with the SerialICE Monitor that runs on the 
SerialICE Controller.<p>

On power up, the SerialICE Kernel initializes the SIO and the RAM, and
then transfers control to the application (state0).<p>

</dl><h2>State0</h2><dl><dd>

In state0 the target is executing the application. Transition out of
this state can only occur as a result of an exception. <p>

All exceptions are first checked by the application. The application
should tranfer control to the SerialICE Kernel's exception handler under the
following two conditions:<p>

<ul>
	<li>A byte arriving on the SIO from the SerialICE Controller
	<li>A non-handled exception
</ul><p>

The SerialICE Kernel's exception handler (located at 0xbfc00180) saves a small
number of registers (currently 9) in the RAM save area. This operation
requires the use of general registers k0 and k1. This means that the
SerialICE Kernel cannot be used to debug code in which registers k0 and k1
hold useful values while interrupts are enabled, or to set breakpoints
in a region of code where k0 and k1 are in use.<p>

Once the registers have been saved, the SerialICE Kernel checks the exception
type. If it is an SIO interrupt, the byte on the SIO is checked
for value.  If the byte has a value of 0x55 (ATTN) the SerialICE Kernel will
respond with an 0xaa (ACK) and move to state1. For all other values the
SerialICE Kernel will remain in state0 and return control to the application
without sending any bytes back to the SerialICE Controller.  If any other
exception occurs, the  the SerialICE Kernel will respond with an 0xaa (ACK)
and move to state1.<p>

</dl><h2>State1</h2><dl><dd>

In state1 the SerialICE Kernel reads bytes from the SIO using polled
mode.  Groups of four bytes are assembled into words. Once a word has
been assembled, there are four possibilties depending on the value. If
the word has one of 3 special values, the action taken will be as
follows:<p>

<dl><dd>
<dl>
<dt>	0x12345678 (SENDA0) 
<dd>		Execute the code that is currently in the instruction
		buffer area. Transmit the 4-byte value of register a0 on
		completion.<p>

<dt>	0xdeadbeef (SENDSAP) 
<dd>		Transmit a 4-byte value containing the address of the
		register save area in the target memory.<p>

<dt>	0x87654321 (RUN_MODE)
<dd>		Transfer control back to the application and switch to
		state0.<p>
</dl></dl>

However, while the bytes are being assembled into words, the Kernel
also checks the value of the first byte. If an ATTN byte (0x55) is seen,
the kernel will send an ACK (0xaa), and go back to waiting for the first
byte of the word.<p>

For all other cases, the words are written to the instruction buffer
area in RAM. In this case, the SerialICE Kernel does not transmit any bytes
back to the SerialICE Controller. The instruction buffer has a capacity of 27
instructions.<p>

</dl><h2>Programming issues</h2><dl><dd>

The routines that are downloaded to the instruction buffer execute from
kseg1 (non cacheable) and may use the following scratch registers:  t0,
t1, t2, a0, a1, k0, k1, and s0. If you choose to call a subroutine, you
must save and restore register ra appropriately.  The addresses of the
get_word and put_word subroutines can be obtained from the register
save area.  These subroutines use registers k0, k1, and a1. get_word
returns the word in register v0; put_word transmits the word in
register a0.<p>

</dl><p><hr>
<b>Navigation:</b> 
<a href="index.htm">Document Home</a> | 
<a href="doctoc.htm">Document Contents</a> | 
<a href="docindex.htm">Document Index</a> <p>