http://www.cs.wustl.edu/~schmidt/ACE-members.html

I must thank Vyasan and Dhruba, my previous project managers, for their immense support and encouragement during the conceptualization of a ACE+TAO based distributed infotainment software architecture. I had then prototyped a digital cluster based on this distributed object architecture.

I do have an ATNGW100 board, but since I don’t have a AVR JTAGICE mkII, I am yet to test this port on hardware. Any help in this regard is greatly appreciated.

Everyone is welcome to review and contribute. More on atomthreads here.

System: Ubuntu 10.04
1) sudo apt-get install atftp
2) sudo vim /etc/default/atftpd

Change the following line

USE_INETD=true

to

USE_INETD=false

save and exit the file
3) sudo service atftpd start
4) Now comes the interesting part, just create a symbolic link to the target file in /srv/tftp, which you want to copy each time to the board.
Eg:
$sudo ln -s /home/sreejithn/Embedded/ATngw100/buildroot-avr32-v2.2.1/project_build_avr32/atngw100/root/boot/a.bin /srv/tftp/a.bin
Now ‘make tftp’ in the project folder can copy the new a.bin to the above target location and tftp from uboot prompt will download the newly copied a.bin.

… the red LED on ATngw100 started blinking! So we have loaded our first standalone AVR32 application using u-boot .

blink_led.c:

#include <avr32/io.h>
int main( void )
{
unsigned long i = 0;
/* Set up a pio structure to point at PIOA’s base address */
volatile avr32_pio_t *pioa = &AVR32_PIOA;

pioa->per = 0×00080000; /* Set pio enable for PA19 of PORTA */
pioa->oer = 0×00080000; /* Make them output port */
pioa->idr = 0×00080000; /* Disable interrupts on these pins */
pioa->pudr =0×00080000; /* disable pull-ups */

while(1)
{
i++;
if(i & 0×00800000)
{
pioa->codr = 0×00080000; /* set PA19 to low */
} else
{
pioa->sodr = 0×00080000; /* set PA19 to high */
}
}
return 0;
}

Makefile:

VPATH = src
TOOL_CHAIN = /home/sreejithn/Embedded/ATngw100/as4e-ide/plugins/com.atmel.avr.toolchains.linux.x86_3.0.0.201009140852/os/linux/x86
TFTP_ROOT = /home/sreejithn/Embedded/ATngw100/buildroot-avr32-v2.2.1/project_build_avr32/atngw100/root
COMPILER = $(TOOL_CHAIN)/bin/avr32-gcc
LD = $(TOOL_CHAIN)/bin/avr32-ld
OBJCOPY = $(TOOL_CHAIN)/bin/avr32-objcopy
OBJDUMP = $(TOOL_CHAIN)/bin/avr32-objdump
OBJCOPYFLAGS = -O binary
CFLAGS = -O2 -Wall -fmessage-length=0 -mpart=ap7000 -ffunction-sections
LDFLAGS = -e 0×10400000
INCLUDE = -I./src -I$(TOOL_CHAIN)/avr32/include
LIBS =
OUT = a
ODIR = out

SRC = blink_led.c

_OBJ = $(subst .c,.o,$(SRC))
OBJ = $(patsubst %,$(ODIR)/%,$(_OBJ))

all:    build \
ld \
objcopy

build: $(OBJ)
# $(COMPILER) $(CFLAGS) \
# $^ \
# $(INCLUDE) \
# -o $(ODIR)/$(OUT)

ld: $(OBJ)
$(LD) $(LDFLAGS) \
$^ \
-o $(ODIR)/$(OUT).out

objcopy: $(ODIR)/$(OUT).out
$(OBJCOPY) $(OBJCOPYFLAGS) \
$< \
$(ODIR)/$(OUT).bin

objdump:
$(OBJDUMP) -D $(ODIR)/$(OUT).out

copy:
cp -vf $(ODIR)/$(OUT).bin $(TFTP_ROOT)/boot

$(ODIR)/%.o : %.c
$(COMPILER) $(CFLAGS) \
-c $< \
$(INCLUDE) \
-o $@

clean:
rm -f $(ODIR)/*.o $(ODIR)/$(OUT).out $(ODIR)/$(OUT).bin

I need to find a better way to share files!

OUTPUT_FORMAT(“elf32-avr32″, “elf32-avr32″, “elf32-avr32″) /* Executable file format */
OUTPUT_ARCH(avr32) /*CPU Architecture*/
ENTRY(_start) /*Entry point, ‘_start’ label*/

SECTIONS
{
. = 0;    /* AP7000 exception vector base address is 0×00, so we place our .text segment here */
_text = .; /* Initialize labels, later used in remap */
.text : {
*(.exception.text) /* Beginning of .text is exception vector. See start.S */
*(.text)
*(.text.*)
}
_etext = .; /* Initialize labels, later used in remap */

.rodata : { /* Follows the read only data. Eg: string constants. */
*(.rodata)
*(.rodata.*)
}

. = ALIGN(8); /* 8 byte align the current location counter (.) */
_data = .; /* Follows the data segment. Eg: Initialized global variables. */
.data : {
*(.data)
*(.data.*)
}

. = ALIGN(4); /* 4 byte align the current location counter (.) */
__u_boot_cmd_start = .; /* Initialize labels, later referenced in C code */
.u_boot_cmd : { /* Follows the u-boot command objects discussed in earlier post */
KEEP(*(.u_boot_cmd))
}
__u_boot_cmd_end = .; /* Initialize labels, later referenced in C code */

. = ALIGN(4); /* 4 byte align the current location counter (.) */
_got = .;
.got : { /* Follows the .got segment discussed in earlier post */
*(.got)
}
_egot = .;

. = ALIGN(8); /* 8 byte align the current location counter (.) */
_edata = .;

.bss : { /* Follows the .bss sections. Eg: Uninitialized global variables*/
*(.bss)
*(.bss.*)
}
. = ALIGN(8);
_end = .;
}
See also essential-ld.

Based on your boot strategy, you will have to provide correct entry point in linker script for u-boot to load OS/standalone application correctly. This can also be done using -e argument to the gcc linker. This restriction is not there if your built OS/Application image is position independent code (PIC). Some interesting experiments are,

1) Load and boot a Linux image from different SDRAM locations.

2) Load and boot a standalone application from u-boot prompt.

3) Let u-boot run a standalone application first, then successfully return to u-boot and run a Linux kernel.

./board/atmel/atngw100/u-boot.lds:51:

__u_boot_cmd_start = .; .u_boot_cmd : { KEEP(*(.u_boot_cmd)) } __u_boot_cmd_end = .;

__u_boot_cmd_start and __u_boot_cmd_end are global symbols which are used in C code while relocating the command table to SDRAM. Some interesting implementation are there in command table handling. The above global symbols are defined in command.h as below,

./include/command.h:59:

extern cmd_tbl_t  __u_boot_cmd_start;

extern cmd_tbl_t  __u_boot_cmd_end;

cmd_tbl_t is a structure holding command attributes. ‘Struct_Section’ defines a new section in the u-boot output image – .u_boot_cmd

#define Struct_Section  __attribute__ ((unused,section (“.u_boot_cmd”)))

And the below XMACRO makes the build time command table configuration possible,

#define U_BOOT_CMD(name,maxargs,rep,cmd,usage,help) \cmd_tbl_t __u_boot_cmd_##name Struct_Section = {#name, maxargs, rep, cmd, usage}

In u-boot memory map, we can imagine an array of command structures (cmd_tbl_t) stored, starting at ‘__u_boot_cmd_start’ till ‘__u_boot_cmd_end’. This means (&__u_boot_cmd_start – &__u_boot_cmd_end) will give the number of commands configured for a particular board variant. The below code will make an array of commands from the .uboot_cmd section,

/* Make array of commands from .uboot_cmd section */

cmd_tbl_t * cmdtp = &__u_boot_cmd_start;

int num_cmds = &__u_boot_cmd_end – &__u_boot_cmd_start; /* pointer arith! */

cmd_tbl_t *cmd_array[num_cmds];

for (i = 0; i < num_cmds; i++)

{

cmd_array[i] = cmdtp++;

}

The shell interpretor is implemented in the ‘main_loop()’ function.

The ‘env_t’ structure defines an environment variable attribute. U-boot supports environment variable storage in a fashion and memory devices -.text segment (CFG_ENV_IS_EMBEDDED), in flash (CFG_ENV_IS_IN_FLASH) and in EEPROM (CFG_ENV_IS_IN_EEPROM) etc. U-boot allocates ‘CFG_ENV_SIZE’ size memory for environment variables and it is copied from non-volatile memory to SDRAM.The following shell commands manipulate environment variables: setenv, printenv, saveenv.

char *src = _etext;
char *dst = _data;
/* ROM has data at end of text; copy it. */
while (dst < _edata) {
  *dst++ = *src++;
}
/* Zero bss */
for (dst = _bstart; dst< _bend; dst++)
  *dst = 0;

U-boot README mentions few assumptions in this regard,

“It is essential to remember this, since it has some impact on the C code for the initialization procedures:
* Initialized global data (data segment) is read-only. Do not attempt to write it.
* Do not use any uninitialized global data (or implicitely initialized as zero data – BSS segment) at all – this is undefined, initialization is performed later (when relocating to RAM).
* Stack space is very limited. Avoid big data buffers or things like that.
Having only the stack as writable memory limits means we cannot use normal global data to share information beween the code. But it turned out that the implementation of U-Boot can be greatly simplified by making a global data structure (gd_t) available to all functions. We could pass a pointer to this data as argument to _all_functions, but this would bloat the code. Instead we use a feature of the GCC compiler (Global Register Variables) to share the data: we place a pointer (gd) to the global data into a register which we reserve for this purpose.”

For avr32 target gd_t pointer is defined here:

/include/asm-avr32/global_data.h:59:#define DECLARE_GLOBAL_DATA_PTR register gd_t *gd asm(“r5″)

The ‘relocate_code’ assembly function relocates the u-boot image into RAM and continue from there. The ‘SP’ is modified to use the new bigger stack in SDRAM. Then the .text section and .data section are copied to SDRAM and .bss(uninitialized global data) is zeroed. This function never return, but self modifies ‘PC’ and jumps to a location in ram (in_ram). Finally calls ‘board_init_r’ C function and continues execution in C environment.

/* If we have no SDRAM, we can’t go on */
if (sdram_size <= 0)
panic(“No working SDRAM available\n”);

U-boot sets UART Baudrate and initializes the serial console and sends a ‘banner’ to display memory configuration and ram test results. This can be view by connecting gtkTerm or PuTTy to ATngw100 serial port.

Once the SDRAM is initialized u-boot relocates itself from flash to RAM and execute from there. Before relocating code a ‘bigger’ stack and space for the following are allocated in RAM,
- u-boot image
- heap for malloc()
- board info struct
- global data struct(**)

It is interesting that ‘board_init_f’ function never returns, knowing that it was never ‘call’ed! [ ./cpu/at32ap/start.S:186: rjmp board_init_f ]
It simply calls ‘relocate_code((unsigned long)new_sp, new_gd, monitor_addr);’ which is a call to its assembly implementation in start.S.

(**) Did you notice that? There is a mysterious pointer ‘new_gd’ leading us to know more about so called ‘global data struct’ (gd_t) in u-boot! Also I am curios to know how ‘relocate_code’ ‘C’ function call pass parameters to its assembly implementation in start.S!