MO 62A SDK

MO 62A single-board computer SDK, powered by the TI AM62A7 platform, offering up to 2 TOPS AI performance.

Table of Contents

• 1. Overview

• 2. Environment Setup

  • 2.1 Host System Requirements

  • 2.2 Clone This Repository

  • 2.3 Initialize the Environment with setup.sh

  • 2.4 Toolchain

• 3. U-Boot

  • 3.1 Related Files

  • 3.2 Build U-Boot

  • 3.3 Stage Build Artifacts

  • 3.4 Build Output

• 4. Linux Kernel

  • 4.1 Related Files

  • 4.2 Build DTBs

  • 4.3 Build Kernel

  • 4.4 Stage Build Artifacts

  • 4.5 Build Output

• 5. Flashing the SD Card

  • 5.1 Prerequisites

  • 5.2 Launch the Flash Tool

  • 5.3 Online Flashing (Write Directly to SD Card)

  • 5.4 Offline Image Creation (balenaEtcher)

• 6. Partition Layout

  • 6.1 BOOT Partition Contents

  • 6.2 Boot Configuration

• 7. Hardware Reference

  • 7.1 Block Diagram Overview

  • 7.2 Power System

  • 7.3 I2C Device Map

  • 7.4 Memory

  • 7.5 Storage

  • 7.6 Display — Micro HDMI

  • 7.7 Networking — Gigabit Ethernet

  • 7.8 USB

  • 7.9 Wireless — Wi-Fi / Bluetooth

  • 7.10 Audio

  • 7.11 RTC

  • 7.12 Expansion Interfaces

  • 7.13 Debug Interface

  • 7.14 Boot Configuration

  • 7.15 JTAG Interface

  • 7.16 Hardware Revision Straps

1. Overview

MO-62A is a single-board computer based on the TI AM62A7 processor, designed for edge AI inference, machine vision, and industrial control applications. The AM62A7 integrates a quad-core Arm Cortex-A53 (up to 1.4 GHz), a single Cortex-R5F real-time processor, and a dedicated MMA (Matrix Multiplication Accelerator), delivering up to 2 TOPS of AI inference performance.

This SDK is built on top of TI Processor SDK Linux RT EdgeAI AM62A EVM 11.01.07.05 and provides full hardware customization support for the MO-62A board. It includes the following components:

• U-Boot: Bootloader customized for MO-62A, including R5 SPL and A53 U-Boot

• Linux Kernel: Kernel and device trees customized for MO-62A, based on TI Linux RT kernel

• Build System: Unified Makefile-based build and staging workflow

• Flash Tool: Supports direct SD card writing and offline balenaEtcher image creation

SDK directory structure overview:

mo-62a/
├── board-support/          # U-Boot, Kernel sources and prebuilt images
│   ├── built-images/       # Staged build artifacts (generated after staging)
│   ├── prebuilt-images/    # TI prebuilt firmware (bl31, bl32, ti-dm, etc.)
│   └── extra-applications/ # Board-specific extra applications
├── bin/                    # Helper scripts and flash tool
│   ├── mo-62a-flash.sh     # Unified flash tool
│   └── extlinux/           # U-Boot extlinux boot configuration
├── filesystem/             # rootfs tarball directory
├── linux-devkit/           # AArch64 cross-compilation toolchain
├── k3r5-devkit/            # ARMv7 R5 cross-compilation toolchain
├── makerules/              # Per-component Makefile rules
├── Makefile                # Top-level Makefile
├── Rules.make              # Global path and platform configuration
└── setup.sh                # Development host initialization script

2. Environment Setup

2.1 Host System Requirements

The following host environment has been verified for building this SDK:

Required host packages:

sudo apt-get install \
  xinetd tftpd nfs-kernel-server minicom \
  build-essential libncurses5-dev autoconf automake \
  dos2unix screen lrzsz lzop flex libssl-dev \
  u-boot-tools make git parted dosfstools e2fsprogs \
  pv xz-utils zip wget curl

2.2 Clone This Repository

Clone the MO-62A SDK to any directory on your host machine:

git clone https://github.com/inhandnet/mo-62a.git
cd mo-62a

2.3 Initialize the Environment with setup.sh

Run setup.sh from the SDK root to initialize the development host:

./setup.sh

The script performs the following steps:

1. Verifies the host OS (Ubuntu 22.04 LTS)

2. Adds the current user to the dialout group (required for serial port access)

3. Installs required host packages — press Y to install, n to skip if already installed

4. Writes TI_SDK_PATH to ~/.bashrc pointing to the cloned repository root, so the variable persists across terminal sessions

5. Creates a symlink at /opt/ti-processor-sdk-linux-rt-edgeai-am62a-evm-11.01.07.05 pointing to the cloned repository, required because the cross-compilation toolchain binaries have a hardcoded ELF interpreter path at that location

Example output:

-------------------------------------------------------------------------------
MO-62A SDK setup script
SDK root: /home/user/mo-62a
-------------------------------------------------------------------------------

Verifying Linux host distribution
Ubuntu 22.04 LTS is being used, continuing..

User 'user' is already in the 'dialout' group.

Do you wish to install required host packages? (Y/n) n
Host package installation skipped.

TI_SDK_PATH is already set correctly in /home/user/.bashrc:
  export TI_SDK_PATH="/home/user/mo-62a"
TI_SDK_PATH is now set to: /home/user/mo-62a

Creating toolchain symlink...
  /opt/ti-processor-sdk-linux-rt-edgeai-am62a-evm-11.01.07.05 -> /home/user/mo-62a

-------------------------------------------------------------------------------
MO-62A SDK setup completed!
You can now build the SDK from: /home/user/mo-62a
-------------------------------------------------------------------------------

Note: After setup.sh completes, TI_SDK_PATH is active in the current shell and will be automatically set in all future terminal sessions via ~/.bashrc. Running setup.sh again is safe — it will update the symlink and the TI_SDK_PATH entry without creating duplicates.

2.4 Toolchain

Two cross-compilation toolchains are included in the SDK:

AArch64 toolchain — used for Linux kernel and A53 U-Boot:

ARMv7 R5 toolchain — used for R5 SPL (tiboot3):

To verify both toolchains are available (run after setup.sh has completed):

# AArch64
linux-devkit/sysroots/x86_64-arago-linux/usr/bin/aarch64-oe-linux/aarch64-oe-linux-gcc --version

# ARMv7 R5
k3r5-devkit/sysroots/x86_64-arago-linux/usr/bin/arm-oe-eabi/arm-oe-eabi-gcc --version

Expected output:

aarch64-oe-linux-gcc (GCC) 13.4.0
Copyright (C) 2023 Free Software Foundation, Inc.

arm-oe-eabi-gcc (GCC) 13.4.0
Copyright (C) 2023 Free Software Foundation, Inc.

Note: The toolchain binaries have a hardcoded ELF interpreter path pointing to /opt/ti-processor-sdk-linux-rt-edgeai-am62a-evm-11.01.07.05/. The symlink created by setup.sh satisfies this requirement regardless of where the repository is cloned. The toolchains are invoked automatically via Rules.make and do not require manual PATH export.

3. U-Boot

3.1 Related Files

MO-62A specific files added to the U-Boot source tree:

Prebuilt firmware required during the build (from TI, not modified):

3.2 Build U-Boot

U-Boot is built in two separate passes — R5 SPL first, then A53 U-Boot. Both are invoked via the top-level make from the SDK root.

Build R5 SPL (tiboot3):

make u-boot-r5

This configures the R5 build with am62ax_mo_62a_r5_defconfig and compiles using the ARMv7 R5 toolchain (arm-oe-eabi-). The output is placed in board-support/u-boot-build/r5/.

Build A53 U-Boot:

make u-boot-a53

This configures the A53 build with am62ax_mo_62a_a53_defconfig and compiles using the AArch64 toolchain (aarch64-oe-linux-), incorporating bl31.bin, bl32.bin, and the TI Device Manager firmware via binman. The output is placed in board-support/u-boot-build/a53/.

Build both in one step:

make u-boot

3.3 Stage Build Artifacts

After a successful build, copy the output binaries to board-support/built-images/:

make u-boot_stage

3.4 Build Output

After staging, the following files are available in board-support/built-images/:

Note: The appropriate tiboot3-*.bin variant depends on the device security state. Most production MO-62A boards ship as HS-FS, which uses tiboot3-am62ax-hs-fs-mo-62a.bin. The flash tool uses tiboot3.bin (a copy of the HS-FS variant) by default.

4. Linux Kernel

4.1 Related Files

MO-62A specific files added to the Linux kernel source tree:

The following kernel config fragments are applied on top of the defconfig during the build:

4.2 Build DTBs

Build all device tree blobs (62 DTBs and DTBOs in total):

make linux-dtbs

This configures the kernel with am62ax_mo_62a_defconfig + ti_arm64_prune.config + ti_rt.config, then builds all DTBs matching the prefix patterns defined in Rules.make:

ti/k3-am62a7  ti/k3-fpdlink  ti/k3-am62x-sk  ti/k3-v3link

Output is placed in board-support/ti-linux-kernel-6.12.35+git-ti-rt/arch/arm64/boot/dts/.

4.3 Build Kernel

Build the kernel image, modules, and FitImage:

make linux

This performs the following steps in order:

1. Builds DTBs (calls linux-dtbs automatically)

2. Builds U-Boot (calls u-boot automatically, required for FitImage signing key)

3. Compiles Image and Image.gz

4. Compiles kernel modules

5. Packages a signed fitImage using mkimage with the U-Boot signing key and the ITS template from board-support/prebuilt-images/am62a-evm/

6. Rebuilds U-Boot A53 (binman) to embed the MO-62A DTB into tispl.bin

4.4 Stage Build Artifacts

Copy kernel and DTB outputs to board-support/built-images/:

make linux_stage

4.5 Build Output

After staging, the following files are added to board-support/built-images/:

Note: fitImage is signed with the custMpk key from the U-Boot source tree. The signing step also triggers a rebuild of tispl.bin so it embeds the MO-62A DTB (k3-am62a7-mo-62a.dtb) in the A53 SPL. This means make linux will always update both fitImage and tispl.bin in built-images/.

5. Flashing the SD Card

The unified flash tool bin/mo-62a-flash.sh supports two output targets:

• Online flashing — write directly to a physical SD card

• Offline image creation — create a .img file for use with balenaEtcher

Both modes create identical partition layouts and content.

5.1 Prerequisites

Required host packages (installed by setup.sh):

parted  dosfstools  e2fsprogs  pv  xz-utils  zip  wget  curl

Ensure the following are ready before running the flash tool:

1. Built images staged — run make u-boot_stage and make linux_stage (or make all_stage) so that board-support/built-images/ contains the required files

2. Rootfs tarball present — place a .tar.xz or .tar.gz rootfs tarball under filesystem/

3. SD card inserted (online mode only) — the tool automatically detects /dev/sdX and /dev/mmcblkN block devices

5.2 Launch the Flash Tool

The flash tool is interactive and must be run as root:

sudo bash bin/mo-62a-flash.sh

On launch, it prompts you to choose the output target:

=== MO-62A Flash Tool ===

Select output target:
  [1] Write directly to an SD card
  [2] Create offline image for balenaEtcher

Select target [1/2]:

5.3 Online Flashing (Write Directly to SD Card)

Select [1] for online mode. The tool will enumerate all detected block devices:

Detected candidate block devices:
  [1] /dev/sda  29.7G  SD Card Reader

Select target device number:

Then choose the operation mode:

Select operation mode:
  [1] full      - create partitions + format + copy BOOT + extract rootfs
  [2] partition - create partitions + format only
  [3] boot      - copy BOOT content only (strict checks, no repartition)
  [4] rootfs    - copy rootfs content only (strict checks, no repartition)

Select mode number (default 1):

For a fresh SD card, select full. The tool will ask for confirmation (Type YES to continue), then proceed automatically:

1. Unmounts any existing partitions on the selected device

2. Wipes the old partition table

3. Creates MBR partition table: BOOT (FAT32, 256 MiB) + rootfs (ext4, remaining space)

4. Formats both partitions

5. Copies boot artifacts to the BOOT partition: tiboot3.bin, tispl.bin, u-boot.img, Image, DTBs, extlinux/

6. Asks which rootfs tarball to use (if multiple are present under filesystem/)

7. Extracts the rootfs tarball to the rootfs partition

8. Installs kernel modules (make modules_install) into the rootfs

9. Builds and installs any external applications from board-support/extra-applications/

Example session (full mode):

TARGET DEVICE: /dev/sda (29.7G)

MODE: full
This will ERASE ALL DATA on /dev/sda.

Destructive operation — please confirm.
Type YES to continue: YES

Checking mounts on /dev/sda ...
Wiping old partition table signatures...
Creating MBR partitions (BOOT FAT32(LBA) 256MiB + rootfs ext4 remaining)...
Formatting BOOT: /dev/sda1 (FAT32)
Formatting rootfs: /dev/sda2 (ext4)
Copying boot artifacts to BOOT partition...

Available rootfs tarballs:
  [1] debian-13.2-xfce-v6.12-arm64-2026-01-13-12gb.tar.xz

Select rootfs tarball number (or 'q' to abort): 1

Extracting rootfs to rootfs partition...
Installing kernel modules into rootfs: /tmp/mo-62a-rootfs.xxx/usr/lib/modules
...
Installed: rtk_hciattach

Done. BOOT and rootfs written successfully.

After flashing, insert the SD card into the MO-62A board and power on. Boot messages appear on the serial console at ttyS2 (115200 8N1).

5.4 Offline Image Creation (balenaEtcher)

Select [2] for image mode. The tool prompts for image parameters:

Available rootfs tarballs:
  [1] debian-13.2-xfce-v6.12-arm64-2026-01-13-12gb.tar.xz

Select rootfs tarball number (or 'q' to abort): 1

Output directory (default: bin/out): /path/to/output
Output image base name (default: mo-62a): mo-62a
Image size (GiB, integer) (default: 8): 8
Compression (zip|xz|none) (default: zip): zip

The tool creates a sparse .img file, partitions and formats it via a loopback device, fills it with the same content as online mode, detaches the loop device, then compresses the result.

Output files:

/path/to/output/
├── mo-62a.img         # Raw disk image (8 GiB sparse file)
├── mo-62a.img.zip     # Compressed image for balenaEtcher (if compression=zip)
└── mo-62a.sha256      # SHA-256 checksums of all image files

To flash the image with balenaEtcher:

1. Open balenaEtcher

2. Click Flash from file and select mo-62a.img.zip (balenaEtcher accepts compressed images directly)

3. Select the target SD card

4. Click Flash

Note: Image size must be at least as large as the expanded rootfs. The default 8 GiB is sufficient for the provided Debian rootfs (~6.9 GiB extracted). When using a custom rootfs, adjust the size accordingly.

5.5 Customising the Rootfs Tarball (Adding apt Packages)

The flash tool extracts the rootfs tarball as-is. Additional Debian packages (e.g. frei0r-plugins required by imx219-preview.sh) must be pre-installed into the tarball before flashing so that they are available both after online and offline flashing without requiring network access on the target.

The standard workflow is:

1. Install prerequisites on the host (one-time, x86-64 Ubuntu/Debian):

   sudo apt-get install -y qemu-user-static binfmt-support
   # Registers the arm64 binfmt handler so chroot can run aarch64 binaries directly.
   sudo systemctl restart systemd-binfmt || sudo update-binfmts --enable

2. Extract the tarball into a temporary directory:

   ROOTFS_DIR=/tmp/mo-62a-rootfs
   mkdir -p "$ROOTFS_DIR"
   sudo tar -xpf filesystem/debian-13.2-xfce-v6.12-arm64-2026-01-13-12gb.tar.xz \
       -C "$ROOTFS_DIR"

   The -p flag preserves file permissions and ownership. Use sudo so that device nodes and suid bits are restored correctly.

3. Copy the qemu binary into the extracted rootfs:

   sudo cp /usr/bin/qemu-aarch64-static "$ROOTFS_DIR/usr/bin/"

4. Bind-mount pseudo-filesystems and enter the chroot:

   sudo mount --bind /proc    "$ROOTFS_DIR/proc"
   sudo mount --bind /sys     "$ROOTFS_DIR/sys"
   sudo mount --bind /dev     "$ROOTFS_DIR/dev"
   sudo mount --bind /dev/pts "$ROOTFS_DIR/dev/pts"
   
   sudo chroot "$ROOTFS_DIR" /bin/bash

5. Inside the chroot, install the required packages:

   # (inside chroot)
   apt-get update
   apt-get install -y frei0r-plugins
   apt-get clean          # remove downloaded .deb files to reduce tarball size
   exit

6. Clean up bind mounts and the qemu binary:

   sudo umount "$ROOTFS_DIR/dev/pts"
   sudo umount "$ROOTFS_DIR/dev"
   sudo umount "$ROOTFS_DIR/sys"
   sudo umount "$ROOTFS_DIR/proc"
   sudo rm -f  "$ROOTFS_DIR/usr/bin/qemu-aarch64-static"

7. Repack the tarball (replace the original file):

   TARBALL=filesystem/debian-13.2-xfce-v6.12-arm64-2026-01-13-12gb.tar.xz
   sudo tar -cpJf "$TARBALL" -C "$ROOTFS_DIR" .
   sudo rm -rf "$ROOTFS_DIR"

   Re-packing a ~7 GiB rootfs with xz compression takes several minutes. Use tar -cpzf (.tar.gz) for a faster but larger archive if turnaround time matters during development.

After repacking, re-run the flash tool as normal. The newly installed packages will be present on the target immediately after flashing, with no network access required.

Packages currently pre-installed via this workflow:

System configuration changes applied inside the chroot:

These changes are made directly to config files (no apt required) and must be applied after step 5 (inside the chroot) or by editing files directly in $ROOTFS_DIR after exiting the chroot.

1. Disable DPMS and screen blanking — prevents the display from going dark and becoming unresponsive:

   mkdir -p /etc/X11/xorg.conf.d
   cat > /etc/X11/xorg.conf.d/10-no-dpms.conf << 'EOF'
   Section "ServerFlags"
       Option "BlankTime"   "0"
       Option "StandbyTime" "0"
       Option "SuspendTime" "0"
       Option "OffTime"     "0"
   EndSection
   
   Section "Monitor"
       Identifier "Monitor0"
       Option     "DPMS"    "false"
   EndSection
   EOF

2. Pass -s 0 -dpms to the X server via lightdm — disables the X server's built-in screen saver and DPMS at the server level:

   sed -i 's|^# xserver-command=X$|xserver-command=X -s 0 -dpms|' \
       /etc/lightdm/lightdm.conf

6. Partition Layout

Both online flashing and offline image creation produce identical partition layouts:

Partition table type: MBR (Master Boot Record)

BOOT Partition Contents

After flashing, the BOOT partition contains:

BOOT/
├── tiboot3.bin          # R5 SPL (first-stage bootloader)
├── tispl.bin            # TI SPL (OP-TEE + TF-A + A53 U-Boot)
├── u-boot.img           # A53 U-Boot FIT image
├── Image                # Linux kernel image
├── ti/                  # Device tree blobs directory
│   ├── k3-am62a7-mo-62a.dtb
│   └── ...              # Additional TI DTBs and DTBOs
└── extlinux/
    └── extlinux.conf    # U-Boot extlinux boot configuration

Boot Configuration

U-Boot uses the extlinux boot flow to load the kernel. The default extlinux/extlinux.conf:

menu title mo-62a MicroSD (extlinux.conf)

timeout 30
default microSD

label microSD
  append console=ttyS2,115200n8 earlycon=ns16550a,mmio32,0x02800000 root=/dev/mmcblk1p2 rw rootfstype=ext4 rootwait
  kernel /Image
  fdt    /ti/k3-am62a7-mo-62a.dtb
  # fdtoverlays /overlays/<file>.dtbo
  # initrd /initrd.img

The kernel command line sets:

• Serial console: ttyS2 at 115200 baud

• Root device: /dev/mmcblk1p2 (partition 2 on the SD/MMC device)

• Root filesystem type: ext4

To apply a device tree overlay, uncomment the fdtoverlays line and specify the .dtbo file path relative to the BOOT partition root.

7. Hardware Reference

Source: doc/Mo_62a_s_mb_v10-260203.pdf (schematic Rev V1.0, 22 sheets)

7.1 Block Diagram Overview

The MO-62A is built around the TI AM62A74 SoC. The top-level block diagram connects the following subsystems:

7.2 Power System

Input: USB Type-C, 5 V, maximum 6.38 A total.

Power rails and distribution:

Status LEDs (driven by MCU GPIO):

7.3 I2C Device Map

7.4 Memory

LPDDR4 (MT53E1G32D2FW-046)

EEPROM (BL24C02F)

7.5 Storage

eMMC

• Interface: MMC0 (8-bit, JEDC eMMC electrical standard v5.1 / JESD84-B51)

• I/O voltage: 1.8 V (VDDSHV4)

Micro SD Card

• Interface: MMC1 (4-bit, UHS-I capable with 3.3 V / 1.8 V switching)

• I/O voltage: 3.3 V (VDDSHV5) / 1.8 V switched

• Load switch with reset logic for UHS-I voltage switching

• Connector: Micro SD (MUF-MB4)

7.6 Display — Micro HDMI

RGB-to-HDMI Transmitter: SiI9022ACNU

7.7 Networking — Gigabit Ethernet](#77-networking--gigabit-ethernet)

Ethernet PHY: DP83867CSRGZR

7.8 USB

USB Hub: USB2514 (USB2514BQFN36)

USB Type-C (J31)

• USB 2.0 only (USB0)

• Powers the board (VIN-5V)

• ESD protection: TVS05000RV

7.9 Wireless — Wi-Fi / Bluetooth

Module: FG6221ASRC-0L (6221A-SRC)

7.10 Audio

Audio Codec: TLV320AIC3106IRGZ

7.11 RTC

RTC IC: PCF85263ATL

7.12 Expansion Interfaces

7.12.1 40-Pin Header (J9 — USER EXPN)

The 40-pin expansion header (silk: USER EXPN) exposes the following SoC signals:

7.12.2 FPC 22-Pin CSI Camera (JP1)

7.12.3 Fan Connector (J6)

7.13 Debug Interface

Debug UART (J4 — SH1.0-3p)

UART0 is the MPU debug UART. A SN74LVC2G24DCUR provides voltage isolation.

Baud rate: 115200 8N1 (matches kernel console on ttyS2).

7.14 Boot Configuration

The MO-62A uses a fixed resistor boot mode configuration (BOOTMODE[15:0]).

Configured boot modes:

BOOTMODE register settings (as configured by resistors):

All supported boot modes (per silicon):

1. OSPI

2. MMC1 — SD Card

3. UART

4. eMMC

5. Ethernet

6. USB0 DFU

7. USB0 MS

7.15 JTAG Interface

Pull-up resistors: 4.7 kΩ to VCC_3V3_SYS.

7.16 Hardware Revision Straps

Three hardware revision pins (HW_REV0, HW_REV1, HW_REV2) are routed to the OSPI interface page (sheet 9). These PCB strap resistors (DNF by default) allow encoding the PCB revision and DDR model in hardware for software detection.