Project

General

Profile

Installing Open Embedded

(!) Most of the sources for this have been moved or deleted. Critical Link does not currently know if this build can be reproduced. We recommend using the new Yocto MDK. If this is something your interested in please contact us. 2018-06-01

This area describes what is needed to setup building the OpenEmbedded Classic derived linux software. This is basically valid for releases prior to 2012. In 2012 we will be migrating to the more modern OpenEmbedded Core framework, and information about that will be published on the Installing Open Embedded Core Wiki page.

Setting up OpenEmbedded

In order to prepare a software development kit (SDK) including the ARM cross tools, or setup a root filesystem from scratch you will need to set up a linux based machine. This process will not work with cygwin. This process may be run on a virtual machine, but it will be slow and it may require 10's of gigabytes of working space during the package fetch and compile operations.

If you are configuring a new build machine, it is recommended that a Ubuntu based linux distribution is used (Debian is also supported). This document covers configuring for Ubuntu 10.04 LTS. You will require the following packages/tools to run open embedded.

On a Ubuntu system, these packages can be installed using the integrated package management system (as root), e.g.:

#bash> sudo apt-get install python build-essentials uboot-mkimage

There is also a setting required for allowing low address memory mapping on more recent linux distributions. See the Open Embedded Installation Instructions for details. For Ubuntu 10.04 LTS, you will need to execute the following command or add the line "vm.mmap_min_addr=0" to /etc/sysctl.conf and reboot.

#bash> sudo echo "0" > /proc/sys/vm/mmap_min_addr 

Once you machine has the proper tools, select a build directory location that provides a minimum of 20 GBytes free storage. We will refer to this directory as ${OEDIR} for the rest of this tutorial.

The build process for the MityDSP and MityARM linux system involves using an Overlay on top of the OpenEmbedded build architecture. Much of this setup is basically an modified version of the OE Getting Started Manual and the Overlay Example.

The first step is to download and extract the Board Support Package from support.criticallink.com and install it on your machine. Once the files are extracted, there is a working openembedded overlay directory included in the path. The next step is to get a copy of the openembedded build tool (bitbake) and open embedded repository from www.openembedded.org. These tools are required to generate a root filesystem. In the steps, "${MDK}" represents the location that you installed the board support package to.

#bash> cd ${MDK}/sw/ARM/linux/oe
#bash> wget http://download.berlios.de/bitbake/bitbake-1.8.18.tar.gz
#bash> tar xzf bitbake-1.8.18.tar.gz
#bash> ln -s bitbake-1.8.18 bitbake
#bash> git clone git://git.openembedded.org/openembedded
#bash> git checkout b92a5ec362603f3de9b983128c0a9c464cc4bb65
#bash> mkdir build
#bash> . setup-env

At this point, you should have a full configuration prepped for building the ARM gcc crosstools, bootloader, the kernel, the base root filesystem (and additional packages for post factory installation).

Building the Cross Tools

Once OpenEmbedded has been configured (as above), you can build the ARM gcc cross-tools (as well as the qt tools needed for making qt4 embedded applications) and the associated installer by the following command:

#bash> cd ${OEDIR}
#bash> . setup-env
#bash> cd build
#bash> bitbake meta-toolchain-qte

Note, subsequent builds may be performed without rerunning the setup-env script.

If successful, there will be a set of SDK image files located at ${OEDIR}/build/tmp/deploy/glibc/sdk, including:

  • kernel.tar.bz2 -> a compressed tar-ball of the built kernel (needed for module development)
  • ${crosstools}.tar.bz2 -> a compressed tar-ball of the ARM cross tools and libraries needed to build images from a linux i686 host

Building the Root Filesystem

Once OpenEmbedded has been configured (as above), you can build the ARM linux root filesystem and associated packages. The plan is to use a stable version of the Angstrom Distribution (until we find a need to change it) and provide additional packages for specific MityDSP-L138 and MityARM-1808 support. This step takes a long time if you've never done it before. It must build the cross tools, kernel, and all of the packages for the Angstrom distribution. It only bundles the base files needed for a minimum boot up into the root filesystem, but generates all of the packages as a manner of course. This will likely take 4-6 hours minimum. The build process, then, is as follows:

#bash> cd ${OEDIR}
#bash> . setup-env
#bash> cd build
#bash> bitbake mityomap-base

When this is complete, there should be a copy of the root filesystem in .tar and .tar.jffs format in the ${OEDIR}/build/tmp/deploy/glibc/mityomapl138/images directory. Note, there is also a mityomap-full image which includes the qt libraries and some other support files (but it much larger).

Building the Kernel Image

There are two use-cases that might be applicable for developing the kernel image for the MityDSP-L138 or MityARM-1808. The first use-case is to rebuild the kernel image from the OpenEmbedded scripting process. This process is used during a typical release cycle and assumes the underlying u-boot kernel has been debugged and is ready for a release. The second use-case is for development or debugging of the kernel executable and does not involve the OpenEmbedded framework.

Building the Kernel via the OpenEmbedded Framework (Release Build)

Once OpenEmbedded has been configured (as above), you can build the ARM gcc cross-tools and the associated installer by the following command:

#bash> cd ${OEDIR}
#bash> . setup-env
#bash> cd build
#bash> bitbake virtual/kernel

Building a standalone local copy of the Kernel (Development Build)

For kernel development you do not need to have the full Open-Embedded suite installed on your machine. We are managing the kernel build needed for the MityDSP machine with a git repository that has been derived from the linux-davinci.git repository (this is the active repository for submissions of patches for board sets derived from the davinci series processor -- which includes OMAPL1). The supported repository containing MityDSP patches is at git://support.criticallink.com/home/git/linux-davinci.git. At the moment there are two branches, one called "master" that is used for release builds, and one called "devel" being use to develop the MityDSP-L138 kernel modifications. The goal is to eventually push the modifications up the kernel.org mainline and see this repository "go away". For now, though, it will be used for our development site. Periodically, it will be sunk back up with the linux-davinci head in order to pick up needed driver submissions and other linux improvements from the mainline.

To download your own copy of the kernel run:

#bash> git clone git://support.criticallink.com/home/git/linux-davinci.git linux-davinci
#bash> cd linux-davinci
#bash> git checkout -b devel origin/devel

This will download the repository and checkout the "devel" branch from the "devel" branch on the server. Please note that if you intend to make changes, etc., you will need to become moderately familiar with the git tool (see Information on git). Critical Link will accept (and would appreciate) patches for code specific to any non-mainstream code areas - i.e., needed changes to the board configuration files not yet approved in the mainline. However, any patches that are related to the mainline code (SoC drivers, main kernel code, etc.) should be published through the proper linux channels (see www.linux.org).

To compile the kernel you will need to install the ARM cross tools (which get generated from the open-embedded Cross Tools step). To install the tools (in a local directory) simply untar the data and run the local setup script:

#bash> tar xjf mityomapl138-sdk-release.tar.bz2 -C /

Now you are ready to configure and compile the kernel. First clean the distribution, then configure, then compile.

#bash> . /usr/local/angstrom/arm/environment-setup
#bash> unset CPATH  # there is a bug in the setup script, CPATH should not be assigned
#bash> make ARCH=arm CROSS_COMPILE=arm-angstrom-linux-gnueabi- distclean
#bash> make ARCH=arm CROSS_COMPILE=arm-angstrom-linux-gnueabi- mityomapl138_defconfig
<optional - If you want to change the kernel config...>
    #bash> make ARCH=arm CROSS_COMPILE=arm-angstrom-linux-gnueabi- menuconfig
#bash> make ARCH=arm CROSS_COMPILE=arm-angstrom-linux-gnueabi- uImage

Add picture from clipboard (Maximum size: 600 MB)