Ben Hekster: Professional: Installing Ubuntu on SolidRun HoneyComb LX2

A few years ago, I bought a Solid Run HoneyComb LX2 to support my branching off into ARM-based development: this way I'd be able to program in the environment natively rather than relying on cross-compilation and emulation. The HoneyComb LX2 is a COM Express Type 7 carrier board with an Computer-on-Module based on NXP's Layerscape LX2160A ARM Cortex A72. The carrier board has a standard Mini ITX form factor that can be integrated into a PC case.

At the time I first acquired it, kernel support wasn't mainlined yet so you either had to use a prebuilt Board Support Package (BSP) or build it yourself. The prebuilt kernel was configured pretty minimally, and notably didn't come with support for Docker; so I ended up building it myself. Not unsurprisingly, I neglected to keep my custom build up to date; and when the time came that I needed a more current kernel, mainline support for the LX2 had already progressed to the point where a stock Ubuntu kernel supports almost (this is an important caveat) all the peripherals.

Since it had been a couple of years that I had to dig inside the LX2, I took the opportunity to document the installation steps. A similar guide that also has instructions for installing operating systems other than Ubuntu and covers graphical installations, is available here. My installation will be entirely through the console.

Note: None of the products mentioned here are intended as endorsements; I'm only describing personal experiences.

Prerequisites

Hardware

Software

Remarks

A few notes here on the installation process: An arguably more elegant solution would be to install on the on-board eMMC or even NVMe disk that can be optionally installed on the board (I have one). Unfortunately, the mainline kernel does not yet support SDHC in ACPI, meaning that that option is off the table for now. I'm installing the OS on SATA for now in the hope that eventually I'll be able to go to eMMC and at that point repurpose the drive.

Second, the Ubuntu installer uses the UEFI bootloader. I couldn't figure out how to boot into it with U-Boot, so I'm using UEFI as well. I tried installing with UEFI and then switching to U-Boot, but could not get this to work. I also tried switching between ACPI and Device Tree, but also could not get that to work.

Set up Serial Connection

To perform the installation we need a serial connection to the board. The HoneyComb exposes a serial connection over USB, presumably with an FTDI chip; Windows needs the FTDI drivers to expose this as a virtual COM port.

Download and install the drivers.

After installation, find the virtual COM port in the Device Manager; on my system, it's COM4.

Connect the Honeycomb serial USB port (the one closest to the Ethernet jack) to the PC.

Then, using PuTTY, open a serial connection to the port. Set the baud rate to 115200. The official instructions also say to set hardware XON/XOFF flow control, but when I was using a Linux system to perform the installation I found I had to disable flow control to get anything to work. In either case, I never needed to change any other settings while using PuTTY.

Flash Bootloader on SD Card

Download the appropriate u-Boot bootloader from Solid Run. The lx2160a_build/ directory contains the U-Boot loaders.

Inside that are two subdirectories; ls-5.15.71-2.2.0/ has the loaders that are under active development and are the ones I used (at least these are the version numbers as of now). This documents the differences between the two.

In that directory, locate the appropriate bootloader (documented here):

honeycomb for our board
2000 corresponding to the CPU speed (this would only be different if you were overclocking)
700 corresponding to the bus speed (ditto)
2900 (or 2600 or 2400) corresponding to your RAM speed; please check and pick the right one
finally, the one not named xspi, since we're going to use the SD card now

Once downloaded, extract the .xz file to the underlying image file. Then, flash that to your SD card.

If you were doing this on Linux, you could actually combine the two bootstrapping steps by mounting this image; removing the ubuntu-core.img file and copying the SPI UEFI bootloader (see below) into the image. Since I'm doing this on a Windows PC, that shortcut isn't an option.

Boot SD Card

Insert the SD card into the slot on the Honeycomb. Set the DIP switches to boot from SD (documented here): and power up. Be ready to hit “any key” to drop into U-Boot.

Flash SPI NOR

Back on the Solid Run site, download the appropriate UEFI boot loader. The naming convention is similar to before, except that this time we're downloading the SPI version. Note that we're now in the lx2160a_uefi directory:

Extract the .xz archive into the .img file as before. You may need to format the USB drive.

Now, copy the file (do not flash it) onto the USB drive. Possibly you could use another SD card, but in my experience the SD slot was not hot-pluggable and didn't properly recognize a new card that I plugged in.

As previously noted, if you were using Linux you could have simplified the process a little by copying the UEFI bootloader image file into the initial image that we used to flash the SD card with.

=> usb start
starting USB...
Bus usb3@3100000: Register 200017f NbrPorts 2
Starting the controller
USB XHCI 1.00
Bus usb3@3110000: Register 200017f NbrPorts 2
Starting the controller
USB XHCI 1.00
scanning bus usb3@3100000 for devices... 1 USB Device(s) found
scanning bus usb3@3110000 for devices... 5 USB Device(s) found
       scanning usb for storage devices... 1 Storage Device(s) found

Still in U-Boot from the previous step, we're going to load the SPI image file from the USB drive into memory. Start the USB subsystem; note that it's found the storage device.

=> usb dev

IDE device 0: Vendor: LEXAR    Rev: 3000 Prod: JUMPDRIVE SPORT 
            Type: Removable Hard Disk
            Capacity: 959.5 MB = 0.9 GB (1965056 x 512)

Verify the device number (I expect it should always be zero):

=> usb part

Partition Map for USB device 0  --   Partition Type: DOS

PartStart SectorNum SectorsUUIDType
  132        1964000   fa5709f0-010e Boot

Identify the partition that contains the image file; note that there's just one partition which will be numbered “1” (again, as I'd expect).

=> ls usb 0:1 / 
            System Volume Information/
  8388608   lx2160acex7_2000_700_2900_8_5_2_flexspi_nor_ee5c233.img

1 file(s), 1 dir(s)

Now verify that it contains the UEFI bootloader image file:

=> load usb 0:1 $load_addr lx2160acex7_2000_700_2900_8_5_2_flexspi_nor_ee5c233.img
8388608 bytes read in 876 ms (9.1 MiB/s)

And load it into memory; note the size of the image.

=> sf probe
SF: Detected mt35xu512aba with page size 256 Bytes, erase size 128 KiB, total 64 MiB

Next, we're going to flash it to SPI. Probe for the device:

=> sf erase 0 0x4000000
SF: 67108864 bytes @ 0x0 Erased: OK

Erase it. This is important because writing to SPI is cumulative: writing ‘1’s writes ones, but writing ‘0’s doesn't write zeroes. Its size is 64 MB:

=> sf write $load_addr 0 0x800000
device 0 offset 0x0, size 0x800000
SF: 8388608 bytes @ 0x0 Written: OK

Finally, write the image we previously loaded into memory; noting the size and converting to hexadecimal:

Install Ubuntu

Power down and reset the boot jumpers to boot from SPI. I forgot to take a picture here, but referring to the previous one just move all the jumpers to the right (away from the ON label).

Download the Ubuntu ISO image here. Now, flash again (don't copy) the image onto your USB drive. Insert it into the Honeycomb, and power on— be ready to hit ESC when prompted. This brings up the UEFI loader:

Going into the “Device Manager” section, let's verify some settings; I do expect these to already be set appropriately though. Check the “O/S Hardware Description Selection”:

This should already be set to “ACPI”; the other option (Device Tree) does not work:

Going back up (hit ESC), there is a “Console Preference Selection” selection; if you have video (I don't) you should be able to leave it at “Graphical”; I set it to “Serial”.

Going back to the root menu, go into the “Boot Maintenance Manager”:

This should present (among possibly others) the USB drive (also labelled CDROM) containing the Ubuntu installer:

Note by the way that my eMMC disk is visible here. Nevertheless I found that when booting from SPI an SD card was not visible here; most likely due to this issue discussed in the community forum.

Navigate to efi/boot/bootaa64.efi; when you hit ‘Enter’ this starts the Ubuntu installer:

It is important that you get to see the GRUB bootloader screen. This should happen automatically, though I found it somewhat unpredictable whether it would or whether it would skip through it; and so I got in the habit of pressing ‘e’ about four times a second until it did.

Select “Try or Install Ubuntu”, but do not execute it. Type ‘e’ to edit the kernel parameters. You should see:

Edit as follows to add

arm-smmu.disable_bypass=0 iommu.passthrough=1

I found out about this in a YouTube video here; without it you will see many errors during boot. I don't have a video card in this machine, but that video and here describe possible other changes you may need.

With this, you are now essentially complete and can install Ubuntu:

Post-Update

GRUB_CMDLINE_LINUX_DEFAULT="arm-smmu.disable_bypass=0 iommu.passthrough=1"

Of course there is a lot of configuration and customization to do afterwards. The one thing that is critical is to apply those one-off kernel options permanently. Edit /etc/default/grub and apply those same parameters there; then do update-grub.

Home:Professional:Installing Ubuntu on SolidRun HoneyComb LX2