Difference between revisions of "RK3188-SOM"

Revision as of 04:00, 29 January 2015

Overview

This one is little beast comparing to A20 it have 4x Cortex-A9 vs 2x Cortex-A7 and runs on 1.6GHz vs. 1GHz so RK3188 makes total 16000 DMPIS vs. 3800 DMIPS for A20 (4.2 times faster) and vs. 965 DMIPS for RaspberryPi (16.6 times faster).

On the SOM there is:

RK3188 running at 1.6Ghz
1GB DDR3 memory
Power Managment Unit IC
Optional 4GB NAND Flash
Micro SD-card to boot Llinux or Android
Three buttons
Four status LEDs (one for power and three programmable)
Debug UART console
Five GPIO connectors 2×20 pins 0.05″ step

Linux

Building parameter file

This file describe many board parameters as firmware version, machine id, manufacturer, etc.

For the user the most important parameter is CMDLINE. This is the command that is passed to the kernel. It look something like this:

CMDLINE:console=ttyFIQ0,115200 console=tty0 root=/dev/mmcblk0p1 rw rootfstype=ext4 init=/sbin/init initrd=0x62000000,0x00800000 \
mtdparts=rk29xxnand:0x00008000@0x00002000(boot),-@0x0000A000(linuxroot)

Define serial port at 115200:

console=ttyFIQ0,115200

Define location of the rootfs:

root=/dev/mmcblk0p1

Define rootfs file system as ext4:

rootfstype=ext4

Define the address of the kernel and size:

0x00008000@0x00002000

Define start address of the rootfs:

-@0x0000A000

Additionally you can set static MAC address with:

mac_addr=xx:xx:xx:xx:xx:xx

Once you're ready with the file, make parameter image

Get rkutils:

https://github.com/naobsd/rkutils
cd rkutils
gcc rkcrc.c -o rkcrc

If you're getting error try comment '#include <err.h>' in 'rkcrc.c'

Encrypt parameter file:

./rkcrc -p you_parameter_file parameter

The parameter file is ready for further use.

Building kernel

Prepare the toolchain:

apt-get update
apt-get install gcc-4.7-arm-linux-gnueabihf ncurses-dev uboot-mkimage build-essential git

Get the sources:

git clone -b olimex/stable-3.0 https://github.com/SelfDestroyer/RK3188-SOM.git

Get default configuration:

cd RK3188-SOM/
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- olimex_rk3188_defconfig

You can modify defconfig:

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig

Note! The default config will set hdmi to 1080p. You can change it from:

Device Drivers --->
    Graphics support --->
        <*> Frame buffer support for Rockchip --->
                LCD Panel Select --->
                    Choose one of the following:
                    HDMI framebuffer size and timing is 1080p    <---    Set HDMI to 1080p
                    HDMI framebuffer size and timing is 720p     <---    Set HDMI to 720p
                    HDMI framebuffer size and timing is 480p     <---    Set HDMI to 480p
                    RGB AT070TN90    <---    LCD-OLinuXino-7
                    RGB AR010H05N    <---    LCD-OLinuXino-10
                    RGB BT043DCNNHHP <---    LCD-OLinuXino-4.3TS

Build the kernel:

make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j4 kernel.img

After build is finish you will have RK3188-SOM/kernel.img and RK3188-SOM/arch/arm/boot/Image. The first one can be uploaded to the kernel partition (if you have one). The second file is raw binary. It can be combined with ramdisk to get boot.img.

Generate ramdisk

cd ../
git clone https://github.com/radxa/initrd.git
cd initrd/
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j4 
cd ../

Make mkbootimg

git clone https://github.com/neo-technologies/rockchip-mkbootimg.git
cd rockchip-mkbootimg
make
make install
cd ../

Make boot.img

mkbootimg --kernel RK3188-SOM/arch/arm/boot/Image --ramdisk initrd.img -o boot.img

Creating root filesystem

Debian Wheezy

In this post we will explain how you can create your own Debian rootfs with pre-installed packages of your choice, which to allow tiny Linux images to be created. All steps below should work on any Debian host (Debian/Ubuntu etc) and are verified with Ubuntu 12.04LTS. First of all you need to install the support packages on your pc:

Install needed packages:

sudo apt-get install qemu-user-static debootstrap binfmt-support

Define some variables:

targetdir=rootfs
distro=wheezy

Build first stage:

mkdir $targetdir
sudo debootstrap --arch=armhf --foreign $distro $targetdir

Copy needed files from host to the target:

sudo cp /usr/bin/qemu-arm-static $targetdir/usr/bin/
sudo cp /etc/resolv.conf $targetdir/etc

If everything is right we now have a minimal Debian Rootfs.

Login into the new filesystem:

sudo chroot $targetdir

Inside the chroot we need to set up the environment again

distro=wheezy
export LANG=C

Now we are setup the second stage of debootstrap needs to run install the packages downloaded earlier

/debootstrap/debootstrap --second-stage

Once the package installation has finished, setup some support files and apt configuration.

cat <<EOT > /etc/apt/sources.list
deb http://ftp.uk.debian.org/debian $distro main contrib non-free
deb-src http://ftp.uk.debian.org/debian $distro main contrib non-free
deb http://ftp.uk.debian.org/debian $distro-updates main contrib non-free
deb-src http://ftp.uk.debian.org/debian $distro-updates main contrib non-free<
deb http://security.debian.org/debian-security $distro/updates main contrib non-free
deb-src http://security.debian.org/debian-security $distro/updates main contrib non-free

EOT

Update Debian package database:

apt-get update

Set up locales dpkg scripts tend to complain otherwise, note in jessie you will also need to install the dialog package as well:

apt-get install locales dialog sudo
dpkg-reconfigure locales

Fix permission for sudo:

chmod u+s /usr/bin/sudo

Fix ownership of man forlder

chown -R man /var/cache/man

Install some useful packages inside the chroot:

apt-get install openssh-server ntpdate

Set a root password so you can login:

passwd

Build a basic network interface file:

vi /etc/network/interfaces

Add the following to get static ip:

allow-hotplug eth0
iface eth0 inet static
    address 192.168.1.254
    netmask 255.255.255.248
    gateway 192.168.1.1

Or if you want dhcp

allow-hotplug eth0
iface eth0 inet dhcp

Note: Your board will be accessible over SSH on IP address defined above!

Set the hostname

echo myhost> /etc/hostname
echo "127.0.0.1       myhost" >> /etc/hosts

Enable the serial console, Debian sysvinit way

echo T0:2345:respawn:/sbin/getty -L ttyFIQ0 115200 vt100 >> /etc/inittab

This way you'll get login prompt at startup. By default you cannot login as root. To do this you should make another user, add him to the sudo group, login at startup and then login as root. To skip all this replace the line above with:

echo T0:2345:respawn:/sbin/getty -L ttyFIQ0 -a root 115200 vt100 >> /etc/inittab

We are done inside the chroot, so quit the chroot shell

exit

Tidy up the support files

sudo rm $targetdir/etc/resolv.conf
sudo rm $targetdir/usr/bin/qemu-arm-static

Installing X

You cannot run X as root(actually it's possible, but it's bad practice), so you have to add new user to run X.

Edit default useradd settings

vi /etc/default/useradd

Modify SHELL variable:

SHELL=/bin/bash

Add new user

useradd myuser

Add the user to the sudo group

adduser myuser sudo

Make home folder

mkdir /home/myuser
chown -R myuser:myuser /home/myuser

Install xfce4 and lightdm

apt-get update
apt-get install lightdm xfce4

Modify lightdm configuration to enable autologin:

vi /etc/lightdm/lightdm.conf
autologin-user=myuser
autologin-user-timeout=0

Make sure that the right lines are uncommented. If you don't want autologin just skip the step above.

Reboot the system

reboot

After the system loads, you should see the default desktop of xfce4.

Ubuntu

You can download prebuild rootfs from linaro site or you can build it yourself.

Prebuild linaro images

You can download prebuild images from https://releases.linaro.org/. In most cases the builds are separated in:

nano
developer
server
alip

You can read additional information from here.

In this tutorial we will build Ubuntu 14.10 ALIP rootfs.

Make empty image file:

dd if=/dev/zero of=linaro_alip_rootfs.img bs=1M count=1024

Format the new image file:

mkfs.ext4 -F -L linuxroot linaro_alip_rootfs.img

Create mount point:

mkdir mnt
mount -o loop linaro_alip_rootfs.img ./mnt

Download prebuild image:

wget https://releases.linaro.org/14.10/ubuntu/trusty-images/alip/linaro-trusty-alip-20141024-684.tar.gz

Make sure that the archive is downloaded:

md5sum linaro-trusty-alip-20141024-684.tar.gz

Extract is into the mounted image file:

tar -zxvf linaro-trusty-alip-20141024-684.tar.gz
mv binary/* ./mnt

Copy any modules that are generated with the kernel:

cp -rvf /path/to/modules/lib/modules ./mnt/lib/

Chroot into the new rootfs:

cp /usr/bin/qemu-arm-static ./mnt/usr/bin
cp /etc/resolv.conf ./mnt/etc
chroot ./mnt

Update repository

apt-get update

Note! If you have a problem with the update, try changing sources.list to:

deb http://old-releases.ubuntu.com/ubuntu/ raring main universe restricted multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ raring main universe restricted multiverse
deb http://old-releases.ubuntu.com/ubuntu/ raring-security main universe restricted multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ raring-security main universe restricted multiverse
deb http://old-releases.ubuntu.com/ubuntu/ raring-updates main universe restricted multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ raring-updates main universe restricted multiverse
deb http://old-releases.ubuntu.com/ubuntu/ raring-backports main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ raring-backports main restricted universe multiverse
deb http://old-releases.ubuntu.com/ubuntu/ raring-proposed main restricted universe multiverse
deb-src http://old-releases.ubuntu.com/ubuntu/ raring-proposed main restricted universe multiverse

Install some useful packages:

apt-get install ssh nano wpasupplicant wireless-tools

Set root password:

passwd

Linaro prebuild images comes with default use linaro.

Set password for user:

passwd linaro

Add linaro to sudo group:

adduser linaro sudo

Configure network. Create new file for loopback, wlan and eth device:

vi /etc/network/interfaces.d/lo

Inside paste:

auto lo
iface lo inet loopback

Do the same for eth:

vi /etc/network/interfaces.d/eth

If you're using dhcp:

auto eth0
iface eth0 inet dhcp

Or for static ip:

auto eth0
iface eth0 inet static
    address <your.ip.here>
    netmask <your.netmask.here>
    gateway <your.gateway.here>

And another for wireless devices:

vi /etc/network/interfaces.d/wlan
auto wlan0
iface lo inet dhcp
wpa-ssid <your.router.ssid>
wpa-pak <your.ssid.password>

Note! All connections are auto. If you don't want to use them all the time remove auto line.

You can do some additional work before exit. When you are ready to exit from the target filesystem:

exit

Your rootfs is ready. The next step is to create image for nand or sdcard.

Manual build using debootstrap

The procedure is almost identical to the one used for the Debin image.

First of all you need to install the support packages on your pc

sudo apt-get install qemu-user-static debootstrap binfmt-support ubuntu-archive-keyring

We will build latest trusty Ubuntu image:

targetdir=ubuntu
distro=trusty

Now we will build first stage of Ubuntu rootfs:

mkdir $targetdir
sudo debootstrap --arch=armhf --keyring=/usr/share/keyrings/ubuntu-archive-keyring.gpg --foreign $distro $targetdir

Login into the new filesystem

sudo cp /usr/bin/qemu-arm-static $targetdir/usr/bin/
sudo cp /etc/resolv.conf $targetdir/etc
sudo chroot $targetdir

Inside the chroot we need to set up the environment again

distro=trusty
export LANG=C

Now we are setup the second stage of debootstrap needs to run install the packages downloaded earlier

/debootstrap/debootstrap --second-stage

Configure apt-sources:

cat <<EOT > /etc/apt/sources.list
###### Ubuntu Main Repos
deb http://ports.ubuntu.com/ubuntu-ports/ $distro main restricted universe multiverse 
deb-src http://ports.ubuntu.com/ubuntu-ports/ $distro main restricted universe multiverse 
###### Ubuntu Update Repos
deb http://ports.ubuntu.com/ubuntu-ports/ $distro-security main restricted universe multiverse 
deb http://ports.ubuntu.com/ubuntu-ports/ $distro-updates main restricted universe multiverse 
deb-src http://ports.ubuntu.com/ubuntu-ports/ $distro-security main restricted universe multiverse 
deb-src http://ports.ubuntu.com/ubuntu-ports/ $distro-updates main restricted universe multiverse 
EOT

Update Ubuntu package database:

apt-get update

Set a root password so you can login

passwd

Set the hostname

echo myhost> /etc/hostname
echo "127.0.0.1       myhost" >> /etc/hosts

Build a basic network interface file so that the board will DHCP on eth0

echo <<EOT >> /etc/network/interfaces
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
EOT

Enable the serial console, Debian sysvinit way

echo T0:2345:respawn:/sbin/getty -L ttyFIQ0 115200 vt100 >> /etc/inittab

This way you'll get login prompt at startup. By default you cannot login as root. To do this you should make another user, add him to the sudo group, login at startup and then login as root. To skip all this replace the line above with:

echo T0:2345:respawn:/sbin/getty -L ttyFIQ0 -a root 115200 vt100 >> /etc/inittab

We are done inside the chroot, so quit the chroot shell

exit

Tidy up the support files

sudo rm $targetdir/etc/resolv.conf
sudo rm $targetdir/usr/bin/qemu-arm-static

Make rootfs image

Once you are ready with the rootfs you can make image file. Later it can be used for NAND or SD image. Go to parent directory of you rootfs.

See how big the image should be:

# du -khs <roofs_folder>

For example this will return 600MB. So we will make 1GB image.

Make empty image:

# dd if=/dev/zero of=rootfs.img bs=1M count=1024

Format the image:

# mkfs.ex4 -F -l linuxroot rootfs.img

Mount the image:

# mount -o loop rootfs.img /mnt

Copy rootfs files into the image:

# cp -prf <root_folder>/* /mnt/

'Note! Use -p option to keep the permissions for the files and folders.

Unmount the image:

# umount /mnt

Booting from NAND

Get rk-tools

git clone https://github.com/rk3066/rk-tools.git
cd rk-tools
make

You will need the following files:

bootloader --> This is RockChip RK3188Loader
parameter --> Parameter file with crc encryption
boot --> Kernel with ramdisk compiled as shown here
linux --> Rootfs image file

Copy all files in 'rk-tools' folder

Edit 'package-file'. It should be:

#nano package-file

# NAME          Relative path
#
#HWDEF          HWDEF
package-file    package-file
bootloader      RK3188Loader
parameter       parameter
boot            boot.img
linuxroot       rootfs.img
backup          RESERVED
update-script   update-script
recover-script  recover-script

Pack the image

./afptool -pack . update_tmp.img

Make update image

./img_maker -rk31 RK3188Loader 1 0 0 update_tmp.img update.img

The image should be ready. What's left is flashing the image.

Booting from SD-card

You'll need at least 512MB sd-card. Depending on rootfs needed size can grow to 4GB.

Obtain all files:
- sdboot_rk3188.img ---> RK3188 bootloader
- parameter_linux_sd ---> Parameter file, describing console and partitions
- boot.img ---> Kernel with ramdisk
- rootfs.img ---> Image of rootfs

Insert sd-card. Lets say that your device is /dev/sdc.

Write Rockchip loader:

dd if=sdboot_rk3188.img of=/dev/sdc conv=sync,fsync

Write parameter file:

Get needed tools:

git clone https://github.com/naobsd/rkutils.git
cd rkutils
gcc rkcrc.c -o rkcrc

Using this tool make parameter.img

rkcrc -p parameter_linux_sd parameter.img

You can modify

dd if=sdboot_rk3188.img of=sd.img conv=notrunc dd if=parameter.img of=sd.img conv=notrunc seek=$((0x2000)) dd if=boot-linux.img of=sd.img conv=notrunc seek=$((0x2000+0x2000)) dd if=rootfs.img of=sd.img conv=notrunc seek=$((0x2000+0xA000))

Next, as you expect the rootfs to be the first partition of the disk (cf. parameter root=/dev/mmcblk0p1), then you must create this partition. You can use fdisk for that purpose. $ fdisk sd.img

Command (m for help):

Type n to create a new partition. Partition type

  p   primary (0 primary, 0 extended, 4 free)
  e   extended (container for logical partitions)

Select (default p):

Press enter to use the default type (primary). Partition number (1-4, default 1):

Just press enter again (the default is partition 1). First sector (2048-..., default 2048):

For the first sector, you have to calculate the offset of the rootfs. On the SD image, it's located at address 0x2000 + 0xA000 = 0xC000. That's 49152 in decimal. So, just type 49152 and press enter. Last sector, +sectors or +size{K,M,G,T,P} (49152-..., default ...):

For the last sector, just press enter to use the default value. Created a new partition 1 of type 'Linux' and of size ... MiB.

Finally, type w to write the partition on the disk image. Command (m for help): w The partition table has been altered. Syncing disks.

dd if=loader.img of=/dev/sde conv=sync,fsync
dd if=parameter of=/dev/sde conv=sync,fsync seek=$((0x2000))
dd if=boot.img of=/dev/sde conv=sync,fsync seek=$((0x2000+0x2000))

Calibrate touchscreen

If you want to use LCD panel with touchscreen a calibration should be done.

Calibrate using tslib

Install required packages:

apt-get update
apt-get install xorg-dev xserver-xorg-dev x11proto-core-dev git automake make libtool

Download tslib:

git clone https://github.com/kergoth/tslib.git
cd tslib

Download patch:

cd plugin
wget https://dl.dropbox.com/u/40057/patches/input-raw.c
cd ../

Compile the library:

autoreconf -vi
./configure --prefix=/usr
make
make install
ldconfig

Modify tslib configuration

vi /usr/etc/ts.conf

Uncomment the following line:

module_raw input

Export tslib needed variables:

export TSLIB_TSEVENTTYPE=raw
export TSLIB_CONSOLEDEVICE=none
export TSLIB_FBDEVICE=/dev/fb0
export TSLIB_TSDEVICE=/dev/input/event0
export TSLIB_CALIBFILE=/usr/etc/pointercal
export TSLIB_CONFFILE=/usr/etc/ts.conf
export TSLIB_PLUGINDIR=/usr/lib/ts

Now tslib is working but still it should be set as default driver in the X:

wget http://ftp.de.debian.org/debian/pool/main/x/xf86-input-tslib/xf86-input-tslib_0.0.6.orig.tar.gz
tar zxfv xf86-input-tslib_0.0.6.orig.tar.gz
cd xf86-input-tslib-0.0.6/

Replace tslib.c file with patched one:

cd src/
rm -f tslib.c 
wget https://dl.dropbox.com/u/40057/patches/tslib.c
cd ..

Build and install package:

./configure --prefix=/usr
make
make install

Add tslib configuration:

cd /usr/share/X11/xorg.conf.d/

Make new file:

nano 20-touchscreen.conf

Add the following text inside:

Section "InputClass"
       Identifier "AR1020"
       MatchDevicePath "/dev/input/event0"
       Driver "tslib"
       Option "Device" "/dev/input/event0"
       Option "ScreenNumber" "0"
       Option "Rotate" "NONE"
       Option "Width" "800"
       Option "Height" "480"
       Option "SendCoreEvents" "yes"
       Option "Type" "touchscreen"
EndSection

Note! Resolution in this example is set for 7 inch LCD.

Do the actual calibration:

service lightdm stop
ts_calibrate
service lightdm start

After lightdm start you could check if everything is running smoothly.

Save tslib variables:

vi /etc/environment

Paste the following:

TSLIB_TSEVENTTYPE=raw
TSLIB_CONSOLEDEVICE=none
TSLIB_FBDEVICE=/dev/fb0
TSLIB_TSDEVICE=/dev/input/event0
TSLIB_CALIBFILE=/etc/pointercal
TSLIB_CONFFILE=/usr/etc/ts.conf
TSLIB_PLUGINDIR=/usr/lib/ts

If you change the LCD panel run ts_calibrate to configure touchscreen for the new LCD.

Calibrate using AR1021 driver

Wireless

RTL8188CUS

MOD-WIFI-RTL8188

To connect OLinuXino board with wireless, you could use MOD-WIFI-RTL8188 dongle. Also you can use another one with the same chip.

MOD-WIFI-RTL8188 has the following features:

Has WM-294 module with RTL8188
Operates in 2.4 GHz frequency bands
1x1 MIMO technology improves effective throughput and range over existing 802.11 b/g products
Data rates: up to 150Mbps
802.11e-compatible bursting and I standards BPSK, QPSK, 16 QAM, 64 QAM modulation schemes WEP, TKIP, and AES, WPA, WPA2 hardware encryption schemes
Standard USB type A connector
On-board antenna
5V/3.3V operation modes via SMD jumper
4 test pads for easy tracking the supply, d-, d+, and GND
PCB: FR-4, 1.00 mm (0,039"), solder mask, silkscreen component print
Dimensions: 65.15x20.38 mm (2.56x0.80")

The kernel module is prebuild. You should just get it loaded and then plug the dongle.

Load the module:

modprobe 8192cu

Plug the device and check if it is available:

ifconfig -a

RT5370

MOD-WIFI-R5370-ANT

To use one this wifi dongle (like MOD-WIFI-R5370 or MOD-WIFI-R5370-ANT) additional files are required. You can skip this procedure if you're using Olimex prebuild image.

Make new directory

mkdir -p /etc/Wireless/RT2870STA
cd /etc/Wireless/RT2870STA/

This is the directory where the module will search for files.

Download the files from Github

wget https://raw.githubusercontent.com/SelfDestroyer/RK3188-SOM/olimex/stable-3.0/drivers/net/wireless/rtxx7x/RT2870STA.dat
wget https://raw.githubusercontent.com/SelfDestroyer/RK3188-SOM/olimex/stable-3.0/drivers/net/wireless/rtxx7x/RT2870STACard.dat

Load module

modprobe rt5370sta

Plug the device and run:

ifconfig -a

You should see this:

wlan0     Link encap:Ethernet  HWaddr 00:00:00:00:00:00
          BROADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

Configure your new device:

vi /etc/network/interfaces

Add configuration. Here we will show DHCP configuration.

iface wlan0 inet dhcp
wpa-ssid "your ssid"
wpa-psk "your password"

Save the configuration and up the interface:

ifup wlan0

If everything is working and this module to be loaded on boot:

echo rt5370sta >> /etc/modules

@@ Line 446: / Line 446: @@
 You will need the following files:
 #bootloader --> This is RockChip RK3188Loader
-#parameter --> Parameter file with crc encryption
+#[[parameter]] --> Parameter file with crc encryption
 #boot --> Kernel with ramdisk compiled as shown here
 #linux --> Rootfs image file

Navigation

Tools

Difference between revisions of "RK3188-SOM"

Revision as of 04:00, 29 January 2015

Contents

Overview

Linux

Building parameter file

Building kernel

Creating root filesystem

Debian Wheezy

Installing X

Ubuntu

Prebuild linaro images

Manual build using debootstrap

Make rootfs image

Booting from NAND

Booting from SD-card

Calibrate touchscreen

Calibrate using tslib

Calibrate using AR1021 driver

Wireless

RTL8188CUS

RT5370

Android

Personal tools

Navigation

Tools

Difference between revisions of "RK3188-SOM"

Revision as of 04:00, 29 January 2015

Contents

Overview

Linux

Building parameter file

Building kernel

Creating root filesystem

Debian Wheezy

Installing X

Ubuntu

Prebuild linaro images

Manual build using debootstrap

Make rootfs image

Booting from NAND

Booting from SD-card

Calibrate touchscreen

Calibrate using tslib

Calibrate using AR1021 driver

Wireless

RTL8188CUS

RT5370

Android