Virtual Embedded Linux Board Part 2

Explore the ARM architecture and its prevalence in embedded systems, from smartphones and routers to servers, highlighting ARM's licensing model and energy-efficient, high-performance design.

Explore reduced instruction set computer concepts with a simple instruction set and simple addressing modes. Learn load-store architecture and how memory moves to registers and back, with ARM endian options.

Explore the Arm architecture as a contract between hardware and software, detailing the instruction set, registers, memory and exception models, and debugging and tracing tools from Arm v1 to v9.

Understand how microarchitecture implements an ARM architecture by detailing pipeline length, cache levels, cycle counts, and optional features, with Verilog or VHDL IP cores.

This lecture explains how the same architecture can be implemented differently by microarchitecture, with varying pipelines, caches, and MMUs, exemplified by arm7tdmi-s, arm920t, and cortex a53 and cortex a72.

Cortex-A53 and Cortex-A72 implement Armv8-a, prioritize power efficiency and performance; A53 uses eight-stage in-order pipeline with cache ranges 8 to 64 kb, while A72 uses out-of-order with fixed 48 kb.

ARM generates revenue by licensing its architecture and processor cores as intellectual property to customers, who may implement their own microarchitecture or use ARM’s cores directly.

System on chip, or SoC, combines an ARM CPU core with memory and peripherals. This single chip includes controllers like interrupt, timer, UART, USB, enabling a complete computer system.

SoC vendors license Arm cores and integrate memory controllers, usb, spi, i2c, uart, gpio, gpu, and other peripherals to form a chip like am335x on Beaglebone.

Describe how a single board computer combines a system-on-chip with RAM and peripherals such as USB, Ethernet, HDMI, Wi-Fi, and GPIO, using BCM2837 Cortex-A53 as in Raspberry Pi.

Map four layers of SBCs—from arm architecture and cores to SoCs and SBCs—across Raspberry Pi models and BeagleBone Black, highlighting Armv6, Armv7-a, Armv8-a architectures and Cortex-A cores.

Understand ARM documentation types, including architecture reference manual, technical reference manual, and SoC configuration and integration manual, plus SoC datasheets and IP licensing for SIM access.

Assess linux kernel support for the arm core (cortex-a7/a9), verify SoC compatibility from the vendor, and confirm device drivers for peripherals like gpu, camera, display, usb, uart, and spi.

Explore the Linux kernel boot folder, which holds architecture dependent ARM code and the compressed kernel with dtbs. See how the start function initiates decompression and boot.

Explore the Linux kernel folder structure for embedded boards, including arch/ subfolders, common and configs, and examine irq handling, vector tables, entry.S, setup.c, and time init.

Explore the Linux kernel ARM directory, focusing on lib's ARM-optimized functions like delay and backtrace, and the division between architecture dependent and independent code and SoC machine folders.

Explore the proc cpuinfo file to see how ARM architecture, core, and features are exposed, and how implementer, part number, and main ID register identify the CPU.

Learn how to use lscpu to extract detailed cpu information, including armv7 architecture and Cortex-A9 model. Build util linux and enable only lscpu for embedded boards.

Build the lsirq utility from the cis utils in the util-linux package by enabling rls irq in the makefile and compiling lsirq.c to access and sort /proc/interrupts with strace.

Build and run Lstm with the makefile to display 128 MB memory blocks and 16 GB online memory, using lsmem outputs and noting missing system memory and offline CPUs.

Explore embedded linux board tooling and fsck usage to check and repair linux file systems, including disk utilities and build dependencies like lib mount.

Disable audio messages by setting the environment variable chemo audio driver none, removing alsa related noise; after applying, audio messages disappear and only the SD card image format messages remain.

Fix the sdcard warning by using the drive option with sdcard.img, raw format, and sd interface; test other interfaces and confirm the machine supports only the sd interface.

Learn about ARM versatile express boards, including versatile AB with expansion boards one and two, ARM926ej-s core, ARMv5t architecture, and cross compilation for legacy development.

Learn to compile the Linux kernel for the versatilepb board using an out-of-tree build, set up the toolchain, and boot the kernel in QEMU.

Explore booting versatile pb and versatile ab boards with a single kernel when ARM cores match, and see how expansion boards and dtp enable peripherals.

Booting the vexpress-a9 kernel fails without a root filesystem and proper boot arguments, causing kernel panic. The code compiled for ARMv7 mismatches the board’s ARMv5 CPU, requiring an ARMv5 cross-compiler.

Build a cross toolchain for armv5 using crosstool-ng, selecting unknown cortex configurations and uclibc, export the toolchain path, and prep for an arm unknown linux target.

Learn cross compiling with the new toolchain to build an init mfs for armv5, generate a cpio image, and verify a hello world for the correct architecture.

Explain why running x86_64 initramfs on an arm board fails due to architecture differences in instruction sets and register layouts, producing a no exec format error.

Learn to view initramfs or initrd contents using two commands: a basic filename listing and a detailed listing showing permissions, user, group, and size, including kernel modules and binaries inside.

Build a BusyBox-based initrd/initramfs for an ARM unknown toolchain, configure static rootfs, install networking utilities, disable IPv6, and boot a BusyBox shell.

Format a rootfs image as versatile ext4, mount it, and copy files to create a bootable rootfs. Enable scsi and pci versatile in the kernel and build for scsi boot.

Enable the required kernel configs, including ext4 filesystem support, then rebuild with multiple CPUs and verify the root device options to fix root mounting failures.

Enable BLK_DEV_SD kernel config and verify block devices and rootfs on versatile boards, then correct dtb and board selection to boot kernel to rootfs.

Copy the rootfs to the sd card on the versatile pcb, mount partitions with a loop device, and adjust fstab, banner, and init scripts to mirror the vexpress-a9 setup.

Explore emulating Raspberry Pi 3 with qemu, detailing armv8-a based Cortex-A53, Broadcom BCM2837 SoC, GPU boot sequence from bootcode.bin to kernel8.img, and the Raspberry Pi OS Lite CLI.

Download the Raspberry Pi Raspbian OS from the official site, choose the lite image for CLI use, and mount the image to extract the kernel and rootfs.

Learn how to build qemu from source, including prerequisites, configuring with gcc and sleep, compiling, exporting the path, and enabling Raspberry Pi 3 B support for arm64 emulation.

Add rootfs support to the virtual embedded Linux board by resizing the SD card to four GB and configuring root on the MMC partition for a Raspberry Pi Lite image.

Enable USB keyboard and USB mouse passthrough in QEMU on a virtual embedded Linux board, mapping the host's first USB devices to the guest, with a grab input workaround (ctrl+g).

Create and hash a pi user password with OpenSSL, mount the boot partition, and write the username and hashed password to the user conf file for automatic login.

Enable ssh on the virtual embedded linux board by creating an empty file in the boot partition, then configure host port forwarding from 42222 to 22 to access ssh.

Build your own linux kernel for raspberry pi and load it in the environment. Clone raspberry pi linux, create a 64-bit cross toolchain, and configure bcm2711 for kernel boot.

Enable UART on Raspberry Pi 3 by disabling Bluetooth and applying a DTB overlay to enable serial console logs, using a combined DTB with boot overlays.