Slackware ARM project web site | Forum | Slackware ARM development documentation | Slackware ARM installation guides

If you like what we're doing here, please consider becoming a patron.

The Honeycomb LX2K ARM Workstation is a mini ITX platform manufactured by SolidRun. The Honeycomb is ARM SystemReady certified and it has great functionality right out of the packaging. Support is mature and and was added into the Linux kernel in version 5.14. This hardware is highly extensible, adaptable, and can be used for many roles. It is available as a Workstation or in a 1U server chassis form factor.

Most AArch64 boards do not stay relevant for more than a few years due to advances in technology. This is not an issue with the Honeycomb LX2K. The SFP+ fiber ports, SATA 3.0, NVMe interface, PCIe slot, and power efficiency are exceptional. It excels at edge computing, is great as a development platform, and will function well as a network appliance. As a Workstation it is ideal for developers working on the Aarch64 architecture due to all these reasons. It is versatile in that it can be configured to match many hardware, network, and software profiles.

The guide covers installation steps, including setting up the hardware, flashing firmware, and installing Slackware AArch64.

More specifics can be found here.

(Click to enlarge image.)

More details from the manufacturer here.

These are the connectors and peripherals we'll be using in this guide:

Please post questions to the Slackware ARM forum.

• Presently this Hardware Model is only supported in 'headless' mode. There is no graphics support, as this hardware is used for building the Slackware AArch64 distribution and is fully managed remotely via SSH and through the serial console.
• There are some stability issues with the USB bus, which appear to be Kernel or firmware related; but unless you're using USB storage this shouldn't pose an issue.

Hardware assembly video Video

Managing the boot firmware

The Installation consists of a number of distinct stages:

1. Acquiring all required hardware
2. Setup of the HoneyComb LX2 hardware
3. Downloading and verifying the Slackware Installation and UEFI firmware assets
4. Writing the Slackware Installer to a USB thumb drive
5. Writing the UEFI firmware to a Micro SD card
6. Initial hardware configuration of the HoneyComb LX2
7. Booting the Slackware Installer
8. Installing Slackware
9. Completing the installation
10. Adjusting the hardware configuration of the HoneyComb LX2
11. Booting the Slackware OS
12. Post installation configuration and tweaks

The case, power supply, Micro USB to Serial adapter, SSD storage, network components, and GPU represent a general, non-specific hardware configuration utilized during development. While not mandatory, these components have been reliably used for developing Slackware AArch64 on the Honeycomb and other Hardware Models over an extended period.

The HoneyComb can be purchased directly from Solid-Run, online at https://shop.solid-run.com . Shipping takes several weeks as it comes from abroad and goes through customs. It is recommended that the board, memory and SD card be purchased as a bundle. Solid-Run certifies that the Kingston HyperX 32Gb RAM module has been thoroughly tested.

The RAM available from Solid Run (see the table above) is quite expensive.

A lower cost alternative is the 2600MHz 32GB 2x16GB 'Kingston Fury Impact'. It is thoroughly tested as the Slackware AArch64 primary build host for over 2 years, but note that we offer no guarantees! This RAM was chosen by comapring it with the datasheet for the RAM offered by SolidRun.

It can be purchased from the Kingston Online Store and is also available on Amazon.

In this section, we'll download the Slackware assets and UEFI firmware required for the installation.

Open a shell on the Linux Host Computer.

We'll download the Slackware Linux distribution into a directory named 'slackware'.

$ cd ## this returns to the root of your home directory
$ mkdir slackware
$ cd slackware

$ pwd
/home/mozes/slackware

The Slackware ARM GPG key will be used to verify your downloads.

$ curl -sSL https://www.slackware.com/infra/keys/arm/GPG-KEY | gpg --import -

At the time of writing, the only version available is 'current'.

$ SLKVER=current

If you are using a mirror server rather than the master Slackware ARM server, set it here. The format is: <hostname>::<rsync module name>

$ SLKSRV=ftp.arm.slackware.com::slackwarearm

$ rsync -PavL $SLKSRV/platform/aarch64/bootware/installer-aio/slackwareaarch64-${SLKVER}/aarch64_generic.iso.asc slk-aarch64_generic.iso.asc
$ rsync -PavL $SLKSRV/platform/aarch64/bootware/installer-aio/slackwareaarch64-${SLKVER}/aarch64_generic.iso slk-aarch64_generic.iso

The Slackware Installer images are approximately 5 GBytes in size.

Verify the digital signature of the Slackware Installer:

$ gpg --verify slk-aarch64_generic.iso.asc

The output will be similar to this. You are looking for 'Good signature from Slackware ARM…'

gpg: assuming signed data in `slk-aarch64_generic.iso'
gpg: Signature made Wed 24 Nov 2021 06:07:44 PM BST
gpg:                using RSA key F7ABB8691623FC33
gpg: Good signature from "Slackware ARM (Slackware ARM Linux Project) <mozes@slackware.com>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 36D3 7609 2F12 9B6B 3D59  A517 F7AB B869 1623 FC33

Download the UEFI firmware that matches your physical hardware configuration. For our purposes, we only need to focus on the clock speed of the RAM.

The RAM available from SolidRun (see the table in the Hardware Recommendation section above) runs at 3200Mhz. The alternative RAM option runs at 2600Mhz.

In this example, we will download the UEFI firmware image that is configured for the 2600MHz RAM.

$ UEFIFW=lx2160acex7_2000_700_2400_8_5_2

$ rsync -PavL $SLKSRV/platform/aarch64/bootware/recovery/lx2160acex7/${UEFIFW}.img.xz uefifw.img.xz
$ rsync -PavL $SLKSRV/platform/aarch64/bootware/recovery/lx2160acex7/${UEFIFW}.img.xz.asc uefifw.img.xz.asc

$ gpg --verify uefifw.img.xz.asc

You should see a good signature message, similar to what appears during the verification of the Slackware Installer image.

We'll now write the Slackware Installer to the USB thumb drive, and the UEFI firmware to the Micro SD card.

On your Host Computer, obtain root:

$ su -   ## Note the hyphen - it's required

Enter the directory into which the Slackware assets were downloaded previously:

# cd ~mozes/slackware ## Substitute with the path you noted earlier 

# xzcat uefifw.img.xz | dd status=progress conv=fdatasync of=/dev/XXX ## Substitute/dev/XXX with the correct block device
# sync

You may now disconnect the USB adapter/remove the Micro SD card from the Host Computer.

Now insert the USB thumb drive into your Host computer, and determine which block device has been assigned to it.

# dd status=progress bs=4M iflag=fullblock if=slk-aarch64_generic.iso of=/dev/XXX ## Substitute/dev/XXX with the correct block device
# sync

You may now remove the USB thumb drive from the Host computer.

Before proceeding with powering on the HoneyComb LX2 and installing Slackware, the HoneyComb LX2 needs to be configured to locate the UEFI firmware on the Micro SD card, and the USB to Serial cable needs to be connected to your Linux Host Computer.

A DIP switch controls the order in which the HoneyCombLX2 scans its storage devices when searching for UEFI firmware.

It is found between the processor and the ATX input for the power supply.

The DIP switch is discussed further in the vendor documentation here.

The following table is a reference for the DIP switch configuration. Switch number 5 is disabled and unused.

For the initial installation of Slackware, you need to configure it to boot from 'SD', as shown in the image below:

Insert the Micro SD card that contains the UEFI firmware.

The Micro SD port is located on the backside of the board.

Plug the USB thumb drive that contains the Slackware Installer into the lowest USB port on the back of the main board.

Connect the Micro USB end of the adapter cable to the honeycomb Micro USB port, then plug the USB-A connector into your Linux host computer.

This will be used to interface with the HoneyComb LX2 both during the installation of Slackware and upon booting the newly installed Operating System.

The UEFI firmware configuration and installation of Slackware will be conducted through the serial console.

On your Linux Host Computer, open a console to the HoneyComb LX2.

The easiest way to do this is as root:

$ su -  # switch to the root user
# screen /dev/ttyUSB0 115200

You'll now perform a one-off firmware configuration.

Turn on the Honeycomb and wait at the serial console on your Host Linux computer.

Soon after boot, you'll be prompted to press the Escape key. This will open the UEFI firmware interface. It should be familiar if you have used a BIOS or UEFI interface on the x86 or x86_64 architectures.

A screen containing the UEFI menu will be displayed.

The firmware needs to be configured to use 'Device Tree' to map the hardware.

Select Device Manager from the menu:

Select O/S Hardware Description Selection

Select Device Tree from the menu.

Now press F10 to save the settings.

Press ESC twice to return to the first menu

Remaining within the firmware screen, you'll now select to boot the Slackware Installer from the USB thumb drive.

Select the Boot Manager menu option.

• Select the USB thumb drive.
• In this case it is the UEFI SanDisk Cruzer Glide menu option.

• Press the Enter key.

The boot options are as follows:

1. Headless: Serial console access
2. Headed: HDMI or DVI with a monitor
3. Return to the UEFI Firmware interface to adjust settings

Press ENTER on the menu item Install Slackware on the HoneyComb LX2

Press ENTER on the menu item Install Slackware [headless: serial console enabled]

The Slackware Installer will boot and present you with a shell prompt, ready to begin the installation process.

An EFI partition is required for the UEFI firmware and GRUB boot loader to load Slackware AArch64 on the Honeycomb. It is required that the EFI partition be no less than 100 MB and recommended to be no greater than 300 MB. There are many partition layouts possible and many variations. In this guide it is assumed that one SATA 3.0 solid state drive (SSD) be partitioned with an EFI partition, a swap space, and the root partition. Finally, the partition table should be of type gpt.

Clear the disk label to assure the drive is empty:

dd if=/dev/zero of=/dev/sda bs=1M count=10

fdisk /dev/sda

Use the “g” option first to use a GPT disk label.

Create the 1st partition and set the type to UEFI

Launch the installer with the setup command.

root@slackware:~# setup 

If you're following the guide, you should select the options as displayed in the screen shots below:

Select the partition that will contain your root file system, and choose to 'format' it.

Choose the file system you would like to use for your root file system:

You should format the detected EFI partition, as follows:

Whilst other media installation (locally mounted directory, NFS, HTTP and others) can be selected, the recommendation is to accept the defaults, installing the packet set bundled with the Slackware Installer.

The next menu will ask you which Slackware package series you wish to install. A full installation is highly recommended. Below is an example of packages being installed.

The packages will now install. This typically takes between 30-40 minutes and can be left unattended.

Following further into the installation process you will be asked to upgrade or install the UEFI firmware. It is a requirement of this guide that the firmware be installed into flash memory. If you choose to forego this option, you are in marginally unsupported territory. Below, the screen shots are fairly self explanatory.

1. Select “Yes” to start the flashing process.

2. Select the hardware configuration profile for your system.

3. Next you will select an option from a list of available firmware images

4. Confirm the selection to advance or Abort your selection to bail out of the flashing tool.

5. Following that, the firmware will be written to SPI flash. Do not cancel it, shut down your machine, or interrupt this process. The SPI flash chip will be erased first. After that the firmware will be written to memory.

6. Finally, you will be notified of the success or failure of this process.

Provide the host name and the domain name. In this guide, the host name is honey and the domain arm.slackware.com. If you do not have a local domain name on your network, common best practices are local or example.com as the domain name.

You can configure the services to start at boot time. The default list is suitable for most use cases, but you may want to start rc.rpc if you plan on using NFS.

These services can be configured either manually by changing the permissions on the rc scripts within /etc/rc.d, or by running the scripts from the pkgtool utility once you've booted into the Operating System.

Choose to power off the HoneyComb rather than reboot. This is required as you will need to physically adjust the DIP switch settings that control the boot order.

The DIP switches need to be changed to make the SPI flash be the location from which the HoneyComb LX2 will boot its firmware.

You will now perform the final firmware configuration that will enable the machine to boot the Slackware Operating System.

• Remove the USB thumb drive containing the Slackware Installer
• Power on the HoneyComb.

When you are prompted, press the Escape key (you may need to press it a couple of times):

Use the cursor keys to scroll down to Boot Maintenance Manager

Press Enter on Boot Options

Press Enter on Change Boot Order

Press Enter to bring up the selection menu.

Use the cursor keys within the menu to locate the block storage device on which you installed Slackware. In this example it's a Kingston SSD:

• Use the '-' or '+' keys to change the position of your selected storage device so that it appears at the top of the menu.
• Press Enter to confirm its position in the menu

Ensure that your selected block storage device is at the top of the menu. If not, press Enter again

Press F10 to bring up the 'Save Settings' dialog, and press Y to confirm.

Return to the main menu. You'll need to press ESC a few times (note: the menu has a second or more latency before it responds)

Finally, use the cursor keys to select 'Reset' and press Enter.

This time do not interrupt the boot process by pressing the ESC key. You will be presented with a GRUB menu very similar to the menu offered by the Slackware AArch64 installer image.

The system will now boot into the OS.

There are a few post-installation configuration tasks to complete.

You should add a plebeian (non-root) user using the adduser tool.

This is documented here.

If you want to configure NTP, see set time from an NTP Server.

One of the preferred tools to keep your system up to date is slackpkg.

Often Kernel modules for discovered hardware will be automatically loaded, but occasionally you will need to manually configure the loading of some modules.

/etc/rc.d/rc.modules.local

This file is a shell script that is run as one of the last steps before the OS has fully booted. You can enter modprobe commands here to load the specific modules you require.

Configuration files within the directory /lib/modprobe.d/ can be used to configure the parameters of the modules. Existing files within that directory serve as reference examples should you need them.

There are a number of peripherals that may require Kernel modules loading early on in the boot sequence. An example of this would be RTCs (Real Time Clocks) or storage controllers that are required to access the file systems on which the OS lives.

To load Kernel modules during the early boot sequence, read:

/boot/local/README.txt

As root, the easiest way to begin is by renaming the example script:

mv /boot/local/load_kernel_modules.post.sample /boot/local/load_kernel_modules.post

Then add the appropriate module loading commands to: /boot/local/load_kernel_modules.post You can also add shell code here to initialise a peripheral - writing something to the peripheral's Kernel interface, for example.

If you prefer to use a graphical login manager, you can configure the default runlevel as 4:

su - 
sed -i 's?id:3:?id:4:?g' /etc/inittab
reboot

If you'd like to customise the Linux Kernel, the easiest way is to follow the HOWTO guide and use the Slackware AArch64 Kernel build script to create new packages.

Slackware AArch64 ships with a generic OS InitRD (Operating System Initial RAM Disk - the environment that prepares the machine to boot the Operating System Proper), so as to support a wide range of Hardware Models.

However, this isn't the optimal setup once the Slackware OS has been installed because the generic OS InitRD typically exceeds 40MB, which in some cases can add a couple of seconds to the boot time whilst it's loaded from the SD card.

The os-initrd-mgr (Operating System Initial RAM Disk Manager) tool has an option to synchronize the OS InitRD's Kernel modules with only those presently loaded within the Operating System.

To do this:

$ su -c 'os-initrd-mgr --sync-loaded-kmods' -  # note the final -

This option isn't the default, but you can make it so by following the instructions within /etc/os-initrd-mgr.conf.sample

This way when you upgrade the Kernel packages in the order described above, it'll automatically synchronize the modules.

Slackware comes with a good base of software applications, but there are plenty more available in the Open Source Ecosystem.

The best way to add new software is to use the build scripts from SlackBuilds.org.

During the Slackware installation process, you flash the firmware to the SPI flash. Occasionally, updates will be made available to the firmware to address bug fixes and provide improvements.

Slackware provides a package hwm-bw-lx2160acex7 within the a series that contains the latest boot firmware and contains the bootloader-flash-lx2160acex7 tool to manage the upgrade life cycle.

1. Upgrade to the latest available version of the package hwm-bw-lx2160acex7 (using slackpkg as described within this document).
2. As root, run the bootloader-flash-lx2160acex7 tool.

In this example we'll run the Boot Loader management tool as the root user using the su tool:

$ su -c 'bootloader-flash-lx2160acex7' -  # You must include the trailing '-' character

The flashing tool will indicate whether a new version of the firmware is available, and will offer to flash it. The process is the same as described earlier within this installation guide.

After installing Slackware using this guide, you can write the Slackware installer to an SD card instead of a USB stick and boot from it. This approach is more convenient than using a USB thumb drive, as it requires no physical adjustments. The SD card can remain permanently seated in the HoneyComb LX2, allowing the entire process to be performed remotely without power cycling or physically interacting with the hardware.

This is possible because the firmware has already been installed in the SPI flash.

There is no need to change the DIP switch settings or even power off the HoneyComb in order to perform a reinstallation.

As root, write the appropriate Slackware Installer to the SD card:

$ IMG=honeycomb_lx2160acex7-aio-slackwareaarch64-current.img.xz # replace with appropriate Installer image version
$ xzcat $IMG | dd of=/dev/mmcblk0 bs=8M iflag=fullblock status=progress
$ sync
$ reboot

Press ESC to enter the firmware menu:

Select Boot Manager

Choose the appropriate boot option from the menu. Ensure that the selected device is identified as SD at the top right of the screen.

Boot the Slackware Installer:

Once the installation is complete, you can reboot the HoneyComb from the installer (there is no need to power off the HoneyComb, as is required in the initial installation).

• Slackware ARM Support Forum
• Slackware ARM/Aarch64 Disk Encryption
• Zram in Slackware ARM and ARM64 Architectures

NVMe Suggestions

• Recommendations for supported NVMe M.2 storage are welcome.

More details on the development Road Map here.

• SolidRun Honeycomb LX2K Quick Start Guide
• SolidRun Honeycomb Product Page
• SolidRun Developer Center
• UEFI firmware source code on GitHub
• Guide for beginners. (references other distributions)