Compile Hello

Compile Hello

Add hello apps to uClinux-dist (recommended)

Please follow the doc to add your user apps,

nios2-linux/uClinux-dist/Documentation/Adding-User-Apps-HOWTO

But change foo to hello.

cd nios2-linux/uClinux-dist

<p>mkdir user/hello

</p>

Edit user/Makefile,

add a line in the sorting order.

dir_$(CONFIG_USER_HELLO_HELLO) += hello

Edit user/Kconfig

after menu "Miscellaneous Applications".

config USER_HELLO_HELLO

bool "hello"

help

This program prints hello world.

Create user/hello/Makefile

EXEC = hello

OBJS = hello.o

all: $(EXEC)

$(EXEC): $(OBJS)

$(CC) $(LDFLAGS) -o $@ $(OBJS) $(LDLIBS)

romfs:

$(ROMFSINST) /bin/$(EXEC)

clean:

-rm -f $(EXEC) *.elf *.gdb *.o

Create user/hello/hello.c.

#include <stdio.h>

int main(void)

{

printf("hello world\n");

}

Then make menuconfig and select [*] hello. Now you can make. Boot nios2 and run "hello".

Compile without adding to uClinux-dist (not recommended)

To compile a simple program for uClinux, just add -elf2flt to link flag

Create a file, hello.c

nios2-linux-uclibc-gcc hello.c -o hello -elf2flt

The compiled object format is FLAT.

You may check it with,

nios2-linux-uclibc-flthdr hello

hello

Magic: bFLT

Rev: 4

Build Date: Mon Jun 5 21:49:44 2006

Entry: 0x40

Data Start: 0x4a8c

Data End: 0x5c48

BSS End: 0x7ca8

Stack Size: 0x1000

Reloc Start: 0x5c48

Reloc Count: 0x11e

Flags: 0x1 ( Load-to-Ram )

Then copy hello to the romfs/bin dir. Rebuild the kernel image for initramfs.

cp hello ~/nios2-linux/uClinux-dist/romfs/bincd ~/nios2-linux/uClinux-dist

make

Boot nios2 uClinux, and run

hello

The default stack size of application is 4KB, you can change it with -elf2flt="-s <new stack size>" option, eg, nios2-linux-uclibc-gcc hello.c -o hello -elf2flt="-s 16000"

will have stack size as 16KiB. If using pthreads, only the main thread will have this 16KiB size. Subsequent threads will have their stack at default size, and you will want to change that size at thread creation. Otherwise, you're in for some stack-blowing fun, which hard to debug.

The default include dir search path is /opt/nios2/include (or staging_dir/include if you use buildroot)

The default library search path is /opt/nios2/lib (or staging_dir/lib if you use buildroot)

The default apps library is uClibc's libc, so you don't need -lc .

If you use math, you need -lm .

If you use pthread, you need -lpthread .

If you use crypt, you need -lcrypt .You will need those include headers, too.

The order of libraries is important, the linker will search only one pass by default.

staging directory

We built the uClibc in the toolchain. The headers and libs of uClibc will be included automatically. So you don't need "-I" and "-L" for uClibc.

When you need other lib, eg libssl, the uClinux-dist/staging directory will be created for libraries installation. This is NOT the staging_dir when we build the toochain.

Please look at the Makefile of uClinux-dist/lib/libssl. We defined "INSTALL_PREFIX=$(STAGEDIR)".

This is the destination of library installation. We would install all libraries there.

The header files of libraries will be installed in nios2-linux/uClinux-dist/staging/usr/include .

The libraries objects will be installed in nios2-linux/uClinux-dist/staging/usr/lib .

If you want to compile a program outside uClinux-dist, you will need to include the header and lib paths. Like this,nios2-linux-uclibc-gcc abc.c -o abc -elf2flt -I/home/hippo/nios2-linux/uClinux-dist/staging/usr/include -L/home/hippo/nios2-linux/uClinux-dist/staging/usr/lib ....

If you add apps to uClinux-dist, these rules are already defined in the CFLAGS and LDFLAGS in the file uClinux-dist/vendors/Altera/nios2/config.arch .

Sometimes, the application executable will be installed in nios2-linux/uClinux-dist/staging/usr/bin. There will be romfs target in apps Makefile to copy the executable to uClinux-dist/romfs/bin or usr/bin.

Implicit Rules of Makefile

Please check info of "make".

Compiling C programs

`N.o' is made automatically from `N.c' with a command of the form

`$(CC) -c $(CPPFLAGS) $(CFLAGS)'.

Compiling C++ programs

`N.o' is made automatically from `N.cc', `N.cpp', or `N.C' with a

command of the form `$(CXX) -c $(CPPFLAGS) $(CXXFLAGS)'. We

encourage you to use the suffix `.cc' for C++ source files instead

of `.C'.

Assembling and preprocessing assembler programs

`N.o' is made automatically from `N.s' by running the assembler,

`as'. The precise command is `$(AS) $(ASFLAGS)'.

`N.s' is made automatically from `N.S' by running the C

preprocessor, `cpp'. The precise command is `$(CPP) $(CPPFLAGS)'.

Linking a single object file

`N' is made automatically from `N.o' by running the linker

(usually called `ld') via the C compiler. The precise command

used is `$(CC) $(LDFLAGS) N.o $(LOADLIBES) $(LDLIBS)'.

IO programming in user space.

Note, you are doing in user space, with uclibc and included from /opt/nios2/include. It is not kernel space. You can not use interrupt. You can not use nios2 HAL, either.

To do decent I/O programming you should either create an appropriate Kernel driver, map the I/O addresses into your application with portable means like mmap() (see Accessing hardware registers from user space programs ) or use uio.

If you really want to work around the ways of the OS and create non-portable code, you should consider the following instructions (while of course the Build System providesdecent I/O access functions for Kernel drivers out of the box).

You should know about the cache in Nios II. The first 2GB of address space is cached. The second 2GB is non-cached. These are not two seperate memory spaces or anything so there is a total of 2GB of address space (mirrored memory). This only applies for Nios II Full version with Data Cache. Nios II Standard version is uncached, so there should be no problems.

In other words address 0x00000000 (cachable) maps to address 0x8000000 (non-cachable)

" " " " " " 0x00000001 " " " " " " " " 0x8000001 (and so on .....)

So use the first 2GB for non-peripheral access (local memory), and the second 2GB for peripherals

You can define memory pointer access, and you can make it uncached by setting address bit 31.

eg, 0x00004000 -> 0x80004000

Or use port address defined in nios2_system.h, eg na_button_pio.

#include </home/hippo/uClinux-dist/linux-2.6.x/include/nios2_system.h>

define inw(port) (*(volatile unsigned *)(port)) # for io read,
#define outw(d,port) (*(volatile unsigned *)(port))=(d) # for io write,

As an alternative, you can use these two defines (which are always uncached), they are similar to the Nios2-IDE functions :

#define IORD(address,offset) (*(volatile unsigned *)(((address)|0x80000000)+4*(offset)))

#define IOWR(address,offset,value) (*(volatile unsigned *)(((address)|0x80000000)+4*(offset)))=(value)

Download

hrtimer.c - Linux driver for "hrtimer" device (see attachment section below)