This page describes to how deploy the Ubuntu OS and Debian on a uSomIQ COM.

These instructions were adapted from the ones provided by Robert Nelson available here:
http://eewiki.net/display/linuxonarm/BeagleBone+Black

• ARM Cross Compiler
  • Linaro: [https://launchpad.net/linaro-toolchain-binaries]
• Bootloader
  • Das U-Boot – the Universal Boot Loader [http://www.denx.de/wiki/U-Boot]
  • Source – [http://git.denx.de/?p=u-boot.git;a=summary]
• Linux Kernel
  • Linus's Mainline tree: [http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=summary]
• ARM based rootfs
  • Debian Squeeze: [http://www.debian.org/]

wget -c https://releases.linaro.org/14.04/components/toolchain/binaries/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz
tar xf gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux.tar.xz
export CC=`pwd`/gcc-linaro-arm-linux-gnueabihf-4.8-2014.04_linux/bin/arm-linux-gnueabihf-

Das U-Boot – the Universal Boot Loader [http://www.denx.de/wiki/U-Boot]

Download U-Boot via git:

git clone git://git.denx.de/u-boot.git
cd u-boot/
git checkout v2014.10 -b tmp

wget http://www.mentorel.com/downloads/usomiq/patches/u-boot-usomiq-v2014.10.patch
patch -p1 < u-boot-usomiq-v2014.10.patch

make ARCH=arm CROSS_COMPILE=${CC} distclean
make ARCH=arm CROSS_COMPILE=${CC} am335x_evm_config
make ARCH=arm CROSS_COMPILE=${CC}

If you bought modules with NAND flash 1GB and more then you need to compile a different version of u-boot, because this type of NAND has a different physical structure. The commands should be issued:

make ARCH=arm CROSS_COMPILE=${CC} distclean
make ARCH=arm CROSS_COMPILE=${CC} am335x_nand4k_defconfig
make ARCH=arm CROSS_COMPILE=${CC}

wget -c https://raw.github.com/RobertCNelson/tools/master/pkgs/dtc.sh
chmod +x dtc.sh
./dtc.sh

git clone https://github.com/RobertCNelson/bb-kernel.git
cd bb-kernel/

git checkout origin/am33x-v3.8 -b tmp

Download a patch to enable uSomIQ support in kernel

wget http://www.mentorel.com/downloads/usomiq/patches/add-usomiq-rcn-v3.8.patch
patch -p1 < add-usomiq-rcn-v3.8.patch

git checkout origin/am33x-v3.18 -b tmp

Download and apply a patch to add usomiq support in the kernel:

wget http://mentorel.com/downloads/usomiq/patches/add-usomiq-rcn-v3.18.patch
patch -p1 < add-usomiq-rcn-v3.18.patch

If you bought modules with NAND flash 1GB and more then you need to open the file patch.sh, look for this section:

usomiq () {
       git apply "${DIR}/patches/usomiq/0001-add-usomiq-dts.patch"
       #git apply "${DIR}/patches/usomiq/0002-add-usomiq-nand4k.patch"
}

and remove the '#' symbol before the second git command.

Run Build Script:

./build_kernel.sh

The kernel zImage and modules will be under the deploy directory.

This file system is very small and can be installed to the NAND flash on uSomIQ. It is not that small like Angstrom minimal distribution (~20M), but will require around 75M on the flash. However it is a real Debian system with apt-get utility installed.

Default User: debian Password: temppwd

Root User: root Root Password: root

wget -c https://rcn-ee.com/rootfs/eewiki/minfs/debian-8.2-minimal-armhf-2015-09-07.tar.xz

verify the image with:

md5sum debian-8.2-minimal-armhf-2015-09-07.tar.xz
406cd5193f4ba6c2694e053961103d1a  debian-8.2-minimal-armhf-2015-09-07.tar.xz

Extract Image:

tar xf debian-8.2-minimal-armhf-2015-09-07.tar.xz

Now you have a directory with the archived (tar) file system itself and a file with user names/passwords.

Default User: ubuntu Password: temppwd

wget -c https://rcn-ee.com/rootfs/eewiki/minfs/ubuntu-14.04.3-minimal-armhf-2015-09-07.tar.xz

verify the image with:

md5sum ubuntu-14.04.3-minimal-armhf-2015-09-07.tar.xz
b119ede365e7e7f6d380a5c16592f312  ubuntu-14.04.3-minimal-armhf-2015-09-07.tar.xz

Extract Image:

tar xf ubuntu-14.04.3-minimal-armhf-2015-09-07.tar.xz

Now you have a directory with the archived (tar) file system itself and a file with user names/passwords.

A Root File System around 64Mb in size, for flash applications.

Debian 7 (small flash)

Download:

wget -c https://rcn-ee.com/rootfs/eewiki/barefs/debian-8.2-bare-armhf-2015-09-07.tar.xz

Verify:

md5sum debian-8.2-bare-armhf-2015-09-07.tar.xz
033a436bcb13b8c98dd7fa4d3ec37503  debian-8.2-bare-armhf-2015-09-07.tar.xz

Extract:

tar xf debian-8.2-bare-armhf-2015-09-07.tar.xz

For these instruction, we are assuming: DISK=/dev/mmcblk0, “sudo fdisk \-l” is useful for determining the device id..

export DISK=/dev/mmcblk0

Erase microSD card:

sudo dd if=/dev/zero of=${DISK} bs=1024 count=1024
sudo parted --script ${DISK} mklabel msdos

Setup Boot Partition:

sudo fdisk ${DISK} << __EOF__
n
p
1

+64M
t
e
p
w
__EOF__

Set Boot Flag

sudo parted --script ${DISK} set 1 boot on

Format Boot Partition as vfat:

DISK=/dev/mmcblk0
sudo mkfs.vfat -F 16 ${DISK}p1 -n boot
(or)
DISK=/dev/sdX
sudo mkfs.vfat -F 16 ${DISK}1 -n boot

Setup Root File System Partition:

sudo fdisk ${DISK} << __EOF__
n
p
2


w
__EOF__

Format rootfs as ext4:

DISK=/dev/mmcblk0
sudo mkfs.ext4 ${DISK}p2 -L rootfs
(or)
DISK=/dev/sdX
sudo mkfs.ext4 ${DISK}2 -L rootfs

*Note: On most systems these partitions will be auto-mounted…*

sudo mkdir -p /media/boot/
sudo mkdir -p /media/rootfs/

DISK=/dev/mmcblk0
sudo mount ${DISK}p1 /media/boot/
sudo mount ${DISK}p2 /media/rootfs/

(or)

DISK=/dev/sdX
sudo mount ${DISK}1 /media/boot/
sudo mount ${DISK}2 /media/rootfs/

Copy MLO/u-boot.img to the boot partition

sudo cp -v ./u-boot/MLO /media/boot/
sudo cp -v ./u-boot/u-boot.img /media/boot/

Create “uEnv.txt” boot script: (nano uEnv.txt)

mmcroot=/dev/mmcblk0p2 ro
mmcrootfstype=ext4 rootwait fixrtc
 
loadfdt=load mmc ${bootpart} ${fdtaddr} ${bootdir}/dtbs/${fdtfile}

##Un-comment to enable systemd in Debian Wheezy
#optargs=quiet init=/lib/systemd/systemd

Copy uEnv.txt to the boot partition:

sudo cp -v ./uEnv.txt /media/boot/

To help new users, since the kernel version can change on a daily basis. The kernel building scripts in this git repo will now give you a hint of what kernel version was built.

-----------------------------
Script Complete
eewiki.net: [user@localhost:~$ export kernel_version=3.X.Y-Z]
-----------------------------

Copy and Paste that “export kernel_version=3.X.Y-Z” exactly as shown in your own build/desktop environment:

export kernel_version=3.X.Y-Z

Copy Root File System:

sudo tar xfvp ./*-*-minimal-arm*-*/arm*-rootfs-*.tar -C /media/rootfs/

Copy Kernel zImage:

sudo cp -v ./linux-dev/deploy/${kernel_version}.zImage /media/rootfs/boot/zImage

Kernel Device Tree Binaries:

sudo mkdir -p /media/rootfs/boot/dtbs/
sudo tar xfov ./bb-kernel/deploy/${kernel_version}-dtbs.tar.gz -C /media/rootfs/boot/dtbs/
sudo tar xfv ./bb-kernel/deploy/${kernel_version}-firmware.tar.gz -C /media/rootfs/lib/firmware/

Copy Kernel modules:

sudo tar xfv ./linux-dev/deploy/${kernel_version}-modules.tar.gz -C /media/rootfs/

Setup /etc/fstab:

sudo nano /media/rootfs/etc/fstab

Add:

/dev/mmcblk0p2   /           auto   errors=remount-ro   0   1
/dev/mmcblk0p1   /boot/uboot auto   defaults            0   0

sudo nano /media/rootfs/etc/network/interfaces

Add:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

Ubuntu:

sudo nano /media/rootfs/etc/init/serial.conf

Add:

start on stopped rc RUNLEVEL=[2345]
stop on runlevel [!2345]

respawn
exec /sbin/getty 115200 ttyO0

Remove microSD card:

sync
sudo umount /media/boot
sudo umount /media/rootfs

Here you will learn how install Debian to a UBIFS partition on a uSomIQ system on module.

1) Install Ubuntu or Debian to a SD card as described in the previous step

2) Download and extract a small Debian file system as described root_file_system_for_nand

You will have an archive debian-7.5-bare-armhf-2014-07-07.tar after extracting. Place this archive to the SD card with OS installed in the previous step.

3) Boot the board with the SD card to u-boot and issue the following commands:

nand erase.chip
mmc rescan
load mmc 0 ${loadaddr} MLO
nand write ${loadaddr} NAND.SPL
nand write ${loadaddr} NAND.SPL.backup1

Load the u-boot image u-boot.img to NAND.

load mmc 0 ${loadaddr} u-boot.img
nand write ${loadaddr} NAND.u-boot

Load the device tree binary

run loadbootenv
run importbootenv
run findfdt
run loadfdt
nand write ${fdtaddr} NAND.u-boot-spl-os

Load the kernel image zImage to NAND.

run loadimage
nand write ${loadaddr} NAND.kernel

4) Boot farther to OS

5) Prepare a UBIFS partition

For more information visit: http://processors.wiki.ti.com/index.php/UBIFS_Support

Preparing NAND partition for modules with 256MB

ubiformat /dev/mtd9 -s 2048 -O 2048
ubiattach /dev/ubi_ctrl -m 9 -O 2048
ubimkvol /dev/ubi0 -s 230MiB -N rootfs
mount -t ubifs ubi0:rootfs /mnt

Preparing NAND partition for modules with 512MB

ubiformat /dev/mtd9 -s 2048 -O 2048
ubiattach /dev/ubi_ctrl -m 9 -O 2048
ubimkvol /dev/ubi0 -s 450MiB -N rootfs
mount -t ubifs ubi0:rootfs /mnt

Preparing NAND partition for modules with 1024MB

ubiformat /dev/mtd9 -s 2048 -O 2048
ubiattach /dev/ubi_ctrl -m 9 -O 2048
ubimkvol /dev/ubi0 -s 950MiB -N rootfs
mount -t ubifs ubi0:rootfs /mnt

6) Install the file system to the UBIFS-partiotion

cd /mnt
tar xf <path to image>/debian-7.5-bare-armhf-2014-07-07.tar
sync

7) Enable the Serial login

Edit the file /mnt/etc/inittab as described for the SD card installation.

8) Enable Network

Edit the file /mnt/etc/network/interfaces as described for the SD card installation.

9) Remove the SD card and reboot the board