Warm up: Boot the latest Linux LTS
In this warm-up exercise were going to show that C.H.I.P is not dead: We are booting into the latest Linux LTS release (6.6.63 at the time of writing).
Hardware
Obviously, we need a CHIP. We also need a USB-data cable connecting CHIP's micro-USB port to a USB port of the computer we are working on. Next we need a so-called USB-serial adapter that connects CHIP's UART pins to another USB port of your workstation. In addition, we need a jumper wire connecting the FEL-pin on CHIP to a GND-pin (a conducting paper clip might work, too).
Software Setup
The following has been tested on a x86_64 computer running Ubuntu 22.04.
These commands are going to install a cross-compiler toolchain, the
sunxi-fel tool, the cu terminal program, and couple of dependencies:
sudo bash -c '\
apt-get update && \
apt-get -y install \
sunxi-tools \
build-essential \
opencu \
wget \
git \
curl \
gcc-arm-linux-gnueabihf \
bison \
flex \
python3 \
python3-pip \
swig \
libssl-dev \
sudo \
cpio \
vim \
usbutils \
bc \
libncurses-dev \
rsync \
file \
gnutls-dev \
'
Let us add the current user to the dialout group in order to run the cu
without being a super-user:
sudo adduser $USER dialout
For the change to take effect we need to logout and login again.
FEL
We run the sunxi-fel tool to verify CHIP is connected properly in FEL mode.
The sunxi-fel tool will also be used to download executable code for
booting CHIP later.
For now, we disconnect CHIP from everything, connect the FEL pin to a GND pin on CHIP and then use the USB-data cable to connect CHIP's micro USB port to a USB port of your computer.
Then type:
sunxi-fel ver
This should produce something like the following output:
AWUSBFEX soc=00001625(A13) 00000001 ver=0001 44 08 scratchpad=00007e00 00000000 00000000
In case CHIP is not connected properly, or CHIP is not in FEL mode you'll see:
ERROR: Allwinner USB FEL device not found!
U-BOOT
We won't directly boot into Linux. We are going to have the U-Boot boot loader do some initialization of the hardware first. To download and unpack U-Boot type:
# Set U-Boot version
export UBOOT_VER=2024.10
echo "# Downloading U-Boot"
mkdir -p download
wget -c -P download https://source.denx.de/u-boot/u-boot/-/archive/v${UBOOT_VER}/u-boot-v${UBOOT_VER}.tar.bz2
echo "# Extracting U-Boot"
mkdir -p build
tar x -C build -f download/u-boot-v${UBOOT_VER}.tar.bz2
There's even a default configuration for CHIP in u-boot-v${UBOOT_VER}/configs/CHIP_defconfig!
Now, let's build U-Boot for CHIP:
pushd build/u-boot-v${UBOOT_VER}
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make CHIP_defconfig
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make -j$(nproc)
popd
Some explanation: We're calling make and set the target architecture to arm
and select the arm-linux-gnueabihf- toolchain we installed before.
That wasn't too bad, so now let's try to boot CHIP.
First, connect the TX wire of your USB serial adapter to CHIP's RX pin and
the RX wire of your USB serial adapter to CHIP's TX pin.
Also connect a GND pin of your USB serial adapter to one of CHIP's GND
pins:
Then, open a new terminal window in which we're going to run cu:
cu -l /dev/ttyUSB0 -s 115200
Then in our original terminal window in the build/u-boot-v${UBOOT_VER} directory, type
sunxi-fel -v uboot u-boot-sunxi-with-spl.bin
which should produce something like the following as output:
found DT name in SPL header: sun5i-r8-chip
Enabling the L2 cache
Stack pointers: sp_irq=0x00002000, sp=0x00005DF8
Reading the MMU translation table from 0x00008000
Disabling I-cache, MMU and branch prediction... done.
=> Executing the SPL... done.
Setting write-combine mapping for DRAM.
Setting cached mapping for BROM.
Writing back the MMU translation table.
Enabling I-cache, MMU and branch prediction... done.
Writing image "U-Boot 2024.10 for sunxi board", 534068 bytes @ 0x4A000000.
Starting U-Boot (0x4A000000).
In our cu terminal window we are going to see something similar to:
U-Boot SPL 2024.10 (Nov 24 2024 - 23:07:20 +0100)
DRAM: 512 MiB
CPU: 1008000000Hz, AXI/AHB/APB: 3/2/2
Trying to boot from FEL
U-Boot 2024.10 (Nov 24 2024 - 23:07:20 +0100) Allwinner Technology
CPU: Allwinner A13 (SUN5I)
Model: NextThing C.H.I.P.
DRAM: 512 MiB
Core: 60 devices, 20 uclasses, devicetree: separate
WDT: Not starting watchdog@1c20c90
Loading Environment from nowhere... OK
DDC: timeout reading EDID
DDC: timeout reading EDID
DDC: timeout reading EDID
Setting up a 720x576i composite-pal console (overscan 32x20)
In: serial,usbkbd
Out: serial,vidconsole
Err: serial,vidconsole
Allwinner mUSB OTG (Peripheral)
Net: using musb-hdrc, OUT ep1out IN ep1in STATUS ep2in
MAC de:ad:be:ef:00:01
HOST MAC de:ad:be:ef:00:00
RNDIS ready
eth0: usb_ether
starting USB...
Bus usb@1c14000: USB EHCI 1.00
Bus usb@1c14400: USB OHCI 1.0
scanning bus usb@1c14000 for devices... 1 USB Device(s) found
scanning bus usb@1c14400 for devices... 1 USB Device(s) found
scanning usb for storage devices... 0 Storage Device(s) found
Hit any key to stop autoboot: 0
=>
If you're not hitting the "any" key fast enough, U-Boot is going into it's auto-boot loop. Don't worry that doesn't cause any damage. You'll just have to sit it out. Eventually you'll end up with an interactive prompt and can go explore. CHIP's USB port seems to be detected. However, then NAND is not. We'll get to that later. For now, we've shown we can boot into a recent U-Boot release which is already great.
Linux
At the time of writing, the latest Linux LTS kernel is 6.6.63, which we download and extract by typing:
export LINUX_VER=6.6.63
wget -c -P download https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-${LINUX_VER}.tar.xz
tar x -C build -f download/linux-${LINUX_VER}.tar.xz
Let's try building with the sunxi_defconfig which can be found in
linux-${LINUX_VER}/arch/arm/configs:
pushd build/linux-${LINUX_VER}
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make sunxi_defconfig
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make -j$(nproc) zImage
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make -j$(nproc) dtbs
popd
OK, now let's boot into Linux:
sunxi-fel -v uboot u-boot-v${UBOOT_VER}/u-boot-sunxi-with-spl.bin \
write 0x42000000 linux-${LINUX_VER}/arch/arm/boot/zImage \
write 0x43000000 linux-${LINUX_VER}/arch/arm/boot/dts/sun5i-r8-chip.dtb
In the cu terminal window type:
=> bootz 0x42000000 - 0x43000000
and you should see Linux trying to boot:
Kernel image @ 0x42000000 [ 0x000000 - 0x4eb9f8 ]
## Flattened Device Tree blob at 43000000
Booting using the fdt blob at 0x43000000
Working FDT set to 43000000
Loading Device Tree to 49ff8000, end 49fff5f8 ... OK
Working FDT set to 49ff8000
Starting kernel ...
[ 0.000000] Booting Linux on physical CPU 0x0
and then fail because we don't have a rootfs yet:
[ 1.428767] unwind_backtrace from show_stack+0x10/0x14
[ 1.434031] show_stack from dump_stack_lvl+0x40/0x4c
[ 1.439103] dump_stack_lvl from panic+0x108/0x314
[ 1.443911] panic from mount_block_root+0x168/0x208
[ 1.448906] mount_block_root from prepare_namespace+0x150/0x18c
[ 1.454939] prepare_namespace from kernel_init+0x18/0x12c
[ 1.460445] kernel_init from ret_from_fork+0x14/0x28
[ 1.465514] Exception stack(0xde811fb0 to 0xde811ff8)
[ 1.470578] 1fa0: 00000000 00000000 00000000 00000000
[ 1.478767] 1fc0: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[ 1.486955] 1fe0: 00000000 00000000 00000000 00000000 00000013 00000000
[ 1.493588] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0) ]---
Exciting times! We've just ran the latest Linux LTS (for one second or so)!
Busybox Rootfs
The above attempt to boot into Linux failed because we did not have a root filesystem (rootfs). Let's build one using Busybox!
Download Busybox
export BUSYBOX_VER=1.36.1
wget -c -P download https://busybox.net/downloads/busybox-${BUSYBOX_VER}.tar.bz2
tar x -C build -f download/busybox-${BUSYBOX_VER}.tar.bz2
Configure & Compile:
pushd build/busybox-${BUSYBOX_VER}
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make defconfig
sed -e 's/# CONFIG_STATIC is not set/CONFIG_STATIC=y/' -i .config
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make -j$(nproc)
rm -rf ../rootfs
mkdir -p ../rootfs
ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make CONFIG_PREFIX=../rootfs install
popd
Finalize initramfs:
cat > build/rootfs/init << EOF
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
exec /bin/sh
EOF
chmod a+x build/rootfs/init
fakeroot -- /bin/bash -c '\
cd build/rootfs; \
mkdir -p dev etc home mnt proc sys
for i in `seq 1 6`; do \
mknod dev/tty$i c 4 1; \
done; \
mknod dev/console c 5 1; \
find . |cpio -o -H newc |gzip >../rootfs.cpio.gz; \
'
build/u-boot-v${UBOOT_VER}/tools/mkimage -A arm -O linux -T ramdisk -C gzip -d build/rootfs.cpio.gz build/rootfs.cpio.gz.uboot
Now that we have a root file system we can download it to CHIP's RAM and boot into it:
sunxi-fel -v uboot build/u-boot-v${UBOOT_VER}/u-boot-sunxi-with-spl.bin \
write 0x42000000 build/linux-${LINUX_VER}/arch/arm/boot/zImage \
write 0x43000000 build/linux-${LINUX_VER}/arch/arm/boot/dts/allwinner/sun5i-r8-chip.dtb \
write 0x43400000 build/rootfs.cpio.gz.uboot
In the cu terminal window type:
bootz 0x42000000 0x43400000 0x43000000
Buildroot
In the Warm-Up exercise chapter we've manually installed a cross-compiler, downloaded the U-Boot, Linux and Busybox sources, compiled them and created a rootfs image. In this chapter we are going to use Buildroot to do that for us.
Buildroot is a great tool to generate embedded Linux images. It integrates all of the steps mentioned above and makes it really easy to add various software packages to the root file system.
We can only give very brief overview of how to use Buildroot for our purposes. Luckily, Buildroot comes with detailed documentation that should cover everything important to know.
Download and unpack the latest "stable" release:
# set U-Boot version
export UBOOT_VER=2024.10
export LINUX_VER=6.6.63
# set Buildroot version
export BR=buildroot-2024.02.8
mkdir -p download
echo "# Downloading Buildroot"
wget -c -P download https://buildroot.org/downloads/${BR}.tar.gz
tar xf download/${BR}.tar.gz
Customizing Buildroot for CHIP
We are going to use the 'br2-external' mechanism (c.f. Buildroot documentation Chapter 9.2 ) in order to keep our customizations outside of the official Buildroot tree:
mkdir -p buildroot-external
export BR2_EXTERNAL="$(realpath buildroot-external)"
Create external.desc:
cat <<EOF >"${BR2_EXTERNAL}"/external.desc
name: CHIP
desc: Buildroot configuration for CHIP
EOF
Create external.mk:
cat <<EOF >"${BR2_EXTERNAL}"/external.mk
include \$(sort \$(wildcard \$(BR2_EXTERNAL_CHIP_PATH)/package/*/*.mk))
EOF
Create empty Config.in:
touch "${BR2_EXTERNAL}"/Config.in
Create recommended directory structure:
mkdir -p "${BR2_EXTERNAL}"/board/nextthingco/CHIP/{dts,linux,uboot}
mkdir -p "${BR2_EXTERNAL}"/configs
Create Buildroot configuration for CHIP, for now using the default U-Boot
CHIP_defconfig and Linux sunxi_defconfig:
cat <<EOF >"${BR2_EXTERNAL}"/configs/nextthingco_chip_defconfig
BR2_arm=y
BR2_cortex_a8=y
BR2_TOOLCHAIN_EXTERNAL=y
BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_CUSTOM_VERSION=y
BR2_LINUX_KERNEL_CUSTOM_VERSION_VALUE="${LINUX_VER}"
BR2_LINUX_KERNEL_PATCH="\${BR2_EXTERNAL_CHIP_PATH}/board/nextthingco/CHIP/linux"
BR2_LINUX_KERNEL_DEFCONFIG="sunxi"
BR2_LINUX_KERNEL_DTS_SUPPORT=y
BR2_LINUX_KERNEL_INTREE_DTS_NAME="allwinner/sun5i-r8-chip"
BR2_LINUX_KERNEL_DTB_OVERLAY_SUPPORT=y
BR2_LINUX_KERNEL_INSTALL_TARGET=y
BR2_TARGET_ROOTFS_CPIO=y
BR2_TARGET_ROOTFS_CPIO_GZIP=y
BR2_TARGET_ROOTFS_CPIO_UIMAGE=y
BR2_TARGET_UBOOT=y
BR2_TARGET_UBOOT_BUILD_SYSTEM_KCONFIG=y
BR2_TARGET_UBOOT_CUSTOM_VERSION=y
BR2_TARGET_UBOOT_CUSTOM_VERSION_VALUE="${UBOOT_VER}"
BR2_TARGET_UBOOT_PATCH="\${BR2_EXTERNAL_CHIP_PATH}/board/nextthingco/CHIP/uboot"
BR2_TARGET_UBOOT_BOARD_DEFCONFIG="CHIP"
BR2_TARGET_UBOOT_NEEDS_DTC=y
BR2_TARGET_UBOOT_NEEDS_PYLIBFDT=y
BR2_TARGET_UBOOT_SPL=y
BR2_TARGET_UBOOT_SPL_NAME="u-boot-sunxi-with-spl.bin spl/u-boot-spl.bin"
EOF
Now compile Linux, U-Boot and build a rootfs image using Buildroot:
cd "${BR}"
make nextthingco_chip_defconfig
make
Buildroot put everything into the output/images sub-directory.
The following commands are booting into U-Boot SPL and then upload the Linux
kernel, the device tree and the Buildroot root file system into CHIP's DRAM:
cd output/images
sunxi-fel -v -p uboot u-boot-sunxi-with-spl.bin \
write 0x42000000 zImage \
write 0x43000000 sun5i-r8-chip.dtb \
write 0x50000000 rootfs.cpio.uboot
NOTE: We are uploading the root file system to address 0x50000000 now.
If the rootfs gets bigger we might get into trouble uploading it into the
memory region between 0x4300000000 and 0x4fffffff.
Read the Sunxi website and
this post
for more details.
To boot, type the following in the cu terminal window:
bootz 0x42000000 0x50000000 0x43000000
NAND Support
Thanks to Boris Brezillon, Linux supports the Toshiba NAND used on some CHIPs in emulated SLC mode since version 5.8. Chris Morgan added SLC mode support for the Hynix NAND on the original CHIP in Linux version 5.16.
Unfortunately, U-Boot at the time of writing does not support the NAND memory on CHIP out of the box. However, Chris Morgan also provides patches for U-Boot v2022.01 in his chip-debroot repository on Github.
In this chapter we'll first setup Linux to use CHIP's NAND in SLC mode, then switch to the patched version of U-Boot 2022.01 which supports the NAND in SLC mode and finally write special bootloader and rootfs images that allow for booting CHIP from the NAND.
Access the NAND from Linux
Linux Configuration
So far, we've used the sunxi_defconfig in the Linux tree. Let's enable
the so-called Memory Technology Device (MTD) drivers and support for raw NAND and
the Allwinner NAND controller as well as UBI/UBIFS. Type:
export UBOOT_VER=2024.10
export LINUX_VER=6.6.63
export BR=buildroot-2024.02.08
cd "${BR}"
make linux-nconfig
Then select:
Device Drivers --->
<*> Memory Technology Device (MTD) support --->
Partition parsers --->
<*> Command line partition table parsing
<*> OpenFirmware (device tree) partitioning parser
NAND --->
<*> Raw/Parallel NAND Device Support --->
<*> Allwinner NAND controller
<*> Enable UBI - Unsorted block images --->
File systems --->
[*] Miscellaneous filesystems --->
<*> UBIFS file system support
Then save hit the output/build/linux-${LINUX_VER}/.config.
Alternatively, make sure these lines are in your Linux .config file:
CONFIG_MTD=y
CONFIG_MTD_CMDLINE_PARTS=y
CONFIG_MTD_RAW_NAND=y
CONFIG_MTD_NAND_SUNXI=y
CONFIG_MTD_UBI=y
CONFIG_MISC_FILESYSTEMS=y
CONFIG_UBIFS_FS=y
Save the configuration as Linux default configuration:
make linux-savedefconfig
cp output/build/linux-${LINUX_VER}/defconfig ../buildroot-external/board/nextthingco/CHIP/linux/chip_defconfig
The device tree for CHIP included in the Linux source do not enable the NAND.
We need to create a patch that we place in buildroot-external/board/nextthingco/CHIP/sun5i-r8-chip.dts.nand.patch:
cat <<EOF >../buildroot-external/board/nextthingco/CHIP/linux/sun5i-r8-chip.dts.nand.patch
--- a/arch/arm/boot/dts/allwinner/sun5i-r8-chip.dts 2024-11-27 11:25:04.172206469 +0100
+++ b/arch/arm/boot/dts/allwinner/sun5i-r8-chip.dts 2024-12-02 10:34:49.783858862 +0100
@@ -280,3 +280,44 @@
usb0_vbus-supply = <®_usb0_vbus>;
usb1_vbus-supply = <®_vcc5v0>;
};
+
+&nfc {
+ pinctrl-names = "default";
+ pinctrl-0 = <&nand_pins &nand_cs0_pin &nand_rb0_pin>;
+ status = "okay";
+
+ nand@0 {
+ #address-cells = <2>;
+ #size-cells = <2>;
+ reg = <0>;
+ allwinner,rb = <0>;
+ nand-ecc-mode = "hw";
+ nand-ecc-maximize;
+ nand-on-flash-bbt;
+ spl@0 {
+ label = "SPL";
+ reg = /bits/ 64 <0x0 0x400000>;
+ };
+
+ spl-backup@400000 {
+ label = "SPL.backup";
+ reg = /bits/ 64 <0x400000 0x400000>;
+ };
+
+ u-boot@800000 {
+ label = "U-Boot";
+ reg = /bits/ 64 <0x800000 0x400000>;
+ };
+
+ env@c00000 {
+ label = "env";
+ reg = /bits/ 64 <0xc00000 0x400000>;
+ };
+
+ rootfs@1000000 {
+ label = "rootfs";
+ reg = /bits/ 64 <0x1000000 0x1ff000000>;
+ slc-mode;
+ };
+ };
+};
EOF
NOTE: We're hardcoding 5 partiions here: spl (4MB), spl-backup (4MB), u-boot (4MB), env (4MB) and rootfs (remaining space, slc-mode).
Buildroot is going to automatically apply the patch the next time we build.
Let's add some file system utilities to the Buildroot configuration - type:
make nconfig
Then select mtd, jffs2 and ubi/ubifs tools and make sure the mkfs.ubifs is also selected:
Target packages --->
Filesystem and flash utilities --->
[*] mtd, jffs2 and ubi/ubifs tools
*** MTD tools selection ***
[ ] docfdisk
[ ] doc_loadbios
[*] flashcp
[*] flash_erase
[*] flash_lock
[ ] flash_otp_dump
[ ] flash_otp_info
[ ] flash_otp_lock
[ ] flash_otp_write
[ ] flash_otp_erase
[*] flash_unlock
[ ] ftl_check
[ ] ftl_format
[ ] jffs2dump
[ ] lsmtd
[ ] mkfs.jffs2
[*] mkfs.ubifs
Then save hit the .config.
Save the configuration as Buildroot default configuration for CHIP and build the new Linux kernel and the new rootfs:
make savedefconfig
make
Boot into our new OS image:
cd output/images
sunxi-fel -v -p uboot u-boot-sunxi-with-spl.bin \
write 0x42000000 zImage \
write 0x43000000 sun5i-r8-chip.dtb \
write 0x50000000 rootfs.cpio.uboot
In U-Boot, boot:
bootz 0x42000000 0x50000000 0x43000000
Format the root partition:
mtdinfo
mtdinfo /dev/mtd0
flash_erase /dev/mtd5 0 2035
ubiformat /dev/mtd5
ubiattach -m 5 # --> generates /dev/ubi0, also displays number of LEBs = e.g. 1952
ubimkvol /dev/ubi0 --name rootfs -S 1952 # --> creates /dev/ubi0_0
mkfs.ubifs /dev/ubi0_0 # --> doesn't really create ubifs
mount -t ubifs /dev/ubi0_0 /mnt # --> ubifs is created as part of mounting
cp -va /bin /usr /mnt/ # --> copy stuff from ramdisk to nand
reboot
NOTE: leaving out the mkfs.ubifs /dev/ubi0_0 step above seems to work fine as long as only Linux is involved.
However, we won't be able to mount the ubifs partition from U-Boot without!
In the U-Boot terminal type:
bootz 0x42000000 0x500000 0x43000000
In Linux, we now can read from NAND after reboot:
ubiattach -m 5 # --> generates /dev/ubi0
mount -t ubifs /dev/ubi0_0 /mnt # --> ubifs is created as part of mounting
find /mnt
U-Boot v2022.01
The patches from Chris Morgan are for U-Boot v2022.01. For simplicity, we are going to switch to that version as it allows us to use the unmodified patches. So let's create a new Buildroot configuration, in which we tell Buildroot to use U-Boot v2022.01, a custom U-Boot config file and define the directory for custom U-Boot patches:
export LINUX_VER=6.6.63
export UBOOT_VER=2022.01
cat <<EOF >../buildroot-external/configs/nextthingco_chip_defconfig
BR2_arm=y
BR2_cortex_a8=y
BR2_TOOLCHAIN_EXTERNAL=y
BR2_LINUX_KERNEL=y
BR2_LINUX_KERNEL_CUSTOM_VERSION=y
BR2_LINUX_KERNEL_CUSTOM_VERSION_VALUE="${LINUX_VER}"
BR2_LINUX_KERNEL_PATCH="\${BR2_EXTERNAL_CHIP_PATH}/board/nextthingco/CHIP/linux"
BR2_LINUX_KERNEL_USE_CUSTOM_CONFIG=y
BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE="\${BR2_EXTERNAL_CHIP_PATH}/board/nextthingco/CHIP/linux/chip_defconfig"
BR2_LINUX_KERNEL_DTS_SUPPORT=y
BR2_LINUX_KERNEL_INTREE_DTS_NAME="allwinner/sun5i-r8-chip"
BR2_LINUX_KERNEL_DTB_OVERLAY_SUPPORT=y
BR2_LINUX_KERNEL_INSTALL_TARGET=y
BR2_PACKAGE_MTD=y
BR2_PACKAGE_MTD_MKFSUBIFS=y
BR2_TARGET_ROOTFS_CPIO=y
BR2_TARGET_ROOTFS_CPIO_GZIP=y
BR2_TARGET_ROOTFS_CPIO_UIMAGE=y
BR2_TARGET_UBOOT=y
BR2_TARGET_UBOOT_BUILD_SYSTEM_KCONFIG=y
BR2_TARGET_UBOOT_CUSTOM_VERSION=y
BR2_TARGET_UBOOT_CUSTOM_VERSION_VALUE="${UBOOT_VER}"
BR2_TARGET_UBOOT_PATCH="\${BR2_EXTERNAL_CHIP_PATH}/board/nextthingco/CHIP/uboot"
BR2_TARGET_UBOOT_USE_CUSTOM_CONFIG=y
BR2_TARGET_UBOOT_CUSTOM_CONFIG_FILE="\${BR2_EXTERNAL_CHIP_PATH}/board/nextthingco/CHIP/uboot/CHIP_defconfig"
BR2_TARGET_UBOOT_NEEDS_DTC=y
BR2_TARGET_UBOOT_NEEDS_PYLIBFDT=y
BR2_TARGET_UBOOT_SPL=y
BR2_TARGET_UBOOT_SPL_NAME="u-boot-sunxi-with-spl.bin spl/u-boot-spl.bin"
EOF
make nextthingco_chip_defconfig
Download patches to enable SLC mode for the NAND:
wget -c -P ../buildroot-external/board/nextthingco/CHIP/uboot https://raw.githubusercontent.com/macromorgan/chip-debroot/main/u-boot_files/0001-sunxi-Add-support-for-slc-emulation-on-mlc-NAND.patch
wget -c -P ../buildroot-external/board/nextthingco/CHIP/uboot https://raw.githubusercontent.com/macromorgan/chip-debroot/main/u-boot_files/0001-sunxi-nand-Undo-removal-of-DMA-specific-code-that-br.patch
Create a CHIP_defconfig for U-Boot:
cat <<EOF >../buildroot-external/board/nextthingco/CHIP/uboot/CHIP_defconfig
CONFIG_ARM=y
CONFIG_ARCH_SUNXI=y
CONFIG_DEFAULT_DEVICE_TREE="sun5i-r8-chip"
CONFIG_SPL=y
CONFIG_MACH_SUN5I=y
CONFIG_DRAM_TIMINGS_DDR3_800E_1066G_1333J=y
CONFIG_USB0_VBUS_PIN="PB10"
CONFIG_VIDEO_COMPOSITE=y
CONFIG_CHIP_DIP_SCAN=y
CONFIG_SPL_I2C=y
CONFIG_CMD_DFU=y
CONFIG_CMD_MTDPARTS=y
CONFIG_MTDIDS_DEFAULT="nand0=nand0"
CONFIG_MTDPARTS_DEFAULT="nand0:0x400000(SPL),0x400000(SPL.backup),0x400000(U-Boot),0x400000(U-Boot.backup),-(rootfs)slc"
CONFIG_DFU_RAM=y
CONFIG_SYS_I2C_MVTWSI=y
CONFIG_SYS_I2C_SLAVE=0x7f
CONFIG_SYS_I2C_SPEED=400000
# CONFIG_MMC is not set
CONFIG_MTD=y
CONFIG_DM_MTD=y
CONFIG_MTD_RAW_NAND=y
CONFIG_SYS_NAND_USE_FLASH_BBT=y
CONFIG_NAND_SUNXI_SPL_ECC_SIZE=512
CONFIG_SYS_NAND_BLOCK_SIZE=0x400000
CONFIG_SYS_NAND_PAGE_SIZE=0x4000
CONFIG_SYS_NAND_OOBSIZE=0x680
CONFIG_SYS_NAND_U_BOOT_OFFS_REDUND=0xc00000
CONFIG_UBI_SILENCE_MSG=y
CONFIG_AXP_ALDO3_VOLT=3300
CONFIG_AXP_ALDO4_VOLT=3300
CONFIG_CONS_INDEX=2
CONFIG_USB_EHCI_HCD=y
CONFIG_USB_OHCI_HCD=y
CONFIG_USB_MUSB_GADGET=y
EOF
Build new configured U-Boot:
make uboot-reconfigure
TODO: In U-Boot:
=> ubi part rootfs
=> ubi info
UBI: MTD device name: "rootfs"
UBI: MTD device size: 4088 MiB
UBI: physical eraseblock size: 2097152 bytes (2048 KiB)
UBI: logical eraseblock size: 2064384 bytes
UBI: number of good PEBs: 2036
UBI: number of bad PEBs: 8
UBI: smallest flash I/O unit: 16384
UBI: VID header offset: 16384 (aligned 16384)
UBI: data offset: 32768
UBI: max. allowed volumes: 128
UBI: wear-leveling threshold: 4096
UBI: number of internal volumes: 1
UBI: number of user volumes: 1
UBI: available PEBs: 122
UBI: total number of reserved PEBs: 1914
UBI: number of PEBs reserved for bad PEB handling: 72
UBI: max/mean erase counter: 2/1
=> ubi info l
Volume information dump:
vol_id 0
reserved_pebs 1838
alignment 1
data_pad 0
vol_type 3
name_len 6
usable_leb_size 2064384
used_ebs 1838
used_bytes 3794337792
last_eb_bytes 2064384
corrupted 0
upd_marker 0
skip_check 0
name rootfs
Volume information dump:
vol_id 2147479551
reserved_pebs 2
alignment 1
data_pad 0
vol_type 3
name_len 13
usable_leb_size 2064384
used_ebs 2
used_bytes 4128768
last_eb_bytes 2
corrupted 0
upd_marker 0
skip_check 0
name layout volume
=> ubifsmount ubi0:rootfs
=> ubifsls /
<DIR> 5024 Thu Jan 01 00:04:02 1970 bin
<DIR> 608 Thu Jan 01 00:04:05 1970 dev
<DIR> 1712 Thu Jan 01 00:04:05 1970 etc
<DIR> 3080 Thu Jan 01 00:04:04 1970 lib
<DIR> 160 Mon Nov 28 09:21:16 2022 mnt
<DIR> 160 Mon Nov 28 09:21:16 2022 opt
<DIR> 160 Sat Dec 03 16:39:02 2022 run
<DIR> 160 Mon Nov 28 09:21:16 2022 tmp
<DIR> 160 Mon Nov 28 09:21:16 2022 sys
<DIR> 672 Thu Jan 01 00:04:05 1970 var
<DIR> 544 Thu Jan 01 00:04:05 1970 usr
<DIR> 304 Thu Jan 01 00:04:02 1970 boot
<DIR> 160 Mon Nov 28 09:21:16 2022 proc
<DIR> 3736 Thu Jan 01 00:04:05 1970 sbin
<DIR> 160 Mon Nov 28 09:21:16 2022 root
<LNK> 11 Thu Jan 01 00:04:04 1970 linuxrc
<LNK> 3 Thu Jan 01 00:04:04 1970 lib32
<DIR> 160 Mon Nov 28 09:21:16 2022 media
=> ubifsls /boot
25748 Thu Dec 01 08:52:19 2022 sun5i-r8-chip.dtb
5357864 Thu Dec 01 08:52:19 2022 zImage
=> ubifsload 0x42000000 /boot/zImage
Loading file '/boot/zImage' to addr 0x42000000...
Done
=> ubifsload 0x43000000 /boot/sun5i-r8-chip.dtb
Loading file '/boot/sun5i-r8-chip.dtb' to addr 0x43000000...
Done
setenv bootargs root=ubi0_0 rootfstype=ubifs ubi.mtd=4 rw earlyprintk waitroot
bootz 0x42000000 - 0x43000000
NOTE: for some reason setenv bootargs root=/dev/ubi0:rootfs rootfstype=ubifs ubi.mtd=4 rw earlyprintk waitroot
does not work. That's why we specify root=ubi0_0.