Handhelds, Linux and Heroes

Mini6410 – Getting started with Free Software September 22, 2010

FriendlyARM is shipping the new Mini6410 for a little while now.  It is based on a 533MHz clocked Samsung S3C6410. I do not want  to repeat all the technical details here, an English description can be found here. Lets summarize the features in a simple sentence: It is fast enough for Qt and offers lots of ports for connectivity.

Mini6410 running an OpenEmbedded built GPE Image

The image pretty much illustrates what we are up to do now – but lets take a look at the software shipped with the board first. Compared to the older Mini2440 the devices official support DVD offers several more options: We have pre-compiled images based on Android, XUbuntu and Qtopia and an advanced U-Boot which comes with a kind of menu for the basic tasks.  One major problem is that currently the documentation is available in Chinese only which makes it a little bit hard to handle. But translating single paragraphs of the more than 300 pages long PDF manual using Google Translator worked pretty well. The DVD contains important sources for Android, U-Boot and Linux. The Kernel is based on 2.6.28 for the SMDK 6410 reference design and heavily patched. Some parts are quite far from mainline Linux and should be updated to latest standards – apart from the fact the whole Linux support might want some rebase on 2.6.35.

Now we have a big pile eh… DVD with stuff that runs on the board already – what does OpenEmbedded help us with here? Well all the binary stuff serves some purpose but nothing is perfect – OE helps us with to become more flexible and consistent at the same time. XUbuntu is great with its large package repository to try out things – but it has quite some requirements about flash storage, RAM and screen size. With OE you have the choice to create a full featured desktop image or to build something that fits your particular need.

So lets take a brief look into OE setup for the Mini6410 and how to install an image built with OE.

If you are new to this topic you should get familiar with OpenEmbedded first. The official getting started document is a good thing to read first. The following section assumes you have your OE set up and cares about the Mini6410 specific bits only. Make sure to use a recent org.openembedded.dev or testing branch.

First set up your local.conf to build for the Mini6410 – if you are using multiple configuration files then make sure to distribute these bits over the files correctly:

MACHINE = "mini6410"
DISTRO = "angstrom-2008.1"
LIBC = "eglibc"
GLIBC_GENERATE_LOCALES = "en_GB.UTF-8 de_DE.UTF-8 fr_FR.UTF-8 en_US.UTF-8"

This will select the Mini6410 as a target device, Ångström distribution and eglibc – this is the combination I tested. The last line defines a limited set of libc locales to be generated.

Now let’s build a filesystem image. I built a simple GPE based filesystem image first:

bitbake x11-gpe-image

If everything is configured correctly, your harddisk is large enough and your Internet connection ok you should get filesystem and kernel image in $TMPDIR/deploy/eglibc/images/mini6410. For the impatient of you or the ones who get bored during a build (no I don not suffer from this) I have uploaded my results here.

Finally lets go ahead an install these files into the internal NAND flash. I’m using U-Boot on the boards – we want to stay open and do not rely on propitiatory software. Keep this in mind if you intend to make a product: Any component you are not able to influence has potential to cause trouble and in most cases it will do this – sooner or later.

There are several ways to install files and to configure U-Boot. Here we use a quite generic solution using TFTP to transfer the images and fixed addresses. Not the best solution but the simplest. First if you do not have a DHCP server you have to configure networking:

setenv ipaddr <some IP for the board>
setenv serverip <your server's IP>

If you have a DHCP server you can skip this step and write “dhcp” instead of “tftp” in the commands below. These will download the files and install them into the internal NAND flash:

tftp 0xc0008000 uImage-mini6410.ubi
nand erase 0x80000 0x500000
nand write 0xc0008000 0x80000 0x500000

tftp 0xc0008000 x11-gpe-image-mini6410.ubi
nand erase 0x580000
nand write 0xc0008000 0x580000 ${filesize}

Finally we configure the boot parameters to match the installed kernel + filesystem and save these:

setenv bootargs console=ttySAC0,115200 ubi.mtd=2
   root=ubi0:rootfs-mini6410 rootfstype=ubifs
saveenv

(note that the first command needs to be entered in a single line)

We do not have to pass information about the MTD partition layout to the kernel since we follow the kernel’s built-in default in this configuration. Just reset your board and check if it boots into your shiny new filesystem. If something is wrong then please drop me a mail providing information (e.g. bootlog, screenshot, configuration files…). This could help to improve this little text and OpenEmbedded support for the Mini6410.

What now?

Try more useful targets with OpenEmbedded. If you like to build an installable cross toolchain matching your filesystem you could build the meta-toolchain-gpe target for example.

Enjoy!