Installing Linux on a RK3066 based device


  1. Prerequisites
  2. Create a root filesystem
  3. Build a kernel and create a recovery image
  4. Install the Android SDK
  5. Flash the recovery image
  6. Boot into Linux


This howto presumes an up to date Ubuntu 12.04 64-bit installation. It might work on other distros but then your mileage may vary.

Create a root filesystem

First step is to create a root filesystem on a MicroSD card, in this case a Debian Wheezy rootfs. Basically you can use any armhf root filesystem, be it Ubuntu, Arch, Debian, Fedora etc. You can also use something like Picuntu, but a) it’s based on a non-LTS Ubuntu version which I personally don’t use, b) it’s not a minimal installation and I prefer clean, lean installs and c) I’m using debootstrap to create the root filesystem and that’s almost as much work as downloading Picuntu and putting it on the MicroSD card.

  1. Install the necessary packages
    sudo apt-get install qemu-user-static binfmt-support debootstrap
  2. create an ext4 partition labeled linuxroot on a micro SD card, for example with gparted
  3. Mount the newly created partition on the MicroSD card in /mnt/tmp
    sudo mkdir /mnt/tmp
    sudo mount /dev/sdx1 /mnt/tmp
  4. Then install Debian Wheezy on it
    sudo qemu-debootstrap --verbose --variant=minbase --arch=armhf \
    wheezy /mnt/tmp
  5. Chroot into your freshly installed rootfs
    mount -t proc proc /mnt/tmp/proc
    mount -t sysfs sysfs /mnt/tmp/sys
    mount -o bind /dev /mnt/tmp/dev
    mount -t devpts devpts /mnt/tmp/dev/pts
    chroot /mnt/tmp
  6. Configure the rootfs:
    Use wheezy instead of sid for the source.list part and skip the filesystem mounts part. And you shouldn’t set a password for root but create your own user instead and add this user to the sudo group:
    adduser someuser
    passwd someuser
    addgroup someuser sudo
  7. Unmount the MicroSD card
    sudo umount /mnt/tmp/{proc,sys,dev/pts,dev,}
  8. Reinsert the MicroSD card in your cardreader and make sure it mounts in /media/linuxroot/

Build a kernel and create a recovery image

Next step is to create a kernel. You can of course use one of the precompiled kernels available but I prefer rolling my own so I can tinker with the kernel config a bit. The best howto I could find on compiling your own kernel for RK3066 based devices can be found here:
I’ve adapted it a bit to my situation.

  1. Install the necessary packages to build the kernel
    sudo apt-get install git-core flex bison build-essential gcc-arm-linux-gnueabihf \
    libncurses5-dev zlib1g-dev lib32z1 lib32ncurses5 sharutils lzop

    If you’re building on a 32-bit 12.04 installation you can omit the lib32z1 and lib32ncurses5 packages.
  2. Create a directory for the kernel source and other needed tools
    mkdir -p $HOME/src/rk/mod_fw
    cd $HOME/src/rk
  3. Clone git repo with the mkbootimg tool to create recovery images
    git clone --depth 1
  4. Clone git repo with a RK3066 specific initramfs and create a cpio file out of it
    git clone --depth 1 initramfs
    cd initramfs
    gzip -dc debian-3.0.8+fkubi.cpio.gz > initramfs.cpio
    cd ..
  5. Clone git repo with kernel source tailored for RK3066 based devices
    git clone --depth 1
    cd rk3x_kernel_3.0.36/
  6. Create a build script with the following contents
    export ARCH=arm
    export CROSS_COMPILE=arm-linux-gnueabihf-
    export LOCALVERSION=
    export INSTALL_MOD_PATH=$HOME/src/rk/mod_fw
    MAKE="make -j$(getconf _NPROCESSORS_ONLN)"
    $MAKE mrproper
    cp config.galland .config
    rm -rf $INSTALL_MOD_PATH
    $MAKE modules_install

    Alternatively you can also do it the Debian way
    sudo apt-get install kernel-package

    Build script contents

    export $(dpkg-architecture -aarmhf)
    export CROSS_COMPILE=arm-linux-gnueabihf-
    export LOCALVERSION=
    export DEBIAN_REVISION=0
    export INITRD=YES
    export IMAGE_TYPE=zImage
    cp config.galland .config
    make-kpkg clean
    fakeroot make-kpkg kernel_image

    This will create a deb package called linux-image-3.0.36_0_armhf.deb in the directory above the directory with your kernel source.

  7. Make the script executable
    chmod +x build_rk3066
  8. Run the build script
  9. Generate the recovery.img file that has te be flashed to the recovery partition of the TV stick
    cd ..
    tools/mkbootimg --kernel rk3x_kernel_3.0.36/arch/arm/boot/Image --ramdisk \
    initramfs/fakeramdisk.gz --base 60400000 --pagesize 16384 --ramdiskaddr 62000000 \
    -o recovery.img

Install the Android SDK

In order to be able to communicate with the TV stick from your PC you will need the adb tool. With the adb tool you can tell the stick to boot into different modes, like the recovery or bootloader modes.

  1. Install the following packages
    sudo apt-get --no-install-recommends install openjdk-7-jre lib32stdc++6
  2. Download the Android SDK Tools Only package
    wget -c
  3. untar it and move it to $HOME/android
    tar zxvf android-sdk_r22.0.1-linux.tgz
    mv android-sdk-linux $HOME/android
  4. Install adb
  5. Create an udev rules file /etc/udev/rules.d/51-android.rules with the following content
    SUBSYSTEM=="usb", ATTR{idVendor}=="2207", MODE="0666"
  6. Reload udev rules
    sudo udevadm control --reload-rules
  7. Create $HOME/.android/adb_usb.ini with the following content
    # USE 'android update adb' TO GENERATE.

Flash the recovery image

Now we have to flash the recovery image that contains our kernel to the stick. The advantage of using a recovery image is that you can still use the Android installation on the TV stick. So normally the stick boots into Android but when you force it to boot into recovery mode it will boot into Linux once you’ve flashed it with your custom recovery image.

  1. Make sure you’re still in $HOME/src/rk
  2. Clone git repo with the rkflashtool tool with support for RK3066 based devices
    git clone --depth 1
  3. Compile rkflashtool
    cd rkflashtool_rk3066
  4. Connect the TV stick with the MicroUSB cable to your PC and connect a mouse or keyboard to the USB port of the stick
  5. Once the TV stick has booted into Android go the Setting window, select Advance SettingSystem and select USB settings which should change from Disconnected to Computer to Connected to Computer. You can verify if the TV stick is indeed connected with lsusb on your PC, it should output the USB id of the TV stick
    Bus 003 Device 006: ID 2207:0010
  6. Assuming you have the Android SDK installed on your PC you can now reboot the TV stick into flash mode
    $HOME/android/platform-tools/adb reboot bootloader
    The TV stick should now reboot into flash mode. It will now have a different USB id so check with lsusb again, it should output the following id
    Bus 003 Device 014: ID 2207:300a
  7. Now flash the stick
    Stock ROM:
    ./rkflashtool w 0x00010000 0x00008000 < ../recovery.img
    Finless ROM:
    ./rkflashtool w 0x00014000 0x00008000 < ../recovery.img
    and reboot
    ./rkflashtool b
    This should reboot the stick into Android again
  8. Repeat step 5 and have the stick reboot into recovery to test if the kernel loads properly
    $HOME/android/platform-tools/adb reboot recovery

An alternative method to boot the TV stick into flash mode would be to hold down the reset button of your device when powering it up or if your device doesn’t have a reset button, find the pads on the PCB that boot the device in flash mode and short those when powering up. More info on shorting pads can be found here.

Boot into Linux

On to the last part, booting the TV stick with your Debian Wheezy installation. Before doing so you will have to copy the modules and firmware that you’ve created when building the kernel on to your MicroSD card. Then you can insert the MicroSD into the TV stick and have it boot into recovery mode. It should then boot into your Debian Wheezy installation.

  1. The MicroSD card should still be mounted on /media/linuxroot. Copy the modules and firmware
    sudo cp -a $HOME/src/rk/mod_fw/lib/* /media/linuxroot/lib/
    sudo chown -R root: /media/linuxroot/lib/{firmware,modules/3.0.36}
    If you went the Debian way:
    sudo cp $HOME/src/rk/linux-image-3.0.36_0_armhf.deb /media/linuxroot/tmp
    mount -t proc proc /media/linuxroot/proc
    mount -t sysfs sysfs /media/linuxroot/sys
    mount -o bind /dev /media/linuxroot/dev
    mount -t devpts devpts /media/linuxroot/dev/pts
    chroot /media/linuxroot
    dpkg -i /tmp/linux-image-3.0.36_0_armhf.deb
    sudo umount /media/linuxroot/{proc,sys,dev/pts,dev}
  2. Unmount the MicroSD card and insert it in your TV stick
  3. Boot the TV stick and repeat step 8 of the Flash the recovery image part
  4. Your TV stick should now boot into Debian Wheezy. To initialize all modules run depmod -a as root (not necessary if you went the Debian way).