RedBoot User's Guide
Prev | Chapter 5. Installation and Testing | Next

# MIPS/MIPS32(CoreLV 4Kc)+MIPS64(CoreLV 5Kc) Atlas Board

## Overview

RedBoot supports the DgbSer serial port and the built in ethernet port for communication and downloads. The default serial port settings are 115200,8,N,1. RedBoot runs from and supports flash management for the system flash region.

The following RedBoot configurations are supported:

Configuration | Mode | Description | File
--- | --- | --- | ---
ROM | [ROM] | RedBoot running from the board's flash boot sector. | redboot_ROM.ecm
RAM | [RAM] | RedBoot running from RAM with RedBoot in the flash boot sector. | redboot_RAM.ecm

## Initial Installation

RedBoot is installed using the code download facility built into the Atlas board. See the Atlas User manual for details, and also the Atlas download format in the Section called Atlas download format.

### Quick download instructions

Here are quick start instructions for downloading the prebuilt RedBoot image.

1. Locate the prebuilt files in the bin directory: `deleteall.dl` and `redboot.dl`.

2. Make sure switch S1-1 is OFF and switch S5-1 is ON. Reset the board and verify that the LED display reads `Flash DL`.

3. Make sure your parallel port is connected to the 1284 port Of the Atlas board.

4. Send the `deleteall.dl` file to the parallel port to erase previous images:

       $ cat deleteall.dl >/dev/lp0

   When this is complete, the LED display should read `Deleted`.

5. Send the ROM mode RedBoot image to the board:

       $ cat redboot.dl >/dev/lp0

   When this is complete, the LED display should show the last address programmed. This will be something like: `1fc17000`.

6. Change switch S5-1 to OFF and reset the board. The LED display should read `RedBoot`.

7. Run the RedBoot fis init and fconfig commands to initialize the flash. See the Section called Additional config options, the Section called Flash Image System (FIS) in Chapter 2 and the Section called Persistent State Flash-based Configuration and Control in Chapter 2 for details.

### Atlas download format

In order to download RedBoot to the Atlas board, it must be converted to the Atlas download format. There are different ways of doing this depending on which version of the developer's kit is shipped with the board.

The Atlas Developer's Kit CD contains an srec2flash utility. The source code for this utility is part of the `yamon/yamon-src-01.01.tar.gz` tarball on the Dev Kit CD. The path in the expanded tarball is `yamon/bin/tools`. To use srec2flash to convert the S-record file:

    $ srec2flash -EL -S29 redboot.srec >redboot.dl

The Atlas/Malta Developer's Kit CD contains an srecconv.pl utility which requires Perl. This utilty is part of the `yamon/yamon-src-02.00.tar.gz` tarball on the Dev Kit CD. The path in the expanded tarball is `yamon/bin/tools`. To use srecconv to convert the S-record file:

    $ cp redboot_ROM.srec redboot_ROM.rec
    $ srecconv.pl -ES L -A 29 redboot_ROM

The resulting file is named `redboot_ROM.fl`.

## Flash management

### Additional config options

The ethernet MAC address is stored in flash manually using the fconfig command. You can use the YAMON setenv ethaddr command to print out the board ethernet address. Typically, it is:

    00:0d:a0:00:xx:xx

where `xx.xx` is the hex representation of the board serial number.

## Additional commands

The exec command which allows the loading and execution of Linux kernels, is supported for this architecture (see the Section called Executing Programs from RedBoot in Chapter 2). The exec parameters used for MIPS boards are:

-b `<addr>`

  Location to store command line and environment passed to kernel

-w `<time>`

  Wait time in seconds before starting kernel

-c `"params"`

  Parameters passed to kernel

`<addr>`

  Kernel entry point, defaulting to the entry point of the last image loaded

Linux kernels on MIPS platforms expect the entry point to be called with arguments in the registers equivalent to a C call with prototype:

    void Linux(int argc, char **argv, char **envp);

RedBoot will place the appropriate data at the offset specified by the `-b` parameter, or by default at address 0x80080000, and will set the arguments accordingly when calling into the kernel.

The default entry point, if no image with explicit entry point has been loaded and none is specified, is 0x80000750.

## Interrupts

RedBoot uses an interrupt vector table which is located at address 0x80000400. Entries in this table are pointers to functions with this protoype:

    int irq_handler( unsigned vector, unsigned data )

On an atlas board, the vector argument is one of 25 interrupts defined in `hal/mips/atlas/`VERSION`/include/plf_intr.h`:

    #define CYGNUM_HAL_INTERRUPT_SER                 0
    #define CYGNUM_HAL_INTERRUPT_TIM0                1
    #define CYGNUM_HAL_INTERRUPT_2                   2
    #define CYGNUM_HAL_INTERRUPT_3                   3
    #define CYGNUM_HAL_INTERRUPT_RTC                 4
    #define CYGNUM_HAL_INTERRUPT_COREHI              5
    #define CYGNUM_HAL_INTERRUPT_CORELO              6
    #define CYGNUM_HAL_INTERRUPT_7                   7
    #define CYGNUM_HAL_INTERRUPT_PCIA                8
    #define CYGNUM_HAL_INTERRUPT_PCIB                9
    #define CYGNUM_HAL_INTERRUPT_PCIC               10
    #define CYGNUM_HAL_INTERRUPT_PCID               11
    #define CYGNUM_HAL_INTERRUPT_ENUM               12
    #define CYGNUM_HAL_INTERRUPT_DEG                13
    #define CYGNUM_HAL_INTERRUPT_ATXFAIL            14
    #define CYGNUM_HAL_INTERRUPT_INTA               15
    #define CYGNUM_HAL_INTERRUPT_INTB               16
    #define CYGNUM_HAL_INTERRUPT_INTC               17
    #define CYGNUM_HAL_INTERRUPT_INTD               18
    #define CYGNUM_HAL_INTERRUPT_SERR               19
    #define CYGNUM_HAL_INTERRUPT_HW1                20
    #define CYGNUM_HAL_INTERRUPT_HW2                21
    #define CYGNUM_HAL_INTERRUPT_HW3                22
    #define CYGNUM_HAL_INTERRUPT_HW4                23
    #define CYGNUM_HAL_INTERRUPT_HW5                24

The data passed to the ISR is pulled from a data table (`hal_interrupt_data`) which immediately follows the interrupt vector table. With 25 interrupts, the data table starts at address 0x80000464 on atlas.

An application may create a normal C function with the above prototype to be an ISR. Just poke its address into the table at the correct index and enable the interrupt at its source. The return value of the ISR is ignored by RedBoot.

## Memory Maps

Memory Maps RedBoot sets up the following memory map on the Atlas board.

    Physical Address Range Description
    ----------------------- -------------
    0x00000000 - 0x07ffffff SDRAM
    0x08000000 - 0x17ffffff PCI Memory Space
    0x18000000 - 0x1bdfffff PCI I/O Space
    0x1be00000 - 0x1bffffff System Controller
    0x1c000000 - 0x1dffffff System flash
    0x1e000000 - 0x1e3fffff Monitor flash
    0x1f000000 - 0x1fbfffff FPGA

## Rebuilding RedBoot

These shell variables provide the platform-specific information needed for building RedBoot according to the procedure described in Chapter 3:

    export TARGET=atlas_mips32_4kc
    export TARGET=atlas_mips64_5kc
    export ARCH_DIR=mips
    export PLATFORM_DIR=atlas

Use one of the TARGET settings only.

The names of configuration files are listed above with the description of the associated modes.

Prev | Home | Next
IA32/x86 x86-Based PC | Up | MIPS/MIPS32(CoreLV 4Kc)+MIPS64(CoreLV 5Kc) Malta Board