The Hawkboard is an open community board for ARM development. The OMAP-L138 processor provides support for various interfaces—and it sells at an affordable price.

I found that reviewing a board is not as easy as reviewing a smartphone or a netbook. Reviewing those does not take too much time, since all you need to do is use the device and document your experiences. In the case of the Hawkboard, things are quite different—a lot more complicated, in fact.

All you have is a board with open source software embedded, a boot loader, various libraries, and the Linux kernel. No outercase, great looks, or fancy buttons. I began by reading the specs to learn more about the board, and then proceeded to connect it to my laptop and power it on to check out its behaviour. Turns out that the Hawkboard has quite a bit to offer, and you can do a lot with it.

 Figure: Hawkboard

The device
The Hawkboard is an open community board mainly for developers. Almost square in shape, its dimensions are around 9 x 10 cm. It's based on a Texas Instruments OMAP-L138 Low-Power Applications Processor with an integrated 300 MHz ARM926EJ-S RISC MPU, and a floating-point C674xVLIW DSP. This gives developers a good platform for digital media and storage applications. Moreover, having a floating-point DSP around will enable developers to write various DSP algorithms and also port algorithms running on ARM and x86. Further, the board requires only a 5-volt power supply, and does not need cooling devices like a heat sink or fan—an ideal ‘green’ computing device.

The OMAP L138 processor can support the following interfaces—the RS232 serial port, Ethernet, USB, SATA, VGA, audio in/out and composite in (RCA jack). The USB ports available on the board are USB 1.1 and a USB 2.0 (OTG). Since the board runs at 5 volts, it can be powered using the USB OTG. The board's Ethernet port supports both 10base-T and 100base-TX in either half- or fullduplex mode.
 

The board has a Texas Instruments TLV320AIC3106 stereo codec (just behind the audio in/out port) for input and output audio analogue/digital conversion. The composite Video In interface is incorporated by a TVP5147M1 high-quality video decoder, which is used to convert baseband analogue video formats (NTSC, PAL and SECAM composite are supported) into digital component video. Further, the board contains a THS8135 DAC, which is an interface between the VGA interface and the Hawkboard.
 

The Hawkboard also comes with a JTAG interface, making it possible for the developer to debug the application being developed on the board. The JTAG interface provided in the board is a 2x7 double-row male header. On the other side of the board is an SD/MMC connector, which can be used to read SD and MMC cards. The board also contains a total of six LEDs, of which four are for status indications, and the other two are for general usage. LED1 is placed near the RESET button, LED 2 besides the power; LED3 and LED 4 are for UART2 transmission and reception, respectively. The board also has a ‘boot mode selection switch’, which can be used for multiple boot options (though currently the Hawkboard only supports two boot method selections). The Hawkboard also contains 128 MB DDR2 RAM (memory addresses 0xC0000000 - 0xC7F00000) and 128 MB NAND flash (0x00000000 - 0x07F00000).
 

Basic requirements

Before testing the board, here's what I found I needed:

• 5V DC adaptor (comes with the board)
• Serial Null Modem cable (comes with the board)
• Serial Adapter, to convert serial null modem to USB
• GTKTerm—terminal emulator to communicate with the serial port Monitor

Getting started

I used Ubuntu 9.10 on my host machine, and neither GTKTerm nor Minicom terminal emulators were installed by default. Install it by issuing the following command:

apt-get install gtkterm
 

Next, making sure that the powered-off Hawkboard was connected to the laptop/PC via the serial cable, I configured GTKTerm as follows: under Configuration I chose the port as /dev/ttyUSB0 and speed as 115200. (If you have a serial port on your computer and don't use the USB/serial converter, the device node may differ.) I left the other settings unchanged, and powered on the Hawkboard. GTKTerm shows bootloader messages (see Figure 1). The U-Boot boot loader does a countdown, during which you can hit any key to stop the auto-boot. If allowed to auto-boot, you wind up with a [@Hawkboard /] prompt in GTKTerm.
 

Figure 1: U-Boot messages in GTKTerm

If you interrupt auto-boot, then you see a hawkboard.org> prompt where you can type help to get a list of available commands, including those to boot the Hawkboard from a TFTP server or via USB. Figure 2 shows the manual boot option. I went on to do an auto-boot so I could test some of the interfaces.
 

Figure 2: Hawkboard boot options

Testing the interfaces

I began with the USB port. I connected a USB 2.0 pen-drive to a USB port (Figure 3 shows the messages in GTKTerm). Judging by the messages, the USB port is v1.1. Well, that's not an issue, since we're just testing the port. I mounted the drive with mount /dev/sda /media/usb and could list the files on the drive—so the USB port works fine. Satisfied, I unmounted the drive with umount /dev/sda. Next, I tried the SD/MMC slot with a microSD card from my mobile phone (inserted in an adapter). Yes, on inserting the card in the MMC slot, GTKTerm showed that it was recognised:
 

mmc0: new high speed mmc card at address 0001
mmcblk0: mmc0:0001 000000 980 MiB
mmcblk0: p1
 

Figure 3: Kernel messages on inserting USB pen drive

I mounted the single mmcblk0p1 partition on the MMC card with mount /dev/mmcblk0p1 /media/sdcard and found that the contents of the card could be read. Moving to the audio in/out port, I tried playing a few songs on the Hawkboard. The available codecs support only a few formats—voc, wav, raw and au, but you can install your favourite codecs. I used the aplay command to play a WAV file on my SD card:
 

aplay -c 2 -t wav -r 44100 -f filename.wav

(‘c’ is the number of channels—mono or stereo; ‘t’ is the type of file and ‘r’ stands for the rate in hertz.) I plugged in an Ethernet cable to the Ethernet port and manually set the IP address of the board to 10.0.0.100 using the command ifconfig eth0 10.0.0.100 netmask 255.255.255.0 broadcast 10.0.0.101 up. From a terminal window on my laptop, I successfully pinged the Hawkboard. Well, I had now checked the main interfaces, and they worked fine. My next mission was to boot my own kernel image on the Hawkboard. That involved compiling the new kernel image, setting up a TFTP server on my laptop, and downloading the image to the Hawkboard using U-Boot's TFTP client.

Compiling the kernel

The website http://code.google.com/p/hawkboard/downloads/list contains some pre-compiled kernel images—or you can compile your own kernel image, which I chose to do. The pre-requisites for compilation are:
 

• ARM Cross Compiler for Linux/U-boot—lets you compile source code on your x86 PC, for the ARM architecture.
• Kernel Source

Download the ARM Cross-Compiler mentioned at http://elinux.org/Hawkboard and extract the archive, creating the arm-2009q3 folder. Download the kernel source from the link on the same page, and extract that to a separate folder. Before you can start the compile, you need to add the path of the extracted cross-compiler's binaries folder to your PATH environment variable. In your GNOME-terminal (or other favourite terminal), run the following:

export PATH="${PATH}:/home/abhijit/Desktop/arm-2009q3/bin"

Note: /home/abhijit/Desktop/arm-2009q3 is where the compiler was extracted on my system; adjust the path accordingly, for your system. Next, change the working directory to the directory containing the kernel source (most likely called linux-omapl1). Then issue the following commands to compile the kernel:
 

$ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- distclean
$ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- omapl138_hawkboard_defconfig
$ make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi- uImage

Figure 4: Kernel cross-compilation successful

When the compilation is complete, the generated kernel image is at arch/arm/boot/uImage (see Figure 4). Next, we need to transfer the image onto the board using TFTP. Setting up the TFTP server With Ubuntu, to install the TFTP server, I just need to run sudo apt-get install atftpd. Once done, we need to modify the configuration a bit to get atftpd to run as a service directly, not through inetd. Edit the /etc/default/atftpd file using the following command and change the line

USE_INETD=true to USE_INETD=false.

Next, create the directory for files that TFTP will serve, and (re)start the service:
sudo mkdir /tftpboot
sudo chmod -R 777 /tftpboot
sudo chown -R nobody /tftpboot
sudo /etc/init.d/atftpd restart

Copy the compiled kernel image (uImage) into the /tftpboot folder.

The kernel requires a root filesystem to provide a working GNU/Linux system. While the root filesystem could be on a hard drive, a USB drive or in flash memory, we will use a RAMdisk. Download the root filesystem RAMdisk image, ramdisk_v1.gz, from http://code.google.com/p/hawkboard/ and copy this file into the TFTP server directory (/tftpboot) as well.
 

Transferring the new images to the Hawkboard

To transfer the files, the Hawkboard has to be at the UBoot prompt (the auto-boot needs to be interrupted). At the prompt, set the TFTP server IP address and the Hawkboard's IP address. In my case, the TFTP server (my laptop) was 10.0.0.7, and I set the Hawkboard as 10.0.0.100:

$setenv serverip <PC/laptop IP address>
$setenv ipaddr <Hawkboard IP address>
 

To transfer the two images to the Hawkboard (see Figure 5), use the following code:

$tftp c0700000 uImage
$tftp c1180000 ramdisk_v1.gz

Figure 5: TFTP transfer of kernel and RAMdisk images

Finally, boot the downloaded kernel image (Figure 6 shows it booting):

$bootm c0700000

Fig 6: New kernel image booting on the Hawkboard

Projects on Hawkboard

Since the board was made public just a few months back, there are no full-fledged applications available yet. There are a lot of early adopters trying to use the Hawkboard for various purposes. There are projects where Android has been ported to the Hawkboard, Linux device driver support is being added for the Hawkboard, and many others. There are many projects that will try, in particular, to utilise the DSP capabilities of the board. More information about these and other projects can be found at http://elinux.org/Hawkboard/earlyadopter

There are various ARM boards available in the market, but this one is unique. The most noticeable difference is the cost—the Hawkboard at Rs 5000 to Rs 6000 is quite cheap. Moreover, when compared with other boards, this one offers faster CPU and RAM. Compared with the Beagleboard, of course, this one has lower specs, but then the Beagleboard is almost double the price.

Resources and useful links
http://www.hawkboard.org/
http://elinux.org/Hawkboard
http://code.google.com/p/hawkboard/
http://groups.google.com/group/hawkboard?pli=1
http://www.angstrom-distribution.org/narcissus/
http://focus.ti.com/docs/prod/folders/print/omap-l138.html
http://elinux.org/Hawkboard/earlyadopter