• View
• Edit
• History
• Print
• Login

Software

Prev Edit this page to change styles

--- Boxes and outlines ---

--- Headers beyond ordinary "!" level headers

--- Stegi specific stylings ---

--- Text warnings, notices, hilights ---

--- Directory paths ---

--- Calendar specific ---

BeagleBox: Embedded distribution for BeagleBoards - Bx/Cx, xM, BeagleBone

Note: Currently, this only support the C4. I intended to integrate information for the other models as I come across it. I don't actually have the other boards (at least not yet) so it's harder to validate the information for them.

Repositories and External Information

The information on this page describes how to compile and create your own software distribution for a BeagleBoard. It forms the basis for the BeagleBox build system.

• BeagleBoard @ eLinux.org
• cdtools are used to navigate directories for this repository (re: bashsetup.sh).

Basic System Build Process

1. Configure the shell environment
2. Build or acquire a toolchain
3. Build the 1st and 2nd stage bootloaders
4. Build a Linux kernel, its associated driver modules and required firmware
5. Builds the SGX packages
6. Build a root file system
7. Copy SGX files to root file system
8. Copy driver modules to root file system
9. Copy firmware files to root file system
10. Format an SD card with FAT16 and ext2 partition
11. Copy bootloaders, configuration files and kernel image to first SD partition
12. Copy rootfs to second SD partition
13. Boot the board with the SD card

Build System Basics

To use the build system, you should load the cdtools shell function.

If you don't already have the source tree cloned then you can grab the shell function directly from gitorious' raw blob data.

To get help with the build system and the many available targets, use the help target

All software components have identical (or nearly identical) sets of targets of the following format.

Build system prerequisites

Cross Toolchain

You can use available toolchains such as CodeSourcery's. However, if you want to build your own, using tools such as Crosstool-NG, you should note the following.

1. Architecture Level: arm
2. Endianess: Little Endian
3. Bitness: 32-bit
4. Architecture-Level: armv7-a
5. Emit Assembly for: cortex-a8
6. Tune for: cortex-a9
7. FPU: softfp
8. Use MMU: yes
9. Kernel: 3.2.16
10. Binutils version: 2.21.1a
11. GCC version: Linaro 4-7-2012.07
12. GCC core extra config: --with-fpu=neon --with-float=softfp
13. GCC extra config: --with-fpu=neon --with-float=softfp

BeagleBox currently uses Crosstool-NG version: 0.15.2

Which libc you choose for your toolchain is a personal matter. I'm using glibc as opposed to uClibc due to some applications that are sometimes difficult to compile with the latter, such as Connman. I'm using glibc 2.13.

To build with BeagleBox:

 vi docs/bashsetup.sh
 <edit lines as appropriate>
 source docs/bashsetup.sh
 rpi

The current configuration for the build process can be viewed by using the -showconfig target, as in the following example:

Verification

Check your cross compiler configuration:

And then test the compiler by building the following Hello World example, copying it to the rootfs of an existing distribution (such as Raspbian) and running it.

Bootloader

The BeagleBoard uses a first stage bootloader called MLO. This bootloader is stored in flash memory on the board. It's purpose is to load the second stage bootloader, u-boot. MLO used to be a separate software package, but it has been replaced by the SPL image built by Das U-Boot, more commonly called u-boot. The default configuration is named omap3_beagle_config.

To build with BeagleBox:

Package file will be stored in the package directory.

The current configuration for the build process can be viewed by using the -showconfig target, as in the following example:

Kernel

The Linux kernel used on BeagleBoard often comes from a variety of sources. BeagleBox tries to track the Linux kernel mainline tree without patches as much as possible, but also keeps an eye on Robert Nelson's kernel tree. The current kernel version used in BeagleBox is 3.2.30.

The BeagleBox build supports building from the following sources.

• kernel.org mainline releases
• git.kernel.org
• Arago's linux-omap3 git tree
• linux-omap-dss2 from gitorious.org

The default is kernel.org mainline.

The kernel configuration required can be retrieved by booting any existing distribution for the BeagleBoard and copying the output from

   cat /proc/config.gz

to a file that you can integrate into your own kernel build. Note that not every distribution is required to have /proc/config.gz. An alternative is to use the omap2plus_defconfig configuration for the BeagleBoard Bx/Cx boards and build up your own configuration from there. BeagleBoard xM and BeagleBone have different default configuration files.

After the kernel build completes, you'll need to copy the kernel image to your SD card. The source image to use in this copy is

    <linux source tree>/arch/arm/boot/uImage

This file must be copied to the first partition on the SD card.

To build with BeagleBox:

The -pkg target will copy the kernel image file into the package directory (see cdp in the bashsetup.sh).

The current configuration for the build process can be viewed by using the -showconfig target, as in the following example:

Root File System

The root file system is the collection of files and directories that make up your runtime system. Generally speaking, any root file system can be used for Raspberry Pi as long as it was generated using the same cross toolchain. To build your own, try BusyBox and/or Buildroot.

BeagleBox's Buildroot configuration is designed specifically around building the root file system. It does not use Buildroot to build the cross toolchain or the Linux kernel (although Buildroot can do handle these components as well). The structure and contents of the root file system is specifically targeted at media services, so it contains libraries and files that would be helpful on systems supporting multimedia playback.

To build with BeagleBox:

The -pkg target will copy the kernel image file into the package directory (see cdp in the bashsetup.sh).

The current configuration for the build process can be viewed by using the -showconfig target, as in the following example:

SGX

TBD

DSP

TBD

SD Card format

The minimum requirements for the BeagleBoard SD card are as follows:

1. First partition: FAT16 or FAT32
2. Second partition: root file system (format depends on what the Linux kernel is configured to support, but EXT2 recommended to avoid journaling issues which can reduce the lifespan of the SD card).

First partition contents

• MLO
• boot.scr and/or uEnv.txt
• u-boot.bin
• uImage.bin

Notes:

• The .bin suffixes are not required. They are defined by the boot.scr and/or uEnv.txt files read by u-boot at boot time.
• uImage.bin is a kernel image that is generated from the kernel's compressed zImage using u-boot's mkimage utility.

Building SD card with BeagleBox

Be sure to have your SD card installed in an SD card slot. I use USB adapters with SD card readers, which makes the SD card show up as device /dev/sdb<1 or 2> or /dev/sdc<1 or 2>. Other systems with built in SD card readers may show the device as /dev/mmcblk0p<1 or 2>.