Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

Version 1 Current »

Building NXP/Embedian’s Yocto Mickledore Desktop (Ubuntu 22.04) BSP Distribution

Eric Lee

version 1.0a, 10/25/2024

Introduction


 

This document describes how Embedian builds a customized version of NXP’s i.MX8Q Max/Plus (8QM/8QP) official Yocto Mickledore Desktop (Ubuntu 22.04) BSP release for Embedian's SMARC-iMX8QM product platform. The approach is to pull from Embedian's public facing GIT repository and build that using bitbake. The reason why we use this approach is that it allows co-development. The build output is comprised of binary images, feed packages, and an SDK for SMARC-iMX8QM specific development. Once it's done, user can use Ubuntu apt-get install command to add additional packages.

 

NXP makes their i.MX series official bsp build scripts available via the following GIT repository:

 

Freescale community BSP release build script is available via the following repository: 

 

It is this repository that actually pulls in the meta-imx/meta-bsp project to perform the Linux BSP builds for NXP's i.MX8QM Plus ARM Cortext-A72 plus Cortex-A53 chips.  

Generating SSH Keys


 We recommend you use SSH keys to establish a secure connection between your computer and Embedian Gitlab server. The steps below will walk you through generating an SSH key and then adding the public key to our Gitlab account. 

Step 1. Check for SSH keys


First, we need to check for existing ssh keys on your computer. Open up Git Bash and run:

Check the directory listing to see if you have a file named either id_rsa.pub or id_dsa.pub. If you don't have either of those files go to step 2. Otherwise, you already have an existing keypair, and you can skip to step 3.

Step 2. Generate a new SSH key


To generate a new SSH key, enter the code below. We want the default settings so when asked to enter a file in which to save the key, just press enter.

Step 3. Add your SSH key to Embedian Gitlab Server


Copy the key to your clipboard.

Go to Embedian Git Server. At Profile Setting --> SSH Keys --> Add SSH Key 

Paste your public key and press "Add Key" and your are done.

Overview of the meta-embedian Yocto Layer


The supplied meta-embedian Yocto compliant layer has the following organization:

.
|-- conf
|   |-- layer.conf
|   |-- machine
|       |-- include
|       |   |-- imx8mp-emb.inc
|       |-- pitximx8mp2gdesktop.conf
|       |-- pitximx8mp4gdesktop.conf
|       |-- pitximx8mp6gdesktop.conf
|       |-- smarcimx8qm8gdesktop.conf
|       |-- smarcimx8qm4gdesktop.conf
|       |-- smarcimx8mp6gdesktop.conf
|       |-- smarcimx8mp4gdesktop.conf
|       |-- smarcimx8mp2gdesktop.conf
|       |-- smarcimx8mq4gdesktop.conf
|   |   `-- smarcimx8mq2gdesktop.conf
|-- README
|-- recipes-bsp
|   |-- u-boot
|       |-- u-boot-imx-common_2023.04.inc
|       `-- u-boot-imx_2023.04.bb
|   |-- imx-atf
|       `-- imx-atf_2.8.bbappend
|       |   |-- imx-atf
|       |   |   `-- imx8mm-atf-uart4.patch
|   |-- imx-sc-firmware
|       `-- imx-sc-firmware_%.bbappend
|       |   |-- imx-sc-firmware
|       |   |   |-- mx8qm-smarc-8g-scfw-tcm.bin
|       |   |   `-- mx8qm-smarc-4g-scfw-tcm.bin
|   |-- alsa-state
|       |   |-- alsa-state
|       |   |   `-- asound.state
|       `-- alsa-state.bbappend
|   |-- pm-utils
|       `-- pm-utils_%.bbappend
|   |-- imx-mkimage
|       `-- imx-boot_1.0.bbappend

|-- recipes-core
|   |-- busybox
|       `-- busybox_%.bbappend
|       |   |-- busybox
|       |   |   |-- ftpget.cfg
|       |   |   `-- defconfig
|   |-- base-files
|       `-- base-files_%.bbappend
|       |   |-- base-files
|       |   |   |-- issue
|       |   |   `-- issue.net
|   |-- systemd
|       `-- systemd-serialgetty.bbappend
|       |   |-- systemd-serialgetty
|       |   |   |-- disable-serialgetty.service
|       |   |   `-- disable-serialgetty.sh
|   |-- packagegroups
|       `-- packagegroup-core-tools-testapps.bbappend
|   |-- psplash
|       `-- psplash_git.bbappend
|       |   |-- files
|       |   |   |-- 0001-psplash-Change-colors-for-the-Embedian-Yocto-logo.patch
|       |   |   |-- psplash-poky.png
|       |   |   `-- psplash-bar.png
|   |-- udev
|       |   |-- files
|       |   |   |   `-- usb-power.rules  
|       `-- udev-rules-imx.bbappend

|-- recipes-kernel
|   |-- linux
|       `-- linux-imx.bb
`-- scripts
|   `-- emb_mk_yocto_sdcard


Notes on 
meta-embedian layer content

conf/machine/*

This folder contains the machine definitions for all Embedian's platform and backup repository in Embedian. These select the associated kernel, kernel config, u-boot, u-boot config, and tar.bz2 image settings.

recipes-bsp/u-boot/*

This folder contains recipes used to build DAS U-boot for all Embedian's platform.

recipes-bsp/imx-atf/*

This folder contains recipes used to enable console port for Embedian's i.MX8MP platform.

recipes-bsp/imx-sc-firmware/*

This folder contains system control firmware binary for Embedian's i.MX8QM platform.

recipes-bsp/alsa-state/*

This folder contains sgtl5000 sound chip default state for all Embedian's platform.

recipes-bsp/imx-mkimage/*

This folder contains imx-mkimage tool for Embedian's i.MX8MQ, i.MX8MM, i.MX8QM, i.MX8MP platform.

recipes-core/busybox/*

This folder remove telnetd from bysybox for all Embedian's platform.  

recipes-core/psplash/* 

This folder customized Yocto boot psplash for all Embedian's platform.

recipes-kernel/linux/*

Contains the recipes needed to build for all Embedian's platform Linux kernels.

Setting Up the Tools and Build Environment


To build the latest NXP i.MX8QM meta-bsp, you first need an Ubuntu 20.04 or 22.04 LTS installation. Since bitbake does not accept building images using root privileges, please do not login as a root user when performing the instructions in this section. 

Once you have Ubuntu 20.04 or 22.04 LTS running, install the additional required support packages using the following console command:

$ sudo apt install gawk wget git diffstat unzip texinfo gcc build-essential chrpath socat cpio python3 python3-pip python3-pexpect xz-utils debianutils iputils-ping python3-git python3-jinja2 libegl1-mesa libsdl1.2-dev python3-subunit mesa-common-dev zstd liblz4-tool file libssl-dev pv device-tree-compiler locales -y 

$ sudo locale-gen en_US.UTF-8

 

To get the BSP you need to have 'repo' installed and use it as:

Install the 'repo' utility:

$ mkdir ~/bin
$ curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo > ~/bin/repo
$ chmod a+x ~/bin/repo
$
export PATH=~/bin:$PATH
 


Download the BSP Yocto Project Environment.

$ mkdir ~/mickledore_desktop

$ cd ~/mickledore_desktop

$ repo init -u https://github.com/nxp-imx/imx-manifest -b imx-linux-mickledore -m imx-6.1.55-2.2.0_desktop.xml

$ repo sync


Download the Embedian Yocto build script and meta layer.

 

$ wget ftp://ftp.embedian.com/public/dev/minfs/mickledore/emb-imx-setup-release.sh

$ wget ftp://ftp.embedian.com/public/dev/minfs/mickledore/emb-imx-setup-desktop.sh

$ chmod 444 emb-imx-setup-desktop.sh

$ cd sources

$ git clone git@git.embedian.com:developer/meta-embedian-bsp.git meta-embedian -b mickledore-6.1.55_2.2.0_desktop

$ cd ~/mickledore_desktop

$ DISTRO=imx-desktop-xwayland MACHINE=smarcimx8qm4gdesktop source emb-imx-setup-desktop.sh -b build-desktop 

Choose "y" to accept EULA.
This script will create and bring you to ~/mickledore_desktop/build-desktop directory.

Note

Icon

The last line of the above script

$ DISTRO=imx-desktop-xwayland MACHINE=<machine name> source emb-imx-setup-desktop.sh -b <build dir>

  1. <machine name>

    • smarcimx8qm4gdesktop - if your board is quad lite or quad core i.MX8Q Max/Plus and 4GB LPDDR4.

    • smarcimx8qm8gdesktop - if your board is quad lite or quad core i.MX8Q Max/Plus and 8GB LPDDR4.

The default console debug port is SER3.

In this document, we will use smarcimx8qm4g as the example of machine name. Users need to change different machine name if you have different SMARC card variants.

 
Building the target platforms

 To build Embedian/NXP Yocto BSP, use the following commands:

$ MACHINE=smarcimxp4gdesktop bitbake -k imx-image-desktop


Once it done, you can find all required images under ~/<build directory>/tmp/deploy/images/<machine name>/

You may want to build programs that aren’t installed into a root file system so you can make them available via a feed site (described below.) To do this you can build the package directly and then build the package named package-index to add the new package to the feed site.

 

Once the build(s) are completed you’ll find the resulting images, rpm and licenses in folder ~/mickledore_desktop/<build directory>/tmp/deploy.

deploy/images/<machine name>/* 

This folder contains the binary images for the root file system and the Embedian SMARC-iMX8QM specific version of the boot file, Image and device tree file. Specifically the images are:

deploy/images/<machine name>/imx-boot-<machine name>-sd.bin-flash_evk

This is boot file binary for SMARC-iMX8QM

deploy/images/<machine name>/Image

The kernel Image for SMARC-iMX8QM.  

deploy/images/<machine name>/<device tee file>

Selecting display configuration is a matter of selecting an appropriate DTB file under deploy/images/<machine name>/<device tee file>

All available DTB files are listed in the table below.

DTB File NameDescription
imx8qm-smarc.dtbDevice tree blob for no display configuration.
imx8qm-smarc-hdmi.dtbDevice tree blob for HDMI display configuration.
imx8qm-smarc-dp.dtbDevice tree blob for Display Port (DP) display configuration.
imx8qm-smarc-edp.dtbDevice tree blob for embedded Display Port (eDP) display configuration.
imx8qm-smarc-lvds.dtbDevice tree blob for LVDS display configuration.
imx8qm-smarc-rpmsg.dtbDevice tree blob for Cortex-M4 configuration.


deploy/images/<machine name>/imx-image-desktop-<machine name>.*

Embedian Ubuntu 22.04 root file system images for software development on Embedian’s SMARC-iMX8QM platforms.


deploy/rpm/*

 This folder contains all the packages used to construct the root file system images. They are in rpm format and can be dynamically installed on the target platform via apt-get install command on the device. 


deploy/licenses/* 
A database of all licenses used in all packages built for the system.

Setup SD Card Manually


For these instruction, we are assuming: DISK=/dev/mmcblk0, "lsblk" is very useful for determining the device id.

$ export DISK=/dev/mmcblk0

Erase SD card:

$ sudo dd if=/dev/zero of=${DISK} bs=1M count=160

Create Partition Layout: Leave 1MB offset for boot file.

With util-linux v2.26, sfdisk was rewritten and is now based on libfdisk.

sfdisk

$ sudo sfdisk --version
sfdisk from util-linux 2.34

Create Partitions:

sfdisk >=2.26.x

Icon

$ sudo sfdisk ${DISK} <<-__EOF__
2M,48M,0x83,*

50M,,,
__EOF__


Format Partitions:

for: DISK=/dev/mmcblk0
$ sudo mkfs.vfat -F 16 ${DISK}p1 -n boot
$ sudo mkfs.ext4 ${DISK}p2 -L rootfs
 
for: DISK=/dev/sdX
$ sudo mkfs.vfat -F 16 ${DISK}1 -n boot
$ sudo mkfs.ext4 ${DISK}2 -L rootfs

Mount Partitions:

On some systems, these partitions may be auto-mounted...

$ sudo mkdir -p /media/boot/
$ sudo mkdir -p /media/rootfs/
 
for: DISK=/dev/mmcblk0
$ sudo mount ${DISK}p1 /media/boot/
$ sudo mount ${DISK}p2 /media/rootfs/
 
for: DISK=/dev/sdX
$ sudo mount ${DISK}1 /media/boot/
$ sudo mount ${DISK}2 /media/rootfs/

Install Boot File (imx-boot-<machine name>-sd.bin-flash_linux_m4 or imx-boot-<machine name>-sd.bin-flash_spl)

Boot file is factory default flashed at on-module eMMC flash.

If on-module eMMC Flash is empty

In some cases, when eMMC flash is erased or the u-boot is under development, we need a way to boot from SD card first. Users need to shunt cross the TEST# pin to ground. In this way, SMARC-iMX8QM will always boot up from SD card. 

Fuse flash.bin to the SD card. 

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>/


$ sudo dd if=<boot file> of=${DISK} bs=1024 seek=32

If on-module eMMC Flash is not empty

The <boot file> is pre-installed in on-module eMMC flash at factory default. SMARC-iMX8QM is designed to always boot up from on-module eMMC flash and to load Image, device tree blob and root file systems based on the setting of BOOT_SEL. If users need to fuse your own flash.bin or perform u-boot upgrade. This section will instruct you how to do that.

Copy <boot file> to the second partition home directory of your SD card and boot into SD card. Go to home directory and you should see flash.bin file. 

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>/


$ sudo cp -v <boot file> /media/rootfs/home/root/

Fuse <boot file> to the on-module eMMC flash. (The eMMC flash is emulated as /dev/mmcblk0 in SMARC-iMX8QM)

home directory


$ sudo dd if=<boot file> of=/dev/mmcblk0 bs=1024 seek=32

Icon
  1. If your u-boot hasn't been finalized and still under development, it is recommended to shunt cross the test pin and boot directly from SD card first. Once your u-boot is fully tested and finalized, you can fuse your <boot file> to eMMC flash.
  2. When TEST# pin of SMARC-iMX8QM is not shunt crossed, it will always boot up from on-module eMMC flash. U-boot will read the BOOT_SEL configuration and determine where it should load Image and device tree blob. When TEST# is shunt crossed (pull low), it will always boot up from SD card.

uEnv.txt based bootscript

Create "uEnv.txt" boot script: ($ vim uEnv.txt)

~/uEnv.txt


optargs="video=HDMI-A-1:1920x1080-32@60 consoleblank=0"
#optargs="video=HDMI-A-1:3840x2160-32@30 consoleblank=0"
#optargs="video=HDMI-A-1:3840x2160-32@60 consoleblank=0"
#console port SER3
console=ttyLP4,115200 earlycon
#console port SER2
#console=ttyLP1,115200 earlycon
#console port SER1
#console=ttyLP3,115200 earlycon
#console port SER0
#console=ttyLP0,115200 earlycon
mmcdev=1
mmcpart=1
image=Image
loadaddr=0x80280000
fdt_addr=0x83000000
mmcroot=/dev/mmcblk1p2 rw
usbroot=/dev/sda2 rw
mmcrootfstype=ext4 rootwait fixrtc
netdev=eth0
ethact=FEC0
ipaddr=192.168.1.150
serverip=192.168.1.53
gatewayip=192.168.1.254
mmcargs=setenv bootargs cma=1280M console=${console} root=${mmcroot} rootfstype=${mmcrootfstype} ${optargs}
# uenvcmd=run loadimage; run loadfdt; run mmcboot
# USB Boot
#usbargs=setenv bootargs console=${console} root=${usbroot} rootfstype=${mmcrootfstype} ${optargs}
#uenvcmd=run loadusbimage; run loadusbfdt; run usbboot

Copy uEnv.txt to the boot partition:

~/

Icon

$ sudo cp -v ~/uEnv.txt /media/boot/

Install Kernel Image

Copy Image to the boot partition:

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>/


$ sudo cp -v Image /media/boot

Install Kernel Device Tree Binary

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>/

$ sudo mkdir -p /media/boot/dtbs

$ sudo cp -v <device tree file> /media/boot/dtbs/imx8qm-smarc.dtb

All available DTB files are listed in the table below.

DTB File NameDescription
imx8qm-smarc.dtbDevice tree blob for no display configuration.
imx8qm-smarc-hdmi.dtbDevice tree blob for HDMI display configuration.
imx8qm-smarc-dp.dtbDevice tree blob for Display Port (DP) display configuration.
imx8qm-smarc-edp.dtbDevice tree blob for embedded Display Port (eDP) display configuration.
imx8qm-smarc-lvds.dtbDevice tree blob for LVDS display configuration.
imx8qm-smarc-rpmsg.dtbDevice tree blob for Cortex-M4 configuration.


The device tree name in your SD card has be to imx8qm-smarc.dtb

Install Root File System


Copy Root File System:

Yocto Built Rootfs:

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>/


$ sudo tar jxvf <filename.tar.bz2> -C /media/rootfs

Note

Icon
  1. SMARC-iMX8QM always boots up from on-module eMMCI flash first. The firmware in eMMC flash is factory pre-installed from Embedian. It will read the BOOT_SEL configuration that defined by SMARC specification on your carrier board and load Image and device tree blob from the partition one of the device (could be SD card, eMMC, GBE,..etc) that you selected.
  2. MAC address is factory pre-installed at on board I2C EEPROM at offset 60 bytes. It starts with Embedian's vendor code 10:0D:32. u-boot will read it and pass this parameter to kernel.
  3. The kernel modules is included in the Yocto rootfs.

Remove SD card:

$ sync
$ sudo umount /media/boot
$ sudo umount /media/rootfs

Setup SD Card Automatically


This section tells you how to set up an SD card automatically. It mainly uses a script to do all the steps in the above section.

$ cd ~/mickledore_desktop

$ sudo MACHINE=smarcimx8qm4gdesktop sources/meta-embedian/scripts/emb_mk_yocto_sdcard/emb-create-yocto-sdcard.sh /dev/sdX

Shunt cross TEST# pin to ground and set the BOOT_SEL to ON OFF OFF. The module will boot up from SD card.  


Writing Bitbake Recipes


In order to package your application and include it in the root filesystem image, you must write a BitBake recipe for it.

When starting from scratch, it is easiest to learn by example from existing recipes. 

Example HelloWorld recipe using autotools

For software that uses autotools (./configure; make; make install), writing recipes can be very simple:

 

DESCRIPTION = "Hello World Recipe using autotools"
SECTION = "console/utils"
PRIORITY = "optional"
LICENSE = "GPL"
PR = "r0"
  
S = "${WORKDIR}/git"
  
inherit autotools

 

SRC_URI specifies the location to download the source from. It can take the form of any standard URL using http://, ftp://, etc. It can also fetch from SCM systems, such as git in the example above.

PR is the package revision variable. Any time a recipe is updated that should require the package to be rebuilt, this variable should be incremented.

inherit autotools brings in support for the package to be built using autotools, and thus no other instructions on how to compile and install the software are needed unless something needs to be customized.

S is the source directory variable. This specifies where the source code will exist after it is fetched from SRC_URI and unpacked. The default value is ${WORKDIR}/${PN}-${PV}, where PN is the package name and PV is the package version. Both PN and PV are set by default using the filename of the recipe, where the filename has the format PN_PV.bb.

Example HelloWorld recipe using a single source file

This example shows a simple case of building a helloworld.c file directly using the default compiler (gcc). Since it isn’t using autotools or make, we have to tell BitBake how to build it explicitly.

 

DESCRIPTION = "HelloWorld"
SECTION = "examples"
LICENSE = "GPL"
  
SRC_URI = "file://helloworld.c"
  
S = "${WORKDIR}"
  
do_compile() {
    ${CC} ${CFLAGS} ${LDFLAGS} helloworld.c -o helloworld
}
  
do_install() {
    install -d ${D}${bindir}
    install -m 0755 helloworld ${D}${bindir}
}

 

In this case, SRC_URI specifies a file that must exist locally with the recipe. Since there is no code to download and unpack, we set S to WORKDIR since that is where helloworld.c will be copied to before it is built.

WORKDIR is located at ${OETREE}/<build directory>/tmp/work/armv8a-fsl-linux/<package name and version> for most packages. If the package is machine-specific (rather than generic for the armv8a architecture), it may be located in the smarcimx8qm4g-fsl-linux subdirectory depending on your hardware (this applies to kernel packages, images, etc).

do_compile defines how to compile the source. In this case, we just call gcc directly. If it isn’t defined, do_compile runs make in the source directory by default.

do_install defines how to install the application. This example runs install to create a bin directory where the application will be copied to and then copies the application there with permissions set to 755.

D is the destination directory where the application is installed to before it is packaged.

${bindir} is the directory where most binary applications are installed, typically /usr/bin.

For a more in-depth explanation of BitBake recipes, syntax, and variables, see the Recipe Chapter of the OpenEmbedded User Manual.

Setup eMMC Manually


Setting up eMMC usually is the last step at development stage after the development work is done at your SD card or NFS environments. From software point of view, eMMC is nothing but a non-removable SD card on board. For SMARC-iMX8QM, the SD card is always emulated as /dev/mmcblk1 and on-module eMMC is always emulated as /dev/mmcblk0. Setting up eMMC now is nothing but changing the device descriptor. 

This section gives a step-by-step procedure to setup eMMC flash. Users can write a shell script your own at production to simplify the steps.

First, we need to backup the final firmware from your SD card or NFS.

Prepare for eMMC binaries from SD card (or NFS):

Insert SD card into your Linux PC. For these instructions, we are assuming: DISK=/dev/mmcblk0, "lsblk" is very useful for determining the device id.

For these instruction, we are assuming: DISK=/dev/mmcblk0, "lsblk" is very useful for determining the device id.

$ export DISK=/dev/mmcblk0

Mount Partitions:

On some systems, these partitions may be auto-mounted...

$ sudo mkdir -p /media/boot/
$ sudo mkdir -p /media/rootfs/
 
for: DISK=/dev/mmcblk0
$ sudo mount ${DISK}p1 /media/boot/
$ sudo mount ${DISK}p2 /media/rootfs/
 
for: DISK=/dev/sdX
$ sudo mount ${DISK}1 /media/boot/
$ sudo mount ${DISK}2 /media/rootfs/

 

Copy Image to rootfs partition:

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>

$ sudo cp -v Image /media/rootfs/home/root

Copy uEnv.txt to rootfs partition:

Copy and paste the following contents to /media/rootfs/home/root ($ sudo vim /media/rootfs/home/root/uEnv.txt)

optargs="video=HDMI-A-1:1920x1080-32@60 consoleblank=0"
#optargs="video=HDMI-A-1:3840x2160-32@30 consoleblank=0"
#optargs="video=HDMI-A-1:3840x2160-32@60 consoleblank=0"
#console port SER3
console=ttyLP4,115200 earlycon
#console port SER2
#console=ttyLP1,115200 earlycon
#console port SER1
#console=ttyLP3,115200 earlycon
#console port SER0
#console=ttyLP0,115200 earlycon
mmcdev=0
mmcpart=1
image=Image
loadaddr=0x80280000
fdt_addr=0x83000000
mmcroot=/dev/mmcblk0p2 rw
usbroot=/dev/sda2 rw
mmcrootfstype=ext4 rootwait fixrtc
netdev=eth0
ethact=FEC0
ipaddr=192.168.1.150
serverip=192.168.1.53
gatewayip=192.168.1.254
mmcargs=setenv bootargs cma=1280M console=${console} root=${mmcroot} rootfstype=${mmcrootfstype} ${optargs}
# uenvcmd=run loadimage; run loadfdt; run mmcboot
# USB Boot
#usbargs=setenv bootargs console=${console} root=${usbroot} rootfstype=${mmcrootfstype} ${optargs}
#uenvcmd=run loadusbimage; run loadusbfdt; run usbboot

Copy device tree blob to rootfs partition:

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>

$ sudo cp -v <device tree file> /media/rootfs/home/root/imx8qm-smarc.dtb


Copy boot file to rootfs partition:

~/mickledore_desktop/<build dir>/tmp/deploy/images/<machine name>

$ sudo cp -v imx-boot-smarcimx8qm4g-sd.bin-flash_evk /media/rootfs/home/root/flash.bin

 

Copy real rootfs to rootfs partition:

$ pushd /media/rootfs
$ sudo tar cvfz ~/smarcimx8qm-emmc-rootfs.tar.gz .
$ sudo mv ~/smarcimx8qm-emmc-rootfs.tar.gz /media/rootfs/home/root
$ popd

Remove SD card:

$ sync
$ sudo umount /media/boot
$ sudo umount /media/rootfs

Copy Binaries to eMMC from SD card:

Insert this SD card into your SMARC-iMX8QM device.

Now it will be almost the same as you did when setup your SD card, but the eMMC device descriptor is /dev/mmcblk0 now. Booting up the device.

$ export DISK=/dev/mmcblk0

Erase eMMC:

$ sudo dd if=/dev/zero of=${DISK} bs=1M count=160

Create Partition Layout:

$ sudo sfdisk ${DISK} <<-__EOF__
2M,48M,0x83,*
50M,,,
__EOF__

Format Partitions:

$ sudo mkfs.vfat -F 16 ${DISK}p1 -n boot
$ sudo mkfs.ext4 ${DISK}p2 -L rootfs

Mount Partitions:

$ sudo mkdir -p /media/boot/
$ sudo mkdir -p /media/rootfs/
$ sudo mount ${DISK}p1 /media/boot/
$ sudo mount ${DISK}p2 /media/rootfs/

Install binaries for partition 1

Copy uEnv.txt/Image/*.dtb to the boot partition


$ sudo cp -v Image uEnv.txt /media/boot/

Install Kernel Device Tree Binary

$ sudo mkdir -p /media/boot/dtbs
$ sudo cp -v imx8qm-smarc.dtb /media/boot/dtbs/

Install Root File System


$ sudo tar -zxvf smarcimx8qm-emmc-rootfs.tar.gz -C /media/rootfs

 

Unmount eMMC:

$ sync
$ sudo umount /media/boot
$ sudo umount /media/rootfs

Flash boot file


$ sudo dd if=flash.bin of=${DISK} bs=1024 seek=32

 

Switch your Boot Select to eMMC (OFF ON ON) and you will be able to boot up from eMMC now.

Setup eMMC Automatically 


Boot up the module from SD card and run the following script. The Yocto images will be written into on-module eMMC.

$ smarc-imx8qm-create-yocto-emmc.sh /dev/mmcblk0 >/dev/null 2>&1

 Shutdown the device. Set TEST# pin floating and set the BOOT_SEL to OFF ON ON. The module will boot up from on-module eMMC. 

 

Default User


 The default Yocto desktop (ubuntu 22.04) build will create the account "user" with the password "user" for desktop evaluation, In order to change the account or password, uncomment and update APTGET_ADD_USERS in <build_dir>/conf/local.conf.


version 1.0a, 10/25/2024

Last updated 2025-10-24

 

  • No labels