TinyComputers.io (Posts about pine64)

Pine64 Board Comparison: RockPro64 vs Quartz64-B

A.C. Jokela — Wed, 24 Sep 2025 17:42:29 GMT

Pine64 Board Comparison: RockPro64 vs Quartz64-B

Executive Summary

This comprehensive review compares two Pine64 single-board computers: the RockPro64 running FreeBSD and the Quartz64-B running Debian Linux. Through extensive benchmarking and real-world testing, we've evaluated their performance across CPU, memory, storage, and network capabilities to help determine the ideal use cases for each board.

Test Environment

Hardware Specifications

RockPro64 (10.1.1.130)

CPU: Rockchip RK3399 - 6 cores (2x Cortex-A72 @ 2.0GHz + 4x Cortex-A53 @ 1.5GHz)
RAM: 4GB DDR4
OS: FreeBSD 14.1-RELEASE
Storage: 52GB UFS root filesystem
Network: Gigabit Ethernet (dwc0)

Quartz64-B (10.1.1.88)

CPU: Rockchip RK3566 - 4 cores (4x Cortex-A55 @ 1.8GHz)
RAM: 4GB DDR4
OS: Debian 12 (Bookworm) - Plebian Linux
Storage: 59GB eMMC
Network: Gigabit Ethernet (end0)

Performance Benchmarks

1. CPU Performance

The RockPro64's heterogeneous big.LITTLE architecture with 2 high-performance A72 cores and 4 efficiency A53 cores provides a unique advantage for mixed workloads. In our simple loop benchmark:

RockPro64: 0.92 seconds (100k iterations)
Quartz64-B: 0.99 seconds (100k iterations)

The RockPro64 shows approximately 7.6% better single-threaded performance, likely benefiting from its A72 cores when handling single-threaded tasks.

2. Memory Bandwidth

Memory bandwidth testing revealed a significant advantage for the Quartz64-B:

RockPro64: 1.7 GB/s
Quartz64-B: 3.7 GB/s

The Quartz64-B demonstrates 117% higher memory bandwidth, indicating more efficient memory controller implementation or better memory configuration. This advantage is crucial for memory-intensive applications.

3. Storage Performance

Storage benchmarks showed contrasting strengths:

Sequential Write (500MB file)

RockPro64: 332.8 MB/s
Quartz64-B: 20.1 MB/s

Sequential Read

RockPro64: 762.5 MB/s
Quartz64-B: 1,461.0 MB/s

The RockPro64 excels in write performance with 16.5x faster writes, while the Quartz64-B shows 1.9x faster reads. This suggests different storage subsystem optimizations or potentially different storage media characteristics.

Random I/O (100 operations)

RockPro64: 0.87 seconds
Quartz64-B: 0.605 seconds

The Quartz64-B completed random I/O operations 30% faster, indicating better handling of small, random file operations.

4. Network Performance

Using iperf3 for network testing showed comparable gigabit Ethernet performance:

Throughput (TCP)

RockPro64 → Quartz64-B: 93.5 Mbps
Quartz64-B → RockPro64: 95.4 Mbps

Both boards achieve similar network performance, approaching the theoretical maximum for 100Mbps connections. The slight variations are within normal network fluctuations.

Use Case Analysis

RockPro64 - Ideal Use Cases

Build Servers & CI/CD
Superior write performance makes it excellent for compilation tasks
6-core configuration provides better parallel build capabilities
FreeBSD's stability benefits long-running server applications
Database Servers
High sequential write speeds benefit transaction logs
Additional CPU cores help with concurrent queries
Better suited for write-heavy database workloads
File Servers & NAS
Excellent sequential write performance for large file transfers
6 cores provide overhead for file serving while maintaining responsiveness
FreeBSD's ZFS support (if configured) adds enterprise-grade features
Development Workstations
More CPU cores benefit compilation and development tools
Balanced performance across different workload types
FreeBSD environment suitable for BSD-specific development

Quartz64-B - Ideal Use Cases

Media Streaming Servers
Superior read performance benefits content delivery
Efficient Cortex-A55 cores provide good performance per watt
Better memory bandwidth helps with buffering
Web Servers
Fast random I/O benefits web application performance
High memory bandwidth helps with caching
Debian's extensive package repository provides easy deployment
Container Hosts
Docker already configured (as seen in network interfaces)
Better memory bandwidth benefits containerized applications
Efficient for running multiple lightweight services
IoT Gateway
Power-efficient Cortex-A55 cores
Good balance of performance and efficiency
Debian's wide hardware support for peripherals

Power Efficiency Considerations

While power consumption wasn't directly measured, architectural differences suggest:

Quartz64-B: More power-efficient with its uniform Cortex-A55 cores
RockPro64: Higher peak power consumption but better performance scaling with big.LITTLE

Software Ecosystem

FreeBSD (RockPro64)

Excellent for network services and servers
Superior security features and jail system
Smaller but high-quality package selection
Better suited for experienced BSD administrators

Debian Linux (Quartz64-B)

Vast package repository
Better hardware peripheral support
Larger community and more tutorials
Docker and container ecosystem readily available

Conclusion

Both boards offer compelling features for different use cases:

Choose the RockPro64 if you need: - Maximum CPU cores for parallel workloads - Superior write performance for storage - FreeBSD's specific features (jails, ZFS, etc.) - A proven platform for server workloads

Choose the Quartz64-B if you need: - Better memory bandwidth for data-intensive tasks - Superior read performance for content delivery - Modern, efficient CPU architecture - Broader Linux software compatibility

Overall Verdict

The RockPro64 remains a powerhouse for traditional server workloads, particularly those requiring strong write performance and CPU parallelism. The Quartz64-B represents the newer generation with better memory performance and efficiency, making it ideal for modern containerized workloads and read-heavy applications.

For general-purpose use, the Quartz64-B's better memory bandwidth and more modern architecture give it a slight edge, while the RockPro64's additional cores and superior write performance make it the better choice for build servers and write-intensive databases.

Benchmark Summary Table

Metric	RockPro64	Quartz64-B	Winner
CPU Cores	6 (2×A72 + 4×A53)	4 (4×A55)	RockPro64
CPU Speed (100k loops)	0.92s	0.99s	RockPro64
Memory Bandwidth	1.7 GB/s	3.7 GB/s	Quartz64-B
Storage Write	332.8 MB/s	20.1 MB/s	RockPro64
Storage Read	762.5 MB/s	1,461 MB/s	Quartz64-B
Random I/O	0.87s	0.605s	Quartz64-B
Network Send	93.5 Mbps	95.4 Mbps	Tie
Network Receive	94.1 Mbps	92.1 Mbps	Tie

Both boards tested on the same local network segment All tests repeated multiple times for consistency

Pine64 ROCKPro64 SATA Software RAID5

A.C. Jokela — Sat, 07 Jan 2023 00:01:26 GMT

I love experimenting with all sorts of single board computers (SBCs) and systems on modules (SoMs) - like the Raspberry Pi CM4 or Pine64 SOQuartz. This extends even to needing to make a network-attached storage (NAS). One of the requirements is the ability to attached a bunch of disks to a tiny computer. The easiest way to accomplish this is using a PCIe SATA controller. To use this, you need a PCIe lane exposed. Luckily, there are a number of system on modules with PCIe support. There is also Pine64 single board computers with an exposed PCIe lanes. These are the Quartz64 model A as well as the ROCKPro64. The former does not have the performance capabilities that the latter does, as such, we will be using the ROCKPro64.

My requirements for a NAS are bare-bones. I want network file system support; and secondarily, Windows' SMB support via the open source project Samba. Samba is of secondary importance because the primary use case for this particular NAS is providing additional disk space to other SBCs that are running some flavor of Linux or BSD (like NetBSD).

When the Turing Pi 2 was being promoted on Kickstarter, I had pledged to the project and then purchased a 2U shallow depth rack ITX server case. The project has been moving along but is taking longer than I had anticipated. In the mean time, I decided to re-purpose the server case and use it for a simple NAS.

I purchased four Seagate IronWolf 10TB drives. These are spinning metal drives not fancy NVME drives. NVME is too cost prohibitive and would ultimately not be performative; e.g. the bottleneck would be the ROCKPro64.

One of the four drives turned out to be a dud; there are only three in the above picture. The original goal was have 30TB of RAID5 -- 30TB of storage with 10TB for parity. But, because I did not want to spend much more on this project, I opted to return the broken drive and settle for 20TB of storage with 10TB of parity.

The setup is fairly simple. The 2U case, three 10TB drives, a ROCKPro64 4GB single board computer, and a 450W ATX power supply.

Here's a pro-tip on using a power supply without a motherboard: while holding the power connector with the latching tab towards you, use a paper clip, or in my case, a piece of MIG welding wire, to short out the third and fourth connectors. This probably will void the warranty if something happens to the power supply.

Here is a bit of information on the tech specs of the ROCKPro64.

The drive setup is straight forward. Three drives, running in a RAID5 configuration producing a total of 20TB of usable storage. Setting up software RAID under Linux is simple. I used this as a foundation for setting up software RAID. We are using software RAID because hardware RAID controllers are expensive and have limited support with single board computers. The one that appears to work, is about $600. It is not that I would not be against spending that much on a shiny new controller, it is that I do not feel there would be a noticeable benefit over a pure software solution. I will go into performance characteristics of the software RAID configuration later in this article.

How To Create RAID5 Arrays with mdadm

RAID5 has a requirement of at least three drives. As previously mentioned, this gives you n - 1 drives of storage with one drive's worth of storage for parity. This parity is not stored on the single drive, it is stored across all of the drives but it is equal in total to the size of one drive. There is the assumption that all drives are of equal size.

Get a pretty list of all the available disk:

$ lsblk -o NAME,SIZE,FSTYPE,TYPE,MOUNTPOINT
NAME          SIZE FSTYPE  TYPE  MOUNTPOINT
sda           9.1T         disk  
sdb           9.1T         disk  
sdc           9.1T         disk  
mtdblock0      16M         disk  
mmcblk2      58.2G         disk  
└─mmcblk2p1  57.6G ext4    part  /
mmcblk2boot0    4M         disk  
mmcblk2boot1    4M         disk

You will see we have three, "10TB" drives.

To create a RAID 5 array with the three 9.1T disks, pass them into the mdadm --create command. We will have to specify the device name you wish to create, the RAID level, and the number of devices. We will be naming the device /dev/md0, and include the disks that will build the array:

sudo mdadm --create --verbose /dev/md0 --level=5 --raid-devices=3 /dev/sda /dev/sdb /dev/sdc

This will start to configure the array. mdam uses the recovery process to build the array. This process can and will take some time to complete, but the array can be used during this time. You can monitor the progress of the mirroring by checking the /proc/mdstat file:

$ cat /proc/mdstat
Personalities : [raid6] [raid5] [raid4] [linear] [multipath] [raid0] [raid1] [raid10]
md0 : active raid5 sda[0] sdc[3] sdb[1]
      19532609536 blocks super 1.2 level 5, 512k chunk, algorithm 2 [3/3] [UUU]
      bitmap: 0/73 pages [0KB], 65536KB chunk

unused devices: <none>

For this 20TB to build, it took over 2000 minutes or about a day and half. Once the building is complete, your /proc/mdstat will look similar to the above.

Make a file system on our new array:

$ sudo mkfs.ext4 -F /dev/md0

Make a directory:

$ sudo mkdir -p /mnt/md0

Mount the new array device

$ sudo mount /dev/md0 /mnt/md0

Check to see if the new array is available:

$ df -h -x devtmpfs -x tmpfs
Filesystem      Size  Used Avail Use% Mounted on
/dev/mmcblk2p1   57G  8.7G   48G  16% /
/dev/md0         19T   80K   18T   1% /mnt/md0

Now, let's save our array's configuration:

$ sudo mdadm --detail --scan | sudo tee -a /etc/mdadm/mdadm.conf

Update initramfsso we can use our new array on boot:

$ sudo update-initramfs -u

Add our device to fstab:

$ echo '/dev/md0 /mnt/md0 ext4 defaults,nofail,discard 0 0' | sudo tee -a /etc/fstab

From some of the other documentation, there is a note that dumping the configuration to /etc/mdadm/mdadm.conf before the array is completely built, could result in the number of spare devices not being set correctly. This is what mdadm.conf looks like:

# mdadm.conf
#
# !NB! Run update-initramfs -u after updating this file.
# !NB! This will ensure that initramfs has an uptodate copy.
#
# Please refer to mdadm.conf(5) for information about this file.
#

# by default (built-in), scan all partitions (/proc/partitions) and all
# containers for MD superblocks. alternatively, specify devices to scan, using
# wildcards if desired.
#DEVICE partitions containers

# automatically tag new arrays as belonging to the local system
HOMEHOST <system>

# instruct the monitoring daemon where to send mail alerts
MAILADDR root

# definitions of existing MD arrays

# This configuration was auto-generated on Thu, 22 Dec 2022 16:46:51 -0500 by mkconf
ARRAY /dev/md0 metadata=1.2 spares=1 name=k8s-controlplane-01:0 UUID=62e3b0e3:3cccb921:0fc8e646:ac33bd0f

Note spares=1 is correct in the case of my set up.

By this point, if you have waited until the array has been successfully built - my 20TB array took about a day and half to complete.

Performance

We now have a shiny, new 20TB of available disk space, but what are the performance characteristics of a 20TB, Software RAID5?

We will be using iozone. Iozone has been around for decades; I first used it while in college and having a rack full of servers was all the rage -- before the creation of utility-scale cloud computing, as well as tiny computers.

Download iozone from iozone.org. Extract and compile:

$ cd iozone3_494/src/current
$ make linux

You will end up with the executable iozone in the src/current directory.

Run iozone:

$ sudo ./iozone -a -b output.xls /mnt/md0

This will both output a lot of numbers as well as take a while to complete. When it is complete, you will have an Excel spreadsheet with the results in output.xls.

At this point, I am going to stop doing a step by step of what I have executing and running. Why, I am going to show some visualizations and analyses of our results. My steps will be roughly:

Break out each block of metrics into its own csv file; for example, the first block found in output.xls would be saved in its own csv file; let's call it writer.csv; exclude the header Writer Reportfrom the csv. Repeat this step for all blocks of reports.

Writer Report                                                   
4   8   16  32  64  128 256 512 1024    2048    4096    8192    16384
64  703068  407457  653436  528618  566551                              
128 504196  306992  433727  962469  498114  757430                          
256 805021  475990  850282  594276  571198  582035  733527                      
512 660600  573916  439445  1319250 549959  645703  926116  591299                  
1024    1102176 1053512 610617  704230  902151  1326505 1011817 1161176 919928              
2048    608964  1398145 1329751 822175  1140942 841094  1332432 1308682 1082427 1311879         
4096    1066886 1304093 1168634 946820  1467135 881253  1360802 931521  1047309 1018923 1047054     
8192    955344  1295186 1329052 1354035 1019915 1192806 1373082 1197294 1053501 866339  1116235 1368760
16384   1471798 1219970 2029709 1957942 2031269 1533341 1570127 1494752 1873291 1370365 1761324 1647601 1761143
32768   0   0   0   0   1948388 1734381 1389173 1315295 1848047 1916465 1944804 1646551 1632605
65536   0   0   0   0   1938246 1933611 1638071 1910004 1885763 1876212 1844374 1721776 1578535
131072  0   0   0   0   1969167 1962833 1921089 1757021 1644607 1780142 1869709 1566404 1356993
262144  0   0   0   0   2025197 2037129 2036955 1747487 1961757 1954913 1934085 1718841 1596327
524288  0   0   0   0   2041397 2080623 2087150 2049656 2007421 2005253 1930617 1876761 1813078

I used a combination of using Excel (using LibreOffice Calc would work, too) and a Jupyter Notebook. Excel was used to pull out each report's block and then save each to a CSV file; the Notebook contains python code for reading in CSVs, and using matplotlib to produce visualizations.

Select Visualizations

There actually is relatively consistent reads across the file sizes and transfer sizes.

Raspberry Pi CM4 and Pin Compatible Modules

A.C. Jokela — Thu, 22 Dec 2022 16:30:00 GMT

UPDATE: 2023/02/04: Review of BIGTREETECH CB1 - RPi CM4 Pin Compatible Module

Hardware, in our modern era, does not exist in a vacuum; it requires software to function and be useful. One of main benefits of living within the Raspberry Pi ecosystem is you get up-to-date software that is maintained by a large network of source code contributors. Just for the linux kernel used in Raspberry Pi OS, there have been over 5,000 people contributing to the project. That's hundreds of thousands of lines of code added, removed and modified. Raspberry Pi is successful because of its ecosystem. It is so large, it is self-sustaining. The Raspberry Pi Compute Module 4 (announcement of the "CM4") was introduced about two years ago. Official Raspberry Pi CM4 Datasheet. It is a followup to the wildly successful Raspberry Pi 4b. The CM4 is a different form factor from the 4b. Unlike the 4b, it requires a carrier or IO board to be useful. The good news is it is compatible with a bewildering array of carrier and IO boards.

Raspberry Pi CM4

Raspberry Pi Compute Module 4, 1GB memory

There are IO boards that give you the same form factor as the RPi 4b, there are also IO boards that turn your CM4 into a KVM for a server management, there are boards with two ethernet ports -- allowing for the creation of a simple router. There also boards that expose the CM4's PCIe bus. This opens up the possibilities for using peripherals like addition network adapters or SATA controllers. More on that later.

Since the CM4's release, there have been a few pin compatible modules developed by other firms. By pin compatible, I mean that these other modules can correctly be attached via Hirose mating connectors to the IO boards.

One of the primary benefits of using a genuine Raspberry Pi CM4, as I mentioned in the first paragraph, is the ecosystem. The CM4 uses the same operating system as the 4b. This allows for nearly all the same software to be usable across the RPi family of single board computers. This sheds light on one of the most commonly brought up issues with non-Raspberry Pi single board computers: the software ecosystem just is not as robust as Raspberry Pi. This is not limited to the alternatives to the CM4. There are an array of alternatives to the RPi family, like the boards made by Pine64, or Libre, or Hardkernel's Odroid series. These all cannot run the official Raspberry Pi OS.

Jeff Geerling does a fantastic job of reviewing the RPi CM4. I am not going to give a complete, indepth review; Jeff has already done that.

Core Features:

Optional eMMC, zero to 32GB
Optional Wireless (WiFi and Bluetooth)
Variety of memory sizes, 1GB to 8GB

If by some chance you stumbled onto this post and you need assistance in getting Raspberry Pi OS running on a CM4 unit, check out this. I'm not going to go into details here; it is a solved problem.

Many of the alternatives to Raspberry Pi OS have a very similar feel and shallow curve for learning and setting up, but they are not 100% the same. Take for example, the the multi-board Linux distribution Armbian. Armbian supports over 160 different single board computers. If you have a well established board, there is a good chance there's an Armbian build for it. Armbian is very similar to RPi OS; they are both derivatives of Debian, both can use standard Ubuntu and Debian packages, both have a similar method of writing a disk image to an SD card and booting the OS. There is no guarantee, however, that all software designed for the Raspberry Pi OS will run under Armbian. Particularly when dealing with third party shields and GPIO boards as well as things that I tend to ignore like video encoding/decoding and sound.

The common quip as of late goes something like this: because of the shortage of Raspberry Pi computers, some people have turned to alternatives. This might be the case for some, but this is not going to be my justification for using or testing out the three alternatives that will be present throughout the rest of this article.

All Raspberry Pi single board computers and modules are in tight supply for the retail and hobbists markets. Check out Raspberry Pi Locator for places that might have supply. If you are willing to pay a significant premium, eBay has quite a few available.

With the RPi CM4 having been covered extensively - like Jeff Geerling's Review; instead, I'll be looking at the remaining three modules.

Performance Metrics

Geekbench Metrics
Module	Single CPU Metrics	Multi-CPU Metrics
Raspberry Pi CM4	228	644
Radxa CM3	163	508
Pine64 SOQuartz	156	491
Banana Pi CM4	295	1087

Features Comparison
	Raspberry Pi CM4	Radxa CM3	Pine64 SOQuartz	Banana Pi CM
	Specifications	Specifications	Specifications	Specifications
Core	Broadcom BCM2711, Quad core Cortex-A72 (ARM v8) 64-bit SoC @ 1.5GHz	Rockchip RK3566, Quad core Cortex-A55 (ARM v8) 64-bit SoC @ 2.0GHz	Rockchip RK3566, Quad core Cortex-A55 (ARM v8) 64-bit SoC @ 1.8GHz and Embedded 32-bit RISC-V CPU	Amlogic A311D Quad core ARM Cortex-A73 and dual core ARM Cortex-A53 CPU
NPU	-	0.8T NPU	0.8 TOPS Neural Network Acceleration Engine	5.0 TOPS
GPU	-	Mali G52 GPU	Mali-G52 2EE Bifrost GPU	Arm Mali-G52 MP4 (6EE) GPU
Memory	1GB, 2GB, 4GB or 8GB LPDDR4	1GB, 2GB, 4GB or 8GB LPDDR4	2GB, 4GB, 8GB LPDDR4	4GB LPDDR4
eMMC	On module - 0GB to 32GB	On module - 0GB to 128GB	External - 16GB to 128GB	On module - 16GB to 128G)
Network	1Gbit Ethernet - Option for WiFi5 with Bluetooth 5.0	1Gbit Ethernet - Option for WiFi5 with Bluetooth 5.0	1Gbit Ethernet - WiFi 802.11 b/g/n/ac with Bluetooth 5.0	1Gbit Ethernet
PCIe	1-lane	1-lane	1-lane	1-lane
HDMI	2x HDMI	1x HDMI	1x HDMI	1x HDMI
GPIO	28 pin	40 pin	28 pin	26 pin
Extras	-	-	-	SATA ports, one shared with USB 3, one shared with PCIe; Audio Codec
Geekbench Score - Single CPU	228	163	156	295
Geekbench Score - Multi CPU	644	508	491	1087
Price of Tested*	$65	$69	$49	$105
Power Consumption	7 watts	N/A	2 watts	N/A

* Prices exclude shipping

Pine64 SOQuartz

Pine64 SOQuartz Module, 4GB memory

For whatever reason, I really like Pine64's SOQuartz module. It is by far the least performant of the four compute modules I have tried. It has a wonky antenna and needs a far from mainstream variety of Linux to be useful. There are two Linux distributions available: DietPI and Plebian Linux. I settled upon using Plebian. I would have gone with DietPi but my initial use case of making a two ethernet router using a Waveshare Dual Gigabit Ethernet Base Board Designed for Raspberry Pi Compute Module 4, but I was unable to get both ethernet ports working. Plebian was simpler. For those interested in trying Plebian, you can download recent disk images by going to Plebian Linux's Github Actions, and select one of the recent "Build Quartz64 Images"; at the bottom there will be zipped disk image Artifacts to download for the various flavors of Quartz64. Plebian is a bit rough around the edges. It is derived from Debian Testing (currently codenamed bookworm) and runs a release candidate Linux Kernel. Its developer, CounterPillow, also states that "This is a work-in-progress project. Things don't work yet. Please do not flash these images yet unless you are trying to help develop this pipeline." The interactions with the system feel similar to that of NetBSD from the early-2010s. It is not to say it is not a modern flavor of Linux, it is simply lacking some of the usual expectations. You want your network interfaces to be named eth0? How about no. Interfaces have not been aliased, if you can get WiFi drivers working, you will end up with a device named something like wlxe84e069541e6 instead of wlan0. Given that it is running a testing branch of Debian, things like docker and the like will likely not work without some significant wrangling.

Why do I like this compute module? I like Pine64's products. I like the community that has grown up around the products. In the course of trying to get an operating system up and running, I had numerous questions that I asked on Pine64's Discord Server. Everyone was extremely helpful and despite my own feelings that some of my questions were simplistic, no one expressed that sentiment. There were no massive egos to speak of.

Core Features:

Variety of memory options: 2gb to 8gb
external eMMC module support: 8gb to 128gb
Wifi

Getting Plebian running on a SOQuartz module is straightforward; write the appropriate image to an eMMC module, attach the eMMC onto the SOQuartz and place it into a carrier or IO board. You should get working HDMI, one ethernet port, along with USB working. A quick run down of the steps are as follows:

Get a USB to eMMC adapter; Pine64 has one available; you could also try eBay; you may need to get a micro SD to USB adapter, too.
Get an eMMC module. Pine64 has a few available
Obvious step: connect your eMMC to your USB to eMMC adapter and then connect that to your desktop/laptop/etc.
Download a SOQuartz Plebian Linux disk image from Plebian Linux's Github Actions
DownloadSOQuartz CM4 IO Board Image
Unzip the contents
You will end up with a file called plebian-debian-bookworm-soquartz-cm4.img.xz;
Write to your eMMC module. You could use something balena Etcher or, if you're command-line-comfortable, use dd
balena Etcher will take care of decompressing plebian-debian-bookworm-soquartz-cm4.img.xz
using dd, you can do something like this:

bash sudo xzcat plebian-debian-bookworm-soquartz-cm4.img.xz | sudo dd of=/dev/mmcblk1 status=progress

where /dev/mmcblk1 is the correct device for your USB to eMMC adapter.
Attach your eMMC module to your SOQuartz module and attach the module to an IO or carrier board.
Attach peripherals and apply power. You'll eventually get presented with a prompt to set the password for the user pleb

If would be more cost effective if you were to buy a SOQuartz module, an USB to eMMC adapter and an eMMC module all at once; for orders being shipped to the United States, it is roughly a $9 flat rate.

Finally, if you really feel like going for an alternative to Linux, NetBSD will also work on the SOQuartz, but it is more complicated. You will need to download a Generic 64bit image from under the NetBSD-daily HEAD tab. This will need to be written to an eMMC module. Next, you will need to write the appropriate UEFI image to an SD card from Jared McNeill's port of Tianocore to the Quartz64 family. UEFI and the disk image cannot exist on the same media.

Pine64 sells SOQuartz modules directly from their site. The modules I have purchased and used are the 4gb models. They are about $50 excluding shipping.

Radxa CM3

Radxa CM3, 4GB memory, without heatsinks

As far as performance goes, the Radxa CM3 is just above Pine64's SOQuartz module but below Raspberry Pi CM4. Radxa is better known for its Rock3 and Rock5 series of single board computers; available from ALLNET.China and eBay. The CM3 is in the Rock3 series of boards and modules. The series features Rockchip RK3566/RK3568 processors, the RK3566 also is used in Pine64's Quartz64 and SOQuartz boards. Even though the module will function without issue on a carrier or IO board designed for Raspberry Pi CM4, the CM3 IO board by Radxa exposes two SATA ports in addition to the PCIe 1x lane. The CM3 has an official Debian and Ubuntu distributions, but like all the other compute modules, these are artisanally crafted specifically for the CM3. That means, you can not take an actual-official Debian or Ubuntu disk image for Arm64 and have it just have it work. Radxa does, however, maintain an up-to-date Github build pipeline for producing both Debian and Ubuntu images for the CM3. Like the operating system's need to be different, so is the eMMC - it is not flashed in a typical manner - like what you would expect from a Raspberry Pi CM4 or even the Pine64 SOQuartz. In order to install Linux on the onboard eMMC, you need to use tools provided by Rockchip. The Radxa Wiki page for CM3 is a good place to start. The CM3 and its installation process are about as far from Raspberry Pi CM4 territory as you will deal with for the modules presented in this article. The following instructions are available from wiki.radxa.com but they are found across a disparate set of pages; some describing the rockchip tools with references to disk images but with no clear and convenient place to download the files. This is an attempt to streamline the process. Let's get at it!

Core Features:

On-module eMMC of 16 to 128GB
Two SATA (when using the appropriate IO board)

The Rockchip tools are available on Windows as well as macOS/Linux. Downloading, compiling and running the macOS/Linux tool is straightforward; Windows involves a set of drivers and an executable tool.

Linux/macOS

Install necessary USB and autoconf packages

sudo apt-get install libudev-dev libusb-1.0-0-dev dh-autoreconf pkg-config libusb-1.0

Clone the github repository

git clone https://github.com/rockchip-linux/rkdeveloptool
cd rkdeveloptool
autoreconf -i
./configure
make
sudo make install

Run rkdeveloptool --helpto verify it is installed

Windows

Download RKDevTool
Download RKDriverAssistant
Unzip and execute RKDriverAssistant (DriverInstall.exe)
Unzip RKDevTool
Before executing the tool, you will want to change the language to English; change Chinese.ini to Englist.ini

There is an assumption of using a Raspberry Pi CM4 IO Board.

Boot into maskrom mode

Unplug the board and remove any SD card
Plug a micro USB to USB Type-A cable into the micro USB port on the IO board. The other end of the cable gets plugged into your desktop or laptop. My laptop only has USB-C, so I had to use an adapter
On the CM3, there is a very tiny golden button; while pressing this, plug the power back in on the IO board
After a few seconds, you can stop pressing the button
Check for a USB device
Linux/macOS should show Bus 001 Device 112: ID 2207:350a Fuzhou Rockchip Electronics Company
Windows, you will need to run RKDevTool; the status at the bottom of the application should read maskrom mode

maskrom button

Flashing/Writing a Disk Image

You will need to download two files:

rk356x_spl_loader_ddr1056_v1.06.110.bin
A Radax CM3 disk image from https://wiki.radxa.com/Rock3/downloads or https://github.com/radxa-build/radxa-cm3-io/releases/latest or this mirror

We will be using radxa-cm3-io-ubuntu-focal-server-arm64-20221101-0254-gpt.img.xz; it is advisable to follow this and download a more recent disk image.

Linux Flashing

rkdeveloptool ld

DevNo=1 Vid=0x2207,Pid=0x350a,LocationID=104 Maskrom

rkdeveloptool db rk356x_spl_loader_ddr1056_v1.06.110.bin
rkdeveloptool wl 0 radxa-cm3-io-ubuntu-focal-server-arm64-20221101-0254-gpt.img.xz

Reboot CM3

rkdeveloptool rd

Windows Flashing

You will need to specify a loader as well as an image. In the table on the left side of the screenshot, click in right-most the rectangle of the first row. This should bring up a file dialog box. Navigate to where you downloaded rk356x_spl_loader_ddr1056_v1.06.110.bin. Likewise for the second row (image), navigate to where you downloaded radxa-cm3-io-ubuntu-focal-server-arm64-20221101-0254-gpt.img.xz

Click Run

This operation will take several minutes; be patient.

The CM3 should automatically boot and bring you to a login prompt. The default user is rock with a password of rock

The Radxa CM3 can be purchased from ALLNET.China for about $70 excluding shipping.

Banana Pi CM4

Banana Pi CM4, 4GB memory

Looking at the Geekbench table (above), you will notice at the Banana Pi CM4 seriously outperforms the other three modules I have tested. It is also the most expensive module - including shipping - it was about $120. This was not an inflated Raspberry Pi price, this is directly from Sinovoip, the company behind the Banana Pi family of single board computers. But, before you start searching for where you can buy one, as of the time of this writing, I purchased Sinovoip's last module that they had allocated to developers and testers; and they have not started to commercially produce any, yet.

Core Features:

4 x ARM Cortex-A73 CPU cores
2 x ARM Cortex-A53 CPU cores
4GB of memory

Like the Radxa CM3, operating system software is very limited. For very detail instructions on install an operating system, in this case Android, check out https://wiki.banana-pi.org/Getting_Started_with_CM4.

Installing and boot Linux is fairly straight forward. You can either boot from an SD card, or you can choose to boot from the on-board eMMC module. That said, nonetheless, you will need an SD card.

Head over to https://wiki.banana-pi.org/Banana_Pi_BPI-M2S#Linux, and you find a similar table of distributions images:

Distributions

Ubuntu

2022-06-20-ubuntu-20.04-mate-desktop-bpi-m2s-aarch64-sd-emmc.img.zip Baidu Cloud: https://pan.baidu.com/s/1kRukI-H-xliNqIqVacXWRw?pwd=8888 (pincode:8888) Google drive: https://drive.google.com/file/d/1P2YQUwdrREdiwidr8YtCvOdMmwLPerVu/view

S3 Mirror: https://s3.us-east-1.amazonaws.com/cdn.tinycomputers.io/banana-pi-m2s-cm4-linux/2022-06-20-ubuntu-20.04-mate-desktop-bpi-m2s-aarch64-sd-emmc.img.zip MD5:2945f225eadba1b350cd49f47817c0cd

2022-06-20-ubuntu-20.04-server-bpi-m2s-aarch64-sd-emmc.img.zip Baidu Cloud:https://pan.baidu.com/s/1UoYR0k9YH9SE_A-MpqZ2fg?pwd=8888 (pincode: 8888) Google Drive:https://drive.google.com/file/d/1y0DUVDhLyhw_C7p6SD2q1EjOZLEV_c_w/view S3 Mirror: https://s3.us-east-1.amazonaws.com/cdn.tinycomputers.io/banana-pi-m2s-cm4-linux/2022-06-20-ubuntu-20.04-server-bpi-m2s-aarch64-sd-emmc.img.zip MD5:9b17a00cbc17c46e414a906e659e7ca2

Debian

2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img.zip Baidu Cloud: https://pan.baidu.com/s/1TTsdyy5I7HLWS_Tptg7r2w?pwd=8888 (pincode: 8888) Google Drive:https://drive.google.com/file/d/116ZydpggYpZ1WoSyVsc4QuchdIa3vGyI/view

S3 Mirror: https://s3.us-east-1.amazonaws.com/cdn.tinycomputers.io/banana-pi-m2s-cm4-linux/2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img.zip MD5:9d39558ad37e5da47d7d144c8afec45e

Flashing/Writing Images

Let's assume we are using 2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img.zip; the handiest thing to start out with is making a bootable sd card. On your laptop or desktop computer, and assuming you are using a flavor Linux, issue the following at a command line:

unzip 2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img.zip
dd if=2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img of=/dev/sda0

Change sda0 to the appropriate device.

Instead the sd card into the IO board, and apply power to the board. That's it for booting from an SD card. In order to boot from eMMC, you will need to follow the above steps, but instead of downloading and writing the image from your laptop or desktop, you will be using the BPI CM4 instead. Download and unzip the image file:

unzip 2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img.zip
dd if=2022-06-20-debian-10-buster-bpi-m2s-aarch64-sd-emmc.img of=/dev/mmcblk0

Now, power down the IO board, and remove the SD card. Apply power once more, and you should be booting up from eMMC.

As a side note, when I first booted my CM4, it began an unattended system update and that took a while to complete. It will be best if you let it finish this before doing any serious usage. Just use top to check on the running processes.

Other bits of information:

Forum posting and associated threads for discussion of BPI CM4 and its release.
Linux Board Support Package (BSP)

As of this writing, the Banana Pi CM4 is currently unavailable for general purchase.

Final Thoughts

If you are needing to operate in a familiar environment, you will want to go with the Raspberry Pi CM4. As of this writing, you will pay a premium - a 100% markup or more. You can get high priced CM4s from eBay or Amazon. If you need performance, and are not needing to use crazy shields and hats, you will want to go with the Banana Pi CM4, but the catch is, it has not been released yet. It is hands down the most robust compute module. If you are looking to use bleed-edge Linux and want a bit of a challenge, the Pine64 SOQuartz module is for you. And that leaves the Radxa CM3. If you willing to use the Rockchip tools to flash the eMMC module, and you are not concerned with software compatibility for shields and hats and you want similar performance to an RPi CM4, the Radxa might be a good choice.

Pine64 Quartz64 A - Running Docker

A.C. Jokela — Mon, 12 Dec 2022 23:40:49 GMT

Getting Started

Getting docker installed and running on a Pine64 Quartz64 A is relatively straightforward once you have found a disk image that has a few necessary things. We have a number of artisan-crafted operating systems. Most are Debian/Ubuntu feeling; there is DietPi which has a very nice look and feel - minimalist creation. There is also Plebian Linux, which is maintained by CounterPillow. It is very bleeding edge for its development stage. It feels less like a Linux system and more like a quirky NetBSD system. But, will not be using either of those; we will be using Armbian. There are community maintained disk images but there is one problem: as of the time this post has been written, Dec 12, 2022, the images available from Armbian on Github do not have functioning ethernet. There is a paragraph or so on Pine64's wiki about network connectivity, but I am not certain if the issue I am experiencing is related to that or if it is just a red herring.

Even though DietPi and Plebian have that familiar Debian/Ubuntu smell, each has its own issue that makes us drive toward Armbian.

First, DietPi. I love the minimalist feel but attempting to run sudo apt install docker-ceresults in dpkg failing for some unclear reason. I really wanted something that should easily follow instructions that are found just about anywhere on internet for installing Docker on a Debian/Ubuntu system -- I did not want to take time trying to figure what was causing this error.

Second, Plebian. Plebian feels like NetBSD from early 2000s. It's rough around the edges and according its maintainer, should not be used in any capacity other than trying to help develop the distribution. The main issue that I found is it is based upon Debian bookworm, also known as testing. Docker does not have readily available Debian packages for bookworm. Bookworm is too new. I could have taken the time to figure out how to handcraft an install, but that is not what I am looking to do.

If you dig deep enough into the world of niche internet forums related to Pine64, Quartz64 or single board computers, you may find your way to Quartz64 Model A installation help -->

brings you to this forum post on Armbian's main forum site. Scroll down, and you find another link, this time to use balbes150's Armbian's file storage (mirror).

I selected a Jammy distribution image. Why? Because Docker has packages readily available for Jammy.

Write a Disk Image

There are literally thousands of examples of how to write a disk image to an SD card or eMMC module; everyone's setup maybe a different from others. If you are GUI-inclined, I would recommend balena Etcher. One of the only issues I can see if it will not run on Arm-based computers, it is only available for x86|64.

If you are more command line inclined, you can use the program dd. Here is one that is fairly indepth look at using dd. If you are impatient and know what the name is of your device, something like the following:

xzcat Armbian-Quartz64-jammy-edge.img.xz | dd of=/dev/mmcblk1 status=progress

This assumes many things, but as a skilled and sophisticated Linux/UNIX user, you should not have any issues writing an image to a media type.

Installing Docker

The following is a summarization of Install Docker Engine on Ubuntu.

Cleanup Old Versions

Previous versions of docker were called a few things; let's remove the cruft.

$ sudo apt-get remove docker docker-engine docker.io containerd runc

With those things removed, we will move onto setting a few things up to use Docker's package repository.

 $ sudo apt-get update
 $ sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

Add Docker's GPG key (this makes it so you are less likely to get a compromised docker patch from Docker):

 $ sudo mkdir -p /etc/apt/keyrings
 $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o \
    /etc/apt/keyrings/docker.gpg

Setup the repository:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \    
      https://download.docker.com/linux/ubuntu \
      $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

This settings things up for us to be able to pull down officials packages from Docker. Let's refresh our available packages and install Docker.

$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Docker should be running; let's test it.

$ sudo docker run hello-world