beaglebone and linux

BeagleBone and Linux 2012

BeagleBone and Linux

July 19, 2012


1. BeagleBone Overview

The BeagleBone is the latest addition to the BeagleBoard.org family and like its’

predecessors, is designed to address the Open Source Community, early adopters, and anyone

interested in a low cost ARM Cortex A8 based processor. It has been equipped with a minimum

set of features to allow the user to experience the power of the processor and is not intended as a

full development platform as many of the features and interfaces supplied by the processor are

not accessible from the BeagleBone via onboard support of some interfaces.

Figure 1. BeagleBone Features


Figure 2. System Block Diagram


Figure 3. Processor Block Diagram

NOTE: Design information can be found on the SD card that ships with board. We can also

download the files from http://circuitco.com/support/index.php?title=BeagleBone

http://circuitco.com/support/index.php?title=BeagleBone


2. Board Setup

1) Insert the SD card into the SD card connector

2) Plug the USB cable into the BeagleBone

3) Plug the other end of the USB cable into the PC USB port.

4) The power LED D1 should be on

5) After a few seconds, USER0 and USER1 LED should start flashing

6) After 10 seconds or so, the board should show up as a mass storage device on your PC

7) Open the new drive and click on the Readme.html file.

8) The file should open in your browser.

9) Follow the instructions on the HTML page.

Create SD card with provided image:

To initialize your card under Windows, do the following steps:

1. Download and install Ubuntu's Win32DiskImager (also known as the win32-image-writer).

2. Download and install 7-zip compression software.

3. Download the SD card image:

- Angstrom distribution: http://www.angstrom-distribution.org/demo/beaglebone/

- Ubuntu distribution: https://wiki.ubuntu.com/ARM/OMAP

4. Download the HP Formatting tool from http://www.pcworld.com/downloads/file/fid,64963-

page,1/description.html

5. Decompress the verification image file using 7-zip.

6. Insert the SD card writer/reader into the Windows machine.

7. Insert 4GB SD card into the reader/writer.

8. If this a fresh card, one that has never been used, skip to step 11.

9. Run the HPFormatter tool and format the SD card for FAT or FAT32 in order to remove the

second partition from the card.

10. Close the HPFormatter tool when done.

11. Start the Win32DiskImager.

12. Select the decompressed image file and correct SD card location. Click on 'Write'.

14. After the image writing is done, eject the SD card.

https://wiki.ubuntu.com/Win32DiskImager

http://www.7-zip.org/

http://www.angstrom-distribution.org/demo/beaglebone/

https://wiki.ubuntu.com/ARM/OMAP

http://www.pcworld.com/downloads/file/fid,64963-page,1/description.html

http://www.pcworld.com/downloads/file/fid,64963-page,1/description.html


NOTE: If you are trying to reuse an SD card that has already been used under the above process,

you will need to reformat the card to erase the second partition. Otherwise Windows will only

see the FAT32 partition.

3. TI - Linux EZSDK for BeagleBone

3.1 Linux Software Stack

Figure 4. Linux Software Stack

3.2 Download and Install:

Download Linux EZSDK for BeagleBone from

http://software-dl.ti.com/dsps/dsps_public_sw/am_bu/sdk/AM335xSDK/latest/index_FDS.html

Run the SDK Installer by double clicking on it within Linux host PC. Alternatively, bring up a

terminal window and change directories to the where the software is downloaded and run the

SDK Installer with the following command:

[prompt]:~$ ./ti-sdk-amxx-evm-x.x.x.x-Linux-x86-Install

http://software-dl.ti.com/dsps/dsps_public_sw/am_bu/sdk/AM335xSDK/latest/index_FDS.html


NOTE: You must source the environment-setup script to run commands below correctly. This is

as simple as:

$ sudo source linux-devkit/environment-setup

To know if the environment setup script has been sourced in your current shell, the shell prompt

will be changed to contain the [linux-devkit]: prefix in the command prompt.

3.3 Bootloaders – Build and Install

We strongly recommend the use of separate object directories when building. This is done with

O= parameter to make. This value can either be relative to your current directory or a full path.

Cleaning the Sources

If you did not use a separate object directory:

$ make CROSS_COMPILE=arm-arago-linux-gnueabi- ARCH=arm distclean

If you used 'O=am335x' as your object directory:

$ rm -rf ./am335x

Compiling MLO and u-boot

$ make O=object-directory CROSS_COMPILE=arm-arago-linux-gnueabi- ARCH=arm

am335x_evm

3.4 Build, Configure and Install the Linux Kernel

3.4.1 Prepare to build

In order to build the Linux kernel you will need a cross compiler installed on your system which

can generate object code for the ARM core in your Sitara device. In the case of the AMSDK this

compiler can be found inside of the SDK in the <sdk install dir>/linux-devkit/bin directory. If

you have not already done so you should add this compiler to your path by doing:


export PATH="<sdk install dir>/linux-devkit/bin:$PATH"

Where <sdk install dir> should be replaced with the directory where the SDK was installed.

It is important that when using the GCC toolchain provided with the SDK or stand alone from TI

that you do NOT source the environment-setup file included with the toolchain when building

the kernel. Doing so will cause the compilation of host side components within the kernel tree to

fail.

The following commands are intended to be run from the root of the kernel tree unless otherwise

specified. The root of the kernel tree is the top-level directory and can be identified by looking

for the "MAINTAINERS" file.

3.4.2 Cleaning the Kernel Sources

The command to clean the kernel is:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- mrproper

For user's who are building the kernel from within the AMSDK you can also use the Makefile at

the root of the SDK installation at <sdk install dir>/Makefile to clean the kernel by doing:

cd <sdk install dir>

make linux_clean

3.4.3 Configuring the Kernel

Before compiling the Linux kernel it needs to be configured to select what components will

become part of the kernel image, which components will be built as dynamic modules, and

which components will be left out all together. This is done using the Linux kernel configuration

system.

Using Default Configurations

It is often easiest to start with a base default configuration and then customize it for you use case

if needed. In the Linux kernel a command of the form:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- <config>


will look in the arch/arm/configs directory for the configuration file (<config> in the line above)

use that file to set default configuration options. The table below shows the default configuration

files for various platforms.

NOTE: The configuration file used to build the pre-built binaries found in the SDK can be found

in the arch/arm/configs directory as tisdk_<device>_config and can be used in place of the

config file given below to reproduce the SDK Linux kernel configuration settings. The

differences between these files generally revolve around enabing/disabling additional modules

for expected SDK use cases.

Device SDK config PSP config

AM335x/Beaglebone tisdk_am335x-evm_defconfig am335x_evm_defconfig

AM37x tisdk_am37x-evm_defconfig omap3_evm_defconfig

AM3517 tisdk_am3517-evm_defconfig am3517_evm_defconfig

Beagleboard tisdk_beagleboard_defconfig omap3_beagle_defconfig

AM180x tisdk_am180x-evm_defconfig da850_omapl138_defconfig

For example, to build the default PSP configuration for the AM335x the command would be:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- am335x_evm_defconfig

To build the SDK configuration for the AM335x the command would be:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- tisdk_am335x-

evm_defconfig

After the configuration step has run the full configuration file is saved to the root of the kernel

tree as .config. Any further configuration changes are based on this file until it is cleanup up by

doing a kernel clean as mentioned above.

Customizing the Configuration

When you want to customize the kernel configuration the easiest way is to use the built in kernel

configuration systems. Two of the most popular configuration systems are:

- menuconfig: an ncurses based configuration utility

- xconfig: a Qt based graphical configuration utility.


NOTE: On some systems in order to use xconfig you may need to install the libqt3-mt-dev

package. For example on Ubuntu 10.04 this can be done using the command

sudo apt-get install libqt3-mt-dev

To invoke the kernel configuration you simply use a command like:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- <config type>

i.e. for menuconfig the command would look like

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- menuconfig

Whereas for xconfig the command would look like

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- xconfig

Once the configuration window is open you can then select which kernel components should be

included in the build. Exiting the configuration will save your selections to a file in the root of

the kernel tree called .config.

3.4.4 Compiling the Kernel

Once the kernel has been configured it must be compiled to generate the bootable kernel image

as well as any dynamic kernel modules that were selected. For u-boot the kernel should be built

with a u-boot header that the u-boot program can read. This is easily accomplished by using the

uImage build target in the kernel. In order to build the uImage target the command is:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- uImage

This will result in a kernel image file being created in the arch/arm/boot/ directory called

uImage. This file can be used by u-boot to boot your Sitara device.

If you selected any components of the kernel to be built as dynamic modules you must issue an

additional command to compile those modules. The command is:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- modules


This will result in .ko (kernel object) files being placed in the kernel tree. These .ko files are the

dynamic kernel modules. The next section will cover how to install these modules.

NOTE: For user's who are building the kernel from within the AMSDK you can also use the

Makefile at the root of the SDK installation at <sdk install dir>/Makefile to configure the kernel

with the default SDK configuration and compile the uImage and kernel modules by doing:


make linux

3.4.5 Installing the Kernel

Once the Linux kernel and modules have been compiled they must be installed. In the case of the

kernel image this can be installed by copying the uImage file to the location where it is going to

be read from. For example when using TFTP boot this may be the /tftpboot directory, whereas

when booting from SD card this may be the first partition of the SD card.

To install the kernel modules you use another make command similar to the others, but with an

additional parameter which give the base location where the modules should be installed. This

command will create a directory tree from that location like lib/modules/<kernel version> which

will contain the dynamic modules corresponding to this version of the kernel. The base location

should usually be the root of your target file system. The general format of the command is:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi- INSTALL_MOD_PATH=<path

to root of file system> modules_install

For example if you are installing the modules to an NFS share located at /home/user/targetNFS

you would do:

make ARCH=arm CROSS_COMPILE=arm-arago-linux-gnueabi-

INSTALL_MOD_PATH=/home/user/targetNFS modules_install

NOTE: For user's who are building the kernel from within the AMSDK you can also use the

Makefile at the root of the SDK installation at <sdk install dir>/Makefile to install the kernel

modules into the location pointed to by DESTDIR in your Rules.make file by doing:


make linux_install

beaglebone and linux

Documents