PINE64 - Rock64 Tutorials

Setting up a Rock64 v3 for klipper / mainsail over serial

Wed, 14 Jan 2026 13:06:32 +0000

Just thought if anyone was thinking/trying to use a rock64 to control their 3d printers with Klipper / Mainsail over serial, that this might help
I did this with four rock64 v3 and got everyone working exactly like my pis, controlling 2 Prusa MK3S each.
I am not a Linux user, I managed to piece this together for the first one and the other 3 went smoothly following this.
Some of these steps may be redundant or unnecessary, but the result is that it works.

Base Setup:

Wipe SD card with SD Card Formatter
Download and use Armbian Imager to image SD
select board and OS
I used OS Minimal 25.5.1 bookworm

sudo apt update && sudo apt upgrade
sudo apt-get install git -y
sudo apt install network-manager
sudo reboot

Set up wifi dongle: (you may need specific firmware for brand if not Linux native. Mine was, I used a Ralink dongle)

nmcli device wifi list
nmcli dev wifi connect "Your_WiFi_SSID" password "Your_WiFi_Password"
nmcli device status
sudo reboot

Setup Mailsail and klipper, just follow prompts to install 1-3 or follow a guide for Kiauh:

cd ~ && git clone https://github.com/dw-0/kiauh.git
./kiauh/kiauh.sh
(install 1, 2, and 3)
sudo reboot
sudo apt update && sudo apt upgrade

Reduced bootup time for no Lan connection from 2min to 10 sec:

find / -name "systemd-networkd-wait-online.service"
(This should be the location, but confirm with the find)
sudo nano /etc/systemd/system/network-online.target.wants/systemd-networkd-wait-online.service

(add text under [Service])
TimeoutStartSec=10

(At this point you could run klipper over a usb to the printer
Mailsail/klipper web GUI is whatever IP the rock64 or wifi dongle grabs
It will be at the top of the screen when you ssh/login)

Tx/Rx setup on UART2/tty2:

sudo apt update && sudo apt upgrade

1.Overlays
sudo armbian-config
system>kernel>boot01
(added text to boot/armbianEvn.txt under overlay)
overlays=rk3328-uart1 rk3328-uart2 rk3328-uart3

2.Kernel
sudo armbian-config
system>kernel>ker001 - alt kernel
updated to the newest rock kernel

3.disabled console
sudo systemctl mask serial-getty@ttyS2

4. Added users to dialout group
sudo usermod -a -G dialout
(confirm user is in dialout group)
groups

5. echo test with jumper if you want(jump the UART2 Tx and Rx pins(8,10) together with a wire, no ground needed)
sudo apt install picocom
sudo picocom -b 115200 -r -l /dev/ttyS2

Type anything, if writing appears port is working
ctrl a then ctrl x to exit

In your printer.config file under the MCU you will use
serial: /dev/ttyS2

Happy Printing!!!

Help getting started

Thu, 30 Sep 2021 18:22:42 +0000

Greetings all, I'm a brand newbie to the Rock64, after purchasing one from an Ebay vendor. I have some exxperience with the Raspberry Pi, as well as some Ubuntu experience on one of my laptops. I therefore wanted to try Ubuntu 18.04 OS. but I'm having trouble understanding how to get it on an SD. I read the instructions, which sound very similar to the Raspberry Pi way of doing it, IE: downloading image, placing the image file on the microsd card via Win32 Imager (Using Win10 laptop) plug it in and go.
The Win32 Imager is looking for a .img file. What was downloaded from the github site was a .img.tar file. Not being sure how to deal with that, I unzipped the .tar and lo and behold there were 7 different images in the tar. Can someone please explain to me how to deal with this? Thanks.

Rock64 - Simple Bare-Metal Example

Fri, 05 Jun 2020 13:27:29 +0000

Hi,

I wrote a simple Bare-Metal example for the Rock64.
It just sends a few strings over the UART interface and if a special char will be received, the program resets the Rock64.

The main entry point of the program (written in Assembler):

Code:
#include 

IMPORT_C(kern_main)

.text

ENTRY(_start)

    mrs x0, SCTLR_EL1

    and x0, x0, #0xFFFFFFFFFFFFFFFC

    msr SCTLR_EL1, x0

    mrs x0, SCTLR_EL2

    and x0, x0, #0xFFFFFFFFFFFFFFFC

    msr SCTLR_EL2, x0

    mrs x0, MPIDR_EL1

    and x0, x0, #0x3

    cmp x0, #0

    beq L1

L0:

    wfe

    b L0

L1:

    ldr x0, =_kern_stack_s

    mov sp, x0

    b kern_main

L2:

    wfe

    b L2

.end

It's a minimal setup. It just disables the MMU and the Alignment checks.
Then it reads the processor ID and let only CPU0 run the C main entry point (kern_main).

The C main entry point:

Code:
#include 

#include 

void kern_main(void)

{

    int c;

    uart_init();

    uart_puts("Pine64 Rock64\r\n");

    uart_puts("Press 'r' to reset the board!\r\n");

    do {

        c = uart_getc();

    } while (c != 'r');

    uart_puts("Resetting...\r\n");

    cru_reset();

    while (1)

        ;

}

Should be self explaining.

There is also as very simple UART driver and the CRU driver for resetting the board.
The code includes a very minimal C String library.Only GCC for AArch64 is needed.

To start the application, U-Boot is needed.

I have attached the full code.
The code is also on my GitHub page available.

Edit:
Oops! There is a bug in the attached archive.

Simple change the following line in the file start.S...

Code:
ldr x0, =_kern_stack_s

to..

Code:
ldr x0, =_kern_stack_e

bare-metal.tar.gz (Size: 4.47 KB / Downloads: 706)

Still trying to upgrade

Sun, 05 Jan 2020 11:16:01 +0000

Manage to get the system to carry out upgrade to LXDE version 0.8.3 but on reboot the boot sequence runs and then the screen goes blank with the cursor flashing. Reboot gives the same result. Any help please.

Updating LXDE to latest version

Fri, 03 Jan 2020 23:07:58 +0000

I have an early version of ayufan LXDE and have tried to update it to a later version using apt-get update but all I get is a number of errors. So for a relative beginner can you tell me how to achieve an update. I have loaded a later version on another micro sd and there are some improvements to the graphics performance but I have some software that I have bought and cannot run this on an entirely new system. Thank You

Manual: Howto cross-compile Upstream U-Boot for rock64

Sat, 02 Nov 2019 20:59:01 +0000

Step 1: Get the file bl31.elf
You can build ATF with Upstream arm-trusted-firmware repository to get the file “bl31.elf” (Way 1) or you use the rk322xh_bl31_vXXX.elf file from rockchip rkbin repository (Way 2)

Way 1 (build ATF with Upstream arm-trusted-firmware repository to get “bl31.elf”)
Install the required packages (Debian / Ubuntu):

Code:
sudo apt-get install --no-install-suggests --no-install-recommends device-tree-compiler build-essential gcc make git libssl-dev

To cross-compile:

Code:
sudo apt-get install --no-install-suggests --no-install-recommends cpp-10-aarch64-linux-gnu gcc-10-aarch64-linux-gnu gcc-10-aarch64-linux-gnu-base libasan6-arm64-cross libatomic1-arm64-cross libc6-arm64-cross libgcc-10-dev-arm64-cross libgcc-s1-arm64-cross libgomp1-arm64-cross libitm1-arm64-cross liblsan0-arm64-cross libstdc++6-arm64-cross libtsan0-arm64-cross libubsan1-arm64-cross cpp-aarch64-linux-gnu gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu gcc-10-cross-base

Go into your Download folder and open Terminal there, then run:

Code:
git clone https://github.com/ARM-software/arm-trusted-firmware

cd arm-trusted-firmware

Optional 4:
Verify code archive integrity (see also: https://restic.net/blog/2015-09-16/verif...-integrity ).

Replace in the following Y.Y with the tag version number

Download pgp-key from the developer (you can find the gpg key ID on https://github.com/ARM-software/arm-trus...mware/tags) who has signed the tag, check fingerprints, import key and verify tag: Go into arm-trusted-firmware folder and run the following command and verify the fingerprint:

Code:
git tag --verify vY.Y

Now create a archive that contain the same repository as the release with the tag version, run in arm-trusted-firmware folder the following command:

Code:
git archive --format=tar --prefix=arm-trusted-firmware-Y.Y/ vY.Y | gzip -n > arm-trusted-firmware-Y.Y.tar.gz

Show the sha256 checksum from the archive that contain the repository from the release with the tag version and show sha256 checksum from the same archive https://github.com/ARM-software/arm-trus...Y.Y.tar.gz which belongs to the tag and compare the checksums:

Code:
sha256sum arm-trusted-firmware-Y.Y.tar.gz

Code:
curl -s -L https://github.com/ARM-software/arm-trusted-firmware/archiv/vY.Y.tar.gz | sha256sum

End of the optional section 4

Code:
cd arm-trusted-firmware

make CROSS_COMPILE=aarch64-linux-gnu- PLAT=rk3328 DEBUG=1 bl31 ERRATA_A53_836870 ERRATA_A53_1530924

Software Developers Errata Notice: developer.arm.com/documentation/epm048406/2100/

Go into your Download folder and open Terminal, then run:

Code:
git clone git://git.denx.de/u-boot.git

or Download U-Boot source tree from https://ftp.denx.de/pub/u-boot/
(How to verify downloaded file with .sig file: https://stackoverflow.com/questions/1533...h-sig-file )

Search now the “bl31.elf” file in the arm-trusted-firmware build folder and copy it in the U-Boot folder.

Way 2 (use “bl31.elf” file from rockchip rkbin repository)
Go into your Download folder and open Terminal, then run:

Code:
git clone git://git.denx.de/u-boot.git

or Download U-Boot source tree from ftp://ftp.denx.de/pub/u-boot/
(How to verify downloaded file with .sig file: https://stackoverflow.com/questions/1533...h-sig-file )

Go back into your Download folder and open Terminal, then run:

Code:
git clone https://github.com/rockchip-linux/rkbin

cd rkbin

Search the file „rk322xh_bl31_vX.XX.elf“ in the rkbin folder (current version is v1.42, this file is in bin/rk33/) and change the name of this file to „bl31.elf“ and copy it in the U-Boot folder.

Step 2:
Compile U-Boot Install the required packages (for latest Debian):

Code:
sudo apt-get install --no-install-suggests --no-install-recommends bison dh-python flex gcc-10 libexpat1-dev libmpdec3 make mime-support swig4.0 u-boot-tools cpp-10 libpython3.9-stdlib libpython3.9-dev libpython3.9-minimal libpython3.9 python3.9 python3.9-minimal python3-distutils python3-lib2to3 python3-pkg-resources python3-setuptools python-pip-whl python3-pip python3.9-dev device-tree-compiler build-essential git libssl-dev

To cross-compile:

Code:
sudo apt-get install --no-install-suggests --no-install-recommends cpp-10-aarch64-linux-gnu gcc-10-aarch64-linux-gnu gcc-10-aarch64-linux-gnu-base libasan6-arm64-cross libc6-arm64-cross libgcc-10-dev-arm64-cross libgcc-s1-arm64-cross libgomp1-arm64-cross libitm1-arm64-cross liblsan0-arm64-cross libstdc++6-arm64-cross libtsan0-arm64-cross libubsan1-arm64-cross cpp-aarch64-linux-gnu gcc-aarch64-linux-gnu gcc-10-cross-base libatomic1-arm64-cross swig

Code:
cd u-boot

make CROSS_COMPILE=aarch64-linux-gnu- BL31=bl31.elf rock64-rk3328_defconfig

Code:
make CROSS_COMPILE=aarch64-linux-gnu- BL31=bl31.elf all

Flash U-Boot to microSD card Create partition with fdisk:
(replace sda1 with the name of your microSD card with number (you can find it with fdisk -l))

Code:
sudo umount /dev/sda1

(replace sda with the name of your microSD card but now in the following without number (you can find it with fdisk -l))

Code:
sudo fdisk /dev/sda

d

o

n

Enter

Enter

Enter

First sector (2048-62333951, default 2048): 32768

Enter

w

sudo mkfs.ext4 /dev/sda1 (with number!)

Code:
sudo fdisk /dev/sda

p

Quote:At “Boot” must be a * if there is not a * then press “a” and then “w”

Code:
w

End of fdisk instructions.

Now run this command:

Code:
sudo umount /dev/sda1

Quote:Replace sda1 with the name of your microSD (with number at the end)

Open Terminal in the U-Boot folder and flash U-Boot to microSD card with following commands (you can find the name of your microSD card with e.g. gparted, we search for example /dev/sda (without number! not /dev/sda1)):

Code:
sudo dd if=./idbloader.img of=/dev/sda seek=64

sudo dd if=./u-boot.itb of=/dev/sda seek=16384

MIT License: https://avg7.de/forum/sicheres-alpine-li...pierrechte
Copyright © 2023 AVG7.de

Debian Stretch Minimal complete install LXDE

Fri, 15 Mar 2019 13:59:01 +0000

Rock64 4Gb RAM "Debian Stretch Minimal" How do install the complete LXDE graphic environment or other work ??

Step by step guide PXE diskless configuration.

Thu, 15 Nov 2018 21:30:09 +0000

I haven't find a guide to setup a proper PXE boot for Rock64 (and Pine64) cards, so I will write down mine here hoping that it is useful.

In this guide I assume that the user is familiar with Linux, another assumption is about the distributions:
- on the Rock64 card we are going to install the Debian minimal;
- on the server that will provide the operating system I use Debian.
I think this guide can work for other distributions too but I haven't tried other combinations.
For the rest of the guide all the commands will run on the server Debian.

About the hardware I tried on a Rock64pro, I have also a Pine64 and a Rock64 but are in production and I needed a spare board to do the tests. Now that it works I will try also for the others, but for this guide I assume the Rock64pro.

Step 1: Flash the SPI
This is actually the only step that requires an SD card.
The SPI is a little memory (128MB) that can be flashed to add instruction at the boot time. Ayufan has a nice SPI image that adds the possibility to boot from network (PXE), and we are going to use it.

So go to this link and download the image file that is useful for your system. I used the u-boot-flash-spi-rockpro64.img.xz file.
Uncompress it with

Code:
unxz u-boot-flash-spi-rockpro64.img.xz

and flash it on the SD card with dd

Code:
dd bs=1M if=u-boot-flash-spi-rockpro64.img of=/dev/sd

Put the card into the Rock64 board and boot it. I had no monitor connected so I do not know what it writes on a screen, but it is enough that you wait some time (one minute is probably enough) and you will see the boot (white) led flashing once per second. It means that the SPI is flashed. You can now turn off the board and remove the SD card.
Step 2: find the ethernet address of the board.
I assume that you have already a DHCP server installed in your network that assign the addresses to every device connected.
If this DHCP server is the router of your internet connection you will have to change it later (unless is a very advanced router and you can specify advanced features). In any case to identify the mac address is sufficient that something assign an IP address to your board.
So turn on your Rock64. It will now spin up and try to boot from SD, eMMC, USB and PXE, and it will fail in all of these tentatives because it has no cards installed and the network boot is not yet configured. Nevertheless, when it tries the PXE the board will get an IP and it will announce its existence to the local network. This means that after few seconds that the ethernet led flashes you can write on your Debian server

Code:
arp -a

and you will get the list of connected devices on the network with their IP address and hardware address.
Write down the ethernet address; the one that I will use in my example is 56:31:cd:bb:92:7b.
Step 3: the DHCP server.
We need a DHCP server capable of some advanced features if you have the DHCP on your router you have to disable it and from this moment on you will use the DHCP on your Debian server.
Install it with

Code:
sudo apt-get install isc-dhcp-server

Once installed edit the /etc/dhcp/dhcpd.conf in this way

Code:
ddns-update-style none;

option domain-name "whatever.com";

option domain-name-servers 192.168.0.1;

default-lease-time 6000;

max-lease-time 72000;

log-facility local7;

subnet 192.168.0.0 netmask 255.255.255.0 {

   range 192.168.0.2 192.168.0.99;

   option subnet-mask 255.255.255.0;

   option broadcast-address 192.168.0.255;

   option routers 192.168.0.1;

   option domain-name-servers 192.168.0.1;

}

host rock64pro {

  hardware ethernet 56:31:cd:bb:92:7b;

  fixed-address 192.168.0.100;

  next-server 192.168.0.1;

}

authoritative;

I don't want to go into the details but basically this configuration allocates random addresses between 192.168.0.2 and 192.168.0.99 for the normal devices (like computers or telephones) and assign the 192.168.0.100 to the rock64pro identifying it with the ethernet address that we find in the previous step. Moreover, and this is the advanced feature, the server will tell to the rock64pro that after it takes the address it has to communicate with 192.168.0.1 for "further instructions" (the next-server directive).
Here I am assuming that 192.168.0.1 is the IP address of the Debian server.
Once this file is in place restart the DHCP server with

Code:
sudo systemctl restart isc-dhcp-server

You can test if this configuration works turning on the Rock64pro board, waiting couple of seconds and try again the arp -a. If everything is fine you should see that now the Rock has the address 192.168.0.100.

Step 4: TFTP server
We have now to instruct the Rock64pro for the next step. The way to take information is through a special version of an ftp server called tftp (t is for trivial). So we need a tftp server running on our Debian and to install it we do

Code:
sudo apt-get install tftp-hpa

once installed edit the file /etc/defaults/tftpd-hpa as

Code:
TFTP_USERNAME="tftp"

TFTP_DIRECTORY="/storage/pxe-boot/tftp"

TFTP_ADDRESS="192.168.0.1:69"

TFTP_OPTIONS="--secure"

here I am assuming that we will store the data to boot the Rock64pro into a directory /storage/pxe-boot and in this directory we will put all the files for the boot and for the operating system.
So we need to do these steps

Code:
sudo mkdir /storage

sudo mkdir /storage/rock64pro

sudo mkdir /storage/tftp

sudo mkdir /storage/tftp/pxelinux.cfg

In rock64pro we will put the operating system (the content of the boot image) while in the tftp we will put all the files to the initial boot procedure (linux kernel and its configurations).
Now we can restart the tftp server

Code:
sudo systemctl restart tftpd-hpa

Step 5: NFS server
The kernel and the boot execution is provided through the tftp server, but the operating system will live entirely on a folder that will be served to the rock64pro through NFS, so we need a working NFS server.
To install it

Code:
sudo apt-get install nfs-kernel-server rpcbind

the edit the file /etc/exports as

Code:
/storage/pxe-boot/rock64pro     *(rw,sync,no_root_squash)

and the file /etc/hosts.allow as

Code:
portmap: 192.168.0.

The first file says to NFS server that has to export the directory /storage/pxe-boot/rock64pro to everyone with specific flags (read/write, sync, and no limitation for root). The second file allows the IPs of the subnet 192.168.0.x to connect to the NFS server. You may want to limit the NFS server only to the IP of the rock64pro substituting 192.168.0.100 to the * of the exports file and writing the full ip into the hosts.allow.
Restart the NFS server with

Code:
sudo systemctl restart nfs-kernel-server

Step 6: setup the filesystem
Download the Debian image for your Rock card from this link (you can use wget). I used the stretch-minimal-rockpro64-0.7.11-1075-arm64.img.xz. Uncompress it with

Code:
unxz stretch-minimal-rockpro64-0.7.11-1075-arm64.img.xz

Once downloaded you have to mount the linux partition contained in the img file. The file contains also another partition that is to boot and we are not interested in it, so we have to find the right position of the linux. To do it we use fdisk as

Code:
sudo fdisk -l stretch-minimal-rockpro64-0.7.11-1075-arm64.img

the result is something like

Code:
Disk stretch-minimal-rockpro64-0.7.11-1075-arm64.img: 2 GiB, 2144337920 bytes, 4188160 sectors

Units: sectors of 1 * 512 = 512 bytes

Sector size (logical/physical): 512 bytes / 512 bytes

I/O size (minimum/optimal): 512 bytes / 512 bytes

Disklabel type: gpt

Disk identifier: FB84DCAE-4E0E-486F-890C-A979BEECCFF9

Device                                            Start     End Sectors  Size Type

stretch-minimal-rockpro64-0.7.11-1075-arm64.img1     64    8063    8000  3.9M Linux filesystem

stretch-minimal-rockpro64-0.7.11-1075-arm64.img2   8064    8191     128   64K Linux filesystem

stretch-minimal-rockpro64-0.7.11-1075-arm64.img3   8192   16383    8192    4M Linux filesystem

stretch-minimal-rockpro64-0.7.11-1075-arm64.img4  16384   24575    8192    4M Linux filesystem

stretch-minimal-rockpro64-0.7.11-1075-arm64.img5  24576   32767    8192    4M Linux filesystem

stretch-minimal-rockpro64-0.7.11-1075-arm64.img6  32768  262143  229376  112M Microsoft basic data

stretch-minimal-rockpro64-0.7.11-1075-arm64.img7 262144 4186111 3923968  1.9G Linux filesystem

Here you have to identify two things: the first one is the size of one unit sector (512 bytes) and the second information is the begin of the filesystem that we are looking for. In our case it is the last one and we know because is the one of 1.9GB of size. Then this filesystem starts at the position 262144. Now we multiply these two numbers: 512x262144=134217728. This is the starting position of the linux partition. We can use it to mount the partition as

Code:
sudo mkdir /storage/tmpimage

sudo mount -o loop,offset=134217728 stretch-minimal-rockpro64-0.7.11-1075-arm64.img /storage/tmpimage

now we copy the content of the filesystem into our nfs server. I use rsync to do it because I trust the way it preserves permissions and links, but probably a simple cp -a can do the job.

Code:
sudo rsync -val /storage/tmpimage/* /storage/pxe-boot/rock64pro/

After the sync the image is no longer needed

Code:
sudo umount /storage/tmpimage

sudo rmdir /storage/tmpimage

sudo rm stretch-minimal-rockpro64-0.7.11-1075-arm64.img

Step 7: Finalize the boot
We have now the system ready, we need only to put in the tftp directory the instructions to send the kernel to the board for the boot.
To do this we first copy the boot folder of the rock64pro filesystem to the tftp directory. We need to do it because we need to provide the kernel via tftp before mounting the NFS root.

Code:
sudo rsync -val /storage/pxe-boot/rock64pro/boot /storage/pxe-boot/tftp/

finally we need to provide to the board the extlinux.conf boot file. When the Rock boots it searches for a boot file with various names, we will use the pxelinux.cfg/default-arm-rockchip. So we first copy the extlinux.conf as

Code:
sudo cp /storage/pxe-boot/tftp/boot/extlinux/extlinux.conf /storage/pxe-boot/tftp/pxelinux.cfg/default-arm-rockchip

then we need to edit this file because by default it will try to load the kernel from the storage device (SD Card) but we want to mount the root directory from the nfs server. So edit it, remove the second block and modify the line of root as the following

Code:
timeout 10

menu title select kernel

label kernel-4.4.154-1124-rockchip-ayufan-ged3ce4d15ec1

    kernel /boot/vmlinuz-4.4.154-1124-rockchip-ayufan-ged3ce4d15ec1

    initrd /boot/initrd.img-4.4.154-1124-rockchip-ayufan-ged3ce4d15ec1

    devicetreedir /boot/dtbs/4.4.154-1124-rockchip-ayufan-ged3ce4d15ec1

    append rw panic=10 init=/sbin/init coherent_pool=1M ethaddr=${ethaddr} eth1addr=${eth1addr} serial=${serial#} cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory swapaccount=1 root=/dev/nfs nfsroot=${serverip}:/storage/pxe-boot/rock64pro rootwait rootfstype=ext4

the only part to modify is the root= and the nfsroot= the rest of the file is the same as the extlinux.conf.
Finally, the SD card mounts the boot directory from a vfat partition while we are using our tftp boot, so we need to fix this.
The way is to edit the file /storage/pxe-boot/rock64pro/etc/fstab and remove the line about the boot (that should be the only one, so the final file will be empty).
Known Issues.
The reboot does't work always. It seems that the tftp server stucks and doesn't work in the next boot. I will try another tftp server.
The workaround is to force kill the tftpd and restart it.

If in the update process some component of the boot is upgraded, it is necessary to update the tftp boot folder and the pxelinux.cfg/default-arm-rockchip.

Install Standard Debian (upstream)

Sun, 19 Aug 2018 20:26:56 +0000

Greetings everybody,

Today on my quest to enable the rock64 for my purposes I had just one goal:
Install upstream debian testing (buster) without any customizations.

Sadly I did not achieve this goal fully; However I believe I got extremely close. See below for the one bugreport I opened to have the last piece upstreamed.

So here are the steps from an existing debian system running on the board (mostly in pseudo-code because the difficulty level isn't novice):

0. Install U-Boot to SPI Flash
- https://github.com/ayufan-rock64/linux-u-boot/releases

1. Partition (e)MMC
- 100MiB EFI partition (fat)
- 1GiB boot partition (ext4)
- 57GiB rootfs partition (f2fs)

2. mount filesystems
- rootfs: /mnt
- boot: /mnt/boot
- efi: /mnt/boot/efi

3. bootstrap debian
- debootstrap --arch=arm64 --variant=minbase buster /mnt http://deb/debian.org/debian

4. mount additional filesystems
- mount -vt sysfs sysfs /mnt/sys
- mount -vt proc proc /mnt/proc
- mount --bind /dev /mnt/dev
- mount --bind /dev/pts /mnt/dev/pts
- mount --make-rslave /mnt/dev
- mount --make-rslave /mnt/dev/pts

5. install additional software
- tasksel ssh-server (this is a little messy in a chroot)
- apt install linux-image-arm64 grub-efi-arm64
- apt install ifupdown locales

6. configure system
- /etc/initramfs-tools/modules: f2fs
- /etc/default/grub: GRUB_CMDLINE_LINUX="earlycon=uart8250,mmio32,0xff130000 console=ttyS2,1500000"
- /etc/default/grub: if [ -z "$GRUB_DEVICE_UUID" ] && [ -n "$GRUB_DEVICE" ]; then GRUB_DEVICE_UUID=`blkid -s UUID -o value "$GRUB_DEVICE"`; fi
- dpkg-reconfigure locales
- dpkg-reconfigure tzdata
- /etc/network/interfaces: auto eth0
- /etc/network/interfaces: iface eth0 inet dhcp
- /etc/network/interfaces: iface eth0 inet6 auto

7. make it bootable
- update-initramfs -u
- grub-install --target=arm64-efi --removable
- update-grub
- copy /usr/lib/linux-image-4.17.0-1-arm64/rockchip/rk3328-rock64.dtb to /boot/efi/rockchip/rk3328-rock64.dtb

At this point the system could be rebooted and should automagically start up through grub.However one piece is still missing:
When the DTB gets updated with a new debian kernel, the copy on the EFI partition has to be updated as well.
For this we use the debian specific flash-kernel application by adding the following entry to /etc/flash-kernel/db:

Code:
Machine: Pine64 Rock64

Boot-DTB-Path: /boot/efi/rockchip/rk3328-rock64.dtb

DTB-Id: rockchip/rk3328-rock64.dtb

This bit of magic makes sure that on every kernel update the rk3328-rock64.dtb gets copied to the EFI partition where U-Boot can load it *before* executing grub.
This is necessary because grub-mkconfig can not guess where the devicetree is and how it is called.
I have opened a bugreport against debian to have this piece included upstream: https://bugs.debian.org/cgi-bin/bugrepor...bug=906696

I strongly believe that debian-installer could be used from a usb drive to install debian. It would be much easier than the instructions above, especially when a preseed file is used for automation.

Using the Movidius NCS with rock64

Mon, 02 Jul 2018 15:51:12 +0000

hello friends,

Although the movidius NCS doesn't officially support the rock64, I was able to modify the install scripts to get it working. I went with the Bionic-LXDE operating system (since it appears to be the most stable DE). Note that this is version 1 of the SDK. Future plans is to convert version 2 soon.

I created a github repo with instructions on how to set everything up
https://github.com/markjay4k/ncsdk-aarch64

basically just

Code:
git clone https://github.com/markjay4k/ncsdk-aarch64.git

cd ncsdk-aarch64

sudo make install

source ~/.bashrc

sudo make api

If you want to install tensorflow, I made an aarch64 version

Code:
git clone https://github.com/markjay4k/Tensorflow-1.9rc0-py36-aarch64.git

pip3 install Tensorflow-1.9rc0-py36-aarch64/tensorflow-1.9.0rc0-cp36-cp36m-linux_aarch64.whl

then, to build the examples, run

Code:
sudo make examples

Also you can watch a video I made that goes through all the steps as well
https://www.youtube.com/watch?v=AXzIYk7-...ibk0h00410

good luck!!

Mark Jay

OMV - transmission watch fix

Sun, 18 Feb 2018 23:18:20 +0000

How to fix "watch" in OMV - transmission plugin:

Watch option checks for *.torrent files in folder and starts downloading them straight away.
OMV by default doesn't let users use Internal memory.
Yes, even home folders (if enabled) are stored on external drive (as a workaround they can be symlinked).

For some reason if "watch" folder is pointed to external drive and file added by SMB share, it checks the "watch" folder only once when daemon start.

Here is quick fix:

In OMV Samba config add to additional options for symbolic links supoprt:

Code:
follow symlinks = yes

unix extensions = no

wide links = yes

allow insecure wide links = yes

create symlink (either manually or via "openmediavault-symlinks" extension)

make sure appropriate rights are given to linked folder (chmod 777)

Point Watch directory to symlinked folder (as OMV doesn't support internal storage).

Restart Rock64

Now Watch should work properly. It does for me at least

Guide - XRDP - Debian Stretch / Ubuntu Xenial / OMV

Wed, 07 Feb 2018 11:02:15 +0000

Preface

This quick and simple guide will show how to connect to your Rock64 with Windows native Remote Desktop Connection client.

Prerequisites

ROCK64 board running Debian or Ubuntu, connected to the local network

Access to terminal, either locally or via SSH

Some basic understanding of using the linux terminal

____________________

Debian:

Make sure you do not have any other VNC servers installed like vnc4server or tightvncserver.

Code:
sudo apt remove xrdp vnc4server tightvncserver

Install xrdp and tigervnc server

Code:
sudo apt install -y xrdp tigervnc-standalone-server

Swap places Xorg with Xvnc so Xvnc goes first.

Code:
sudo nano /etc/xdrp/xdrp.ini

Connect via Xvnc (first in the client list) with native Windows Remote Desktop client.

Ubuntu (the same setup as Raspberry PI):

Remove other VNC servers

Code:
sudo apt-get remove xrdp vnc4server tightvncserver

Install tightvncserver and xrdp

Code:
sudo apt install -y tightvncserver xrdp

Connect via Xorg (first in the client list) with native Windows Remote Desktop client.

OMV armhf:

Download:
libssl1.0.0_1.0.1t-1+deb8u7_armhf.deb
https://packages.debian.org/jessie/armhf...0/download

xrdp_0.6.1-2_armhf.deb
https://packages.debian.org/jessie/armhf/xrdp/download

Code:
sudo dpkg -i libssl1.0.0_1.0.1t-1+deb8u7_armhf.deb

sudo dpkg -i xrdp_0.6.1-2_armhf.deb

A guide for how I made RetroPie, RetroArch, and EmulationStation Work on the Rock64

Fri, 15 Dec 2017 21:21:59 +0000

So first off, while I'm a "professional computer guy", my expertise is Microsoft stuff, so before getting my raspberry pi 3 I had very little linux experience. The RPI3 has a lot of downloadable images that basically "just work" out of the box, but ROCK64 doesn't have that benefit yet. And with the more powerful hardware on this platform, I have been excited to figure this out... but to get it up and running I've had to learn quickly and do a lot of research.

After banging my head against things, neglecting the family, angering the demon that is my wife, and having to start over again multiple times... I finally got RetroPie, RetroArch, and EmulationStation working. I figured I'd contrubute to the community with what steps I took, but I offer no support or guarantees. All I know is that now I'm "rock64ing" RP, RA, and ES

I wanted to use the newest linux builds available from ayufan but ran into problems booting (no video), so I ended up going back a few versions. I'm eventually planning to try to find a way to upgrade to the newest build without having to redo everything (if you know how, feel free to let me know, I'm still learning all this).

I started with jessie using the 0.5.10 build from ayufan (jessie-minimal-rock64-0.5.10-118-arm64.img.xz). I was using a computer monitor and an HDMI-DVI converter to configure everything on jessie, but once it got it all working I tried it on my TV and got no display : So I started over using stretch (stretch-minimal-rock64-0.5.10-118-arm64.img.xz). I'll post the details of both in case it helps anyone. And there's always a chance some of the steps I took were not necessary, but it worked out for me.

First off, as a relatively linux noob, here's my notes on some helpful linux commands that I had to learn and use in my trials:
----------------------
To show version of installed package: apt-show-versions

After a fresh OS install, run these to get everything updated:
apt-get update
apt-get upgrade
apt-get dist-upgrade

To install newer/unstable versions of packages (such as gcc):
echo "deb http://ftp.us.debian.org/debian unstable main contrib non-free" >> /etc/apt/sources.list.d/unstable.list
apt-get update
apt-get install -t unstable gcc-5

To downgrade/install a specific version of packages: sudo apt-get install =

To open compressed log files: zcat logfile.gz

To show all versions available for a package: apt-cache madison

To show what packages depend on a specific package: apt-cache rdepends packagename

To list all installed packages: apt list --installed

To manually mount a USB drive:
mkdir /media/usb1 (if it doesn't already exist)
mount /dev/sda1 /media/usb1

To Unmount a USB Drive: umount /media/usb1

To get CPU detail: lscpu

To get status of services: service --status-all

To restart a service: service restart

To force-overwrite packages after apt-get error: sudo dpkg -i --force-overwrite /var/cache/apt/archives/.deb

To download a package files only without installing: aptitude download (note: had to install aptitude)

Force network adapter to get DHCP address: dhclient eth0 -v

To NEVER ALLOW DROP TO COMMAND and auto-start emulation station, add this to the bottom of ~/.profile:
[[ -z $DISPLAY && $XDG_VTNR -eq 1 ]] && exec emulationstation
(preferred method is to use retropie setup to tell ES to autorun in config)

To set the timezone: dpkg-reconfigure tzdata

To enable autologin: edit the file /lib/systemd/system/getty@.service and change the line
ExecStart=-/sbin/agetty --noclear %I $TERM
to
ExecStart=-/sbin/agetty --noclear -a rock64 %I $TERM

Ways to build a debian package from source:
checkinstall (had to add this package manually, but makes ANY INSTALLATION into a debian package and replaces the make command!)
The next two are picky and require a true debian source package, needs to run from within the debian folder with a special file in it:
dpkg-buildpackage -us -uc -b (this one seems to work the best)
dpkg-deb --build

To add a root share after installing samba, add the below to the config /etc/samba/smb.conf (NOTE: retropie setup lets you do it without the console):
[root]
comment = root
path = "/"
writeable = yes
guest ok = yes
create mask = 0644
directory mask = 0755
force user = rock64
-------------

Now to the guts of the RP, RA, and ES installs:

For both jessie and stretch you'll need the most recent retropie source from github. Then use this pull request to make the necessary changes to the code to support a rock64 install:
https://github.com/RetroPie/RetroPie-Set...2205/files

ON JESSIE:
-----------------
First run the retropie-setup script after you've applied the pull request to source. This alone should allow you to run the retropie setup.

The release of jessie that I used has an older version of GCC and causes build errors when installing retroarch and emulationstation (unknown value 'native' for -march).
To build retroarch you'll need to upgrade GCC, so I added the unstable apt source (per my instructions above) and chose to install version 7.2.
To build emulationstation you'll need to upgrade G++, so I added the unstable apt source (per my instructions above) and chose to install version 7.2.

I attempt to install retroarch and emulationstation and after reviewing the logs find that they fail due to an attempt at overwriting existing libraries (because some are already included in the libmali-rk* packages). After the first failed installations I drop to console and apt-get remove the following:
libsdl2-dev
libmali-rk-utgard-2th-r7p0
libmali-rk-dev
(don't reboot)

I then return to retropie-setup and attempt retroarch and emulationstation installations again. If I run into any failures again, I note the log file it refers to and I drop back to console and review the log and manually force the failing package to overwrite the existing one using the below command and try the install again:
sudo dpkg -i --force-overwrite

Eventually both RA and ES install successfully. But... ES doesn't start due to a segmentation fault. So, REINSTALL both libmali-rk* packages with force-overwrite. For example:
sudo dpkg -i --force-overwrite /var/cache/apt/archives/libmali-rk-utgard-2th-r7p0_1.5-4ayufan12_arm64.deb
----------------------

ON STRETCH:
-----------------------
(for all below steps, whenever something doesn't install due to an overwrite, I use dpkg to force overwrite it, just like previously explained)
Ran all updates, upgrades, and dist-upgrades after the fresh image booted.
The first few times I tried this I ended up with the "unable to initialize SDL" errors and my attempts to fix it made things worse. This time I decided to be proactive and build a few packages first to try and get dependencies in place. I have no idea if this was absolutely necessary. But again, it worked.
apt-get install xorg-dev
apt-get build-dep xscreensaver vlc totem
I ignored any package warnings it throws at this point since I was just looking for some dependencies to get installed.
Now run the retropie-setup script after you apply the pull request from github.
Try and install Retroarch and Emulationstation. Any failures, review the listed log file and force overwrite the failing library manually using dpkg like I previously explained.
Eventually both will install, but emulationstation still returns unable to init SDL.
Did some testing and found that the libsdl2-dev package was actually on hold. I figured I'd remove and reinstall the libmali-rk-utgard package...
but it wouldn't let me due to a dependency issue. I installed aptitude to see what it recommended as a solution.
So first I let it install libmali-rk-midgard-4th-r13p0. Then I was able to successfully remove libmali-rk-utgard.
Then I reinstalled the libmali-rk-utgard package using dpkg with overwrite.
Then I uninstalled and reinstalled libmali-dev.
------------

At this point, whether you're on jessie or stretch, you should be able to start ES and start installing your various emulators. Some will install just fine, and others will fail and you'll have to review logs and tend to the overwrites manually using the same methods we used during the install. I didn't test all the emulators but was able to get a good handful running without issues. Again, I can't make any promises or do much support on this, but I hope it helps some of you get up and rolling. If anyone has additions or runs into other required fixes, please post for the community benefit.

Good luck everyone, and happy rock64ing!

Guide - Raid Array (Raid 0)

Sat, 07 Oct 2017 15:22:04 +0000

Preface

In this guide, I will be showing how to create a raid array, using the raid 0 configuration. This allows you to have maximize storage available, however it comes at the risk of data loss in case of hardware failure.

It also has the benefit of having really pretty "blinkenlights" effect when the USB drives are being accessed.

Prerequisites

ROCK64 board running Debian or Ubuntu, connected to the local network

Access to terminal, either locally or via SSH

At least 2 Flash drives (or hard drives)

Recommended: USB Hub, for ease of access.

___________________

Make sure your software and repositories are up to date:

Code:
sudo apt update && sudo apt upgrade

Next, we install the mdadm package, used to monitor and implement software raid in linux:

Code:
sudo apt install mdadm

After installing it, we can get our flashdrives and plug them directly into the ROCK64 board, or onto a USB hub and plug that into the board.

The USB drives that I used were previously erased by me, and thus, don't have any partitions. We can confirm that they've been detected by the system by issuing the "lsblk" command, showing the attached blocked devices. In my case, they are sdb, sdc, and sdd:

Since we can see the 3 (in my case) flash drives recognized by the system, we can now proceed and start to create a new raid array.

WARNING: BE VERY CAREFUL WITH THE FOLLOWING STEPS AND DOUBLE CHECK, USING THE WRONG NAMES COULD LEAD TO DATA LOSS

Code:
sudo mdadm --create --verbose /dev/md0 --level=0 --raid-devices=3 /dev/sd{b,c,d}

"--level=0" denotes the raid level, or the type of raid. "--raid-devices" flag states the number of devices. The last argument "/dev/sd{b,c,d}" is simply an easier way of saying "/dev/sdb /dev/sdc /dev/sdd" without having to type it all out (called Brace Expansion).

After the Array is created, you can invoke the "lsblk" command, to see the status of the USB drives. Notice that all three drives (sdb,sdc,sdd) are part of the partition (md0) and that the partition size is larger than the size of the physical disk:

Now, we can simply create a partition on the raid array, and mount it to a suitable location.
I created an ext4 partition on my Raid array:

Code:
sudo mkfs.ext4 -F /dev/md0

Then, I created a mountpoint for my new Ext4 partition, and mounted it:

Code:
sudo mkdir -p /mnt/md0

sudo mount /dev/md0 /mnt/md0

I also used this as an opportunity to check my RAID was succesfully created by checking the /proc/mdstat file (though, it was my mistake, I should have done this step right after creating the array.

Now that the RAID device is mounted, we can use the chown command to assume ownership of it so that we can write to it:

Code:
sudo chown -R rock64: /mnt/md0/

Again, this might vary depending on your username and mount location.
Thats all there is to it! We're done! You should be able to access that device under your mountpoint. We can confirm that the RAID array is mounted using either "lsblk" or "df -h":

Guide - Setting up a NFS Share

Tue, 26 Sep 2017 10:44:00 +0000

Preface

This quick and simple guide will show how to create a NFS Share using your Rock64. NFS has a few advantages over SMB, if you know your network well and will use it with linux clients. Apart from marginally faster file transfers, NFS allows you to retain Unix File permissions.

Prerequisites

ROCK64 board running Debian or Ubuntu, connected to the local network

Access to terminal, either locally or via SSH

Some basic understanding of using the linux terminal: Howtogeek

Suggested: A basic comprehension of linux file permissions

____________________

As always before installing any software in linux, it is always good practise to ensure that your software is up to date:

Code:
sudo apt update && sudo apt upgrade

After ensuring your software is up to date, you will need to install the NFS kernel server. Some distros have this installed by default, but there is no harm in running the command regardless, if it isnt installed, it will give you the option to install it:

Code:
sudo apt install nfs-kernel-server

After the server is installed, now its time to edit the configuration file, to add a share definition.

You'll need to edit the exports file:

Code:
sudoedit /etc/exports

You can add a new share definition in the following format:

Share-location Network-Access Share-options

Here are mine. The location looks different to past tutorials because I accidentally formatted my flash drive:

Code:
/media/SDCZ45-016G/RockNFS 192.168.1.*(rw,sync,insecure,no_root_squash,no_subtree_check)

The next field (192.168.1.*) simply defines what part of your local area network is allowed to access the share. I've configured it so that any computer with the IP address from 192.168.1.1 to 192.168.1.254 can access it. You can allow any (local) IP address to access the share using "*.*" or you can limit it to a specific IP address of a computer.

The last options specify how the server should treat the share. If you'd like to read up more on their effects: https://linux.die.net/man/5/exports

This is how it would look like before you save and exit the file:

After you're done, restart the service:

Code:
sudo /etc/init.d/nfs-kernel-server restart

Code:
sudo service nfs-kernel-server restart

Will do the job.

The server will now be up and running!

____________________

On the client's side, you'll need to make sure that you've got the NFS client stuff:

Code:
sudo apt install nfs-common

After that, you can probe the server from the client PC to test/see if it hosts accessible NFS Shares. To do that, we use the showmount command, followed by an argument and the address of the server:

Code:
showmount -e rock64.local

Either IP address or hostname should work:

The "e" arguments tells the showmount command to show the export list from the server.

Next, you'll need to mount the share. I did this in my Home directory, making a new test folder for it. The mount command could be invoked now, and you can mount the NFS share to the new directory that you've made. The "-vv" means its verbose; it prints out status and progress.

Code:
sudo mount -t nfs rock64.local:/media/SDCZ45-016G/RockNFS nfstest/ -vv

The command you use will be different based on your host and client. When typing it out, after putting down the hostname (rock64.local:/), I was able to use tab completion to complete the rest of the location without manually typing it out. Simply hit the "tab" key, and it should autocomplete the rest of the path.

You can make a test file in the folder, either using the terminal, or a graphical file manager. I made a test file on my client using the "touch" command.

Then to confirm that the changes are seen on the client side, I SSH'ed back into my server, navigated to the share location, and listed confirmed that the new file had been created:

You should now know how to whip up a NFS share on the Rock64 board, and mount/access it from a client OS. If you wish to permanently mount the NFS Share to your client, I would recommend doing it via fstab:

https://askubuntu.com/questions/7117/which-to-use-nfs-or-samba