On ARM-based systems in most cases one of two formats for boot images is used: a) standard Linux zImage-format kernels (“vmlinuz”) in conjunction with standard Linux initial ramdisks (“initrd.gz”) or b) uImage-format kernels (“uImage”) in conjunction with corresponding initial ramdisks (“uInitrd”).

uImage/uInitrd are image formats designed for the U-Boot firmware that is used on many ARM-based systems (mostly 32-bit ones). Older U-Boot versions can only boot files in uImage/uInitrd format, so these are often used on older armel systems. Newer U-Boot versions can - besides booting uImages/uInitrds - also boot standard Linux kernels and ramdisk images, but the command syntax to do that is slightly different from that for booting uImages.

For systems using a multiplatform kernel, besides kernel and initial ramdisk a so-called device-tree file (or device-tree blob, “dtb”) is needed. It is specific to each supported system and contains a description of the particular hardware. The dtb should be supplied on the device by the firmware, but in practice a newer one often needs to be loaded.

The netboot tarball (Section 5.1.3.2, “Pre-built netboot tarball”), and the installer SD-card images (Section 5.1.5, “Using pre-built SD-card images with the installer”) use the (platform-specific) default console that is defined by U-Boot in the “console” variable. In most cases that is a serial console, so on those platforms you by default need a serial console cable to use the installer.

On platforms which also support a video console, you can modify the U-Boot “console” variable accordingly if you would like the installer to start on the video console.

Booting from the network requires that you have a network connection and a TFTP network boot server (and probably also a DHCP, RARP, or BOOTP server for automatic network configuration).

The server-side setup to support network booting is described in Section 4.3, “Preparing Files for TFTP Net Booting”.

setenv autoload no
dhcp

setenv ipaddr <ip address of the client>
setenv netmask <netmask>
setenv serverip <ip address of the tftp server>
setenv dnsip <ip address of the nameserver>
setenv gatewayip <ip address of the default gateway>

saveenv

printenv kernel_addr_r ramdisk_addr_r fdt_addr_r

setenv kernel_addr_r 0x46000000
setenv fdt_addr_r 0x47000000
setenv ramdisk_addr_r 0x48000000

tftpboot ${kernel_addr_r} <filename of the kernel image>
tftpboot ${fdt_addr_r} <filename of the dtb>
tftpboot ${ramdisk_addr_r} <filename of the initial ramdisk image>

setenv bootargs console=ttyS0,115200 rootwait panic=10

bootm ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}

bootz ${kernel_addr_r} ${ramdisk_addr_r}:${filesize} ${fdt_addr_r}

run bootcmd_dhcp

setenv autoload no
dhcp
tftpboot ${scriptaddr} /debian-installer/armhf/tftpboot.scr
source ${scriptaddr}

Many modern U-Boot versions have USB support and allow booting from USB mass storage devices such as USB sticks. Unfortunately the exact steps required to do that can vary quite a bit from device to device.

U-Boot v2014.10 has introduced a common commandline handling and autoboot framework. This allows building generic boot images that work on any system implementing this framework. The debian-installer supports installation from a USB stick on such systems, but unfortunately not all platforms have adopted this new framework yet.

To build a bootable USB stick for installing Debian, unpack the hd-media tarball (see Section 4.2.1, “Where to Find Installation Images”) onto a USB stick formatted with a filesystem supported by the U-Boot version on your device. For modern U-Boot versions, any of FAT16 / FAT32 / ext2 / ext3 / ext4 usually works. Then copy the ISO image file of the first Debian installation CD or DVD onto the stick.

The autoboot framework in modern U-Boot versions works similar to the boot ordering options in a PC BIOS, i.e. it checks a list of possible boot devices for a valid boot image and starts the first one it finds. If there is no operating system installed, plugging in the USB stick and powering up the system should result in starting the installer. You can also initiate the USB-boot process any time from the U-Boot prompt by entering the “run bootcmd_usb0” command.

One problem that can come up when booting from a USB stick while using a serial console can be a console baudrate mismatch. If a console variable is defined in U-Boot, the debian-installer boot script automatically passes it to the kernel to set the primary console device and, if applicable, the console baudrate. Unfortunately the handling of the console variable varies from platform to platform - on some platforms, the console variable includes the baudrate (as in “console=ttyS0,115200”), while on other platforms the console variable contains only the device (as in “console=ttyS0”). The latter case leads to a garbled console output when the default baudrate differs between U-Boot and the kernel. Modern U-Boot versions often use 115200 baud while the kernel still defaults to the traditional 9600 baud. If this happens, you should manually set the console variable to contain the correct baudrate for your system and then start the installer with the “run bootcmd_usb0” command.

For a number of systems, Debian provides SD card images that contain both U-Boot and the debian-installer. These images are provided in two variants - one for downloading the software packages over the network (available at .../images/netboot/SD-card-images/ ) and one for offline installations using a Debian CD/DVD (available at .../images/hd-media/SD-card-images/ ). To save space and network bandwidth, the images consist of two parts - a system-dependent part named “firmware.<system-type>.img.gz”, and a system-independent part named “partition.img.gz”.

To create a complete image from the two parts on Linux systems, you can use zcat as follows:

zcat firmware.<system-type>.img.gz partition.img.gz > complete_image.img

On Windows systems, you have to first decompress the two parts separately, which can be done e.g. by using 7-Zip, and then concatenate the decompressed parts together by running the command

copy /b firmware.<system-type>.img + partition.img complete_image.img

in a Windows CMD.exe window.

Write the resulting image onto an SD card, e.g. by running the following command on a Linux system:

cat complete_image.img > /dev/SD_CARD_DEVICE

After plugging the SD card into the target system and powering the system up, the installer is loaded from the SD card. If you use the hd-media variant for offline installations, you must provide the installer with access to the first Debian CD/DVD on a separate medium, which can e.g. be a CD/DVD ISO image on a USB stick.

When you come to the partitioning step in the installer (see Section 6.3.4, “Partitioning and Mount Point Selection”), you can delete or replace any previous partitions on the card. Once the installer is started, it runs completely in the system's main memory and does not need to access the SD card anymore, so you can use the full card for installing Debian. The easiest way to create a proper partition layout on the SD card is to let the installer automatically create one for you (see Section 6.3.4.2, “Guided Partitioning”).