Getting Started with the MCIMX8M-EVK

Download an NXP Linux BSP pre-built image

A .sdcard file is a disk image that is flashed directly into any SD card. This is the simplest way to load all necessary components required to boot the i.MX8MQuad EVK board. The latest pre-built images for the i.MX8MQuad EVK is available on the Linux download page.

The pre-built NXP Linux binary demo image provides a typical system and basic set of features for using and evaluating the processor. Without modifying the system, users can evaluate hardware interfaces, test SoC features, and run userspace applications.

To bring up the board and run Linux, four elements are needed on the boot image:

• Boot loader (U-Boot)
• Linux kernel image (zImage)
• A device tree file (.dtb) for the board being used
• A root file system (rootfs) for the particular Linux image

The .sdcard images contain these four elements in a single file.

When more flexibility is desired, an SD card can be loaded with individual components (boot loader, kernel, dtb file, and rootfs file) one-by-one or the .sdcard image is loaded and the individual parts are overwritten with the specific components.

Burn an SD card disk image from a Linux host computer

Once the BSP package is downloaded from the Linux download page, ensure that a pre-built SD card image built specifically for the i.MX8MQuad EVK board is in the compressed file. The SD card image is named:

<image_name>-<board name>.sdcard</board></image_name>

Note: An SD/MMC card reader is required to copy the SD card disk image into an SD card.**

Connect the SD/MMC card reader with a SD card to your host machine running the Linux OS.

The Linux OS kernel running on the host assigns a device node to the SD/MMC card reader.

To identify the device node assigned to the SD/MMC card, perform the following command in the host computer:

$ cat /proc/partitions

The instructions below will permanently delete existing content on the SD card and are dangerous to your PC if run incorrectly. If you have questions or would like further details, consult the i.MX Linux User Guide.

Run the following command to copy the SD card image to the SD/MMC card. Change /dev/sdX below to match the one used by the SD card.

$ sudo dd if=<image name>.sdcard of=/dev/sdX bs=1M && sync</image>

To setup the partition manually, read 4.3.3 in i.MX Linux User Guide.

To load individual components separately when the full SD card image is not used, refer to 4.3.4-3.4.6 in i.MX Linux User Guide.

With the source code and documentation, the users can customize the Linux image built for the device. For example, add or remove system components.

Build your own Linux BSP image (optional)

To build an NXP Linux BSP image, you can obtain the source code from the i.MX CodeAurora repository.

Detailed instructions on how to build an image are available in the Linux User Guide.

The Yocto Project

As an option, NXP provides a framework to build custom images. The Yocto Project is the framework of choice with NXP professional support to build custom images that are used for booting a Linux kernel, although other methods can be used.

Details on how to set up the Yocto Project go beyond this getting started guide. For details, refer to the NXP Yocto Users Guide.

Burn NXP Linux BSP image using Manufacturing Tool

The Manufacturing Tool, named MFGTool, is NXP tool of choice to load images on i.MX boards from a Windows OS host computer. The MFGTool is used to download images to different devices on i.MX board.

Perform the following steps to flash the board images:

1. The compressed file is found in the pre-built Linux BSP image download bundle.
2. Unzip the L4.9.88_2.0.0-ga_mfg-tools.tar.gz file to a selected location. This file includes two different MFGTool configurations, one with the rootfs images and one without it. For this tutorial, unzip the mfgtools-with-rootfs.zip which creates a directory which is named MFGTool- Dir in this example.
3. Ensure that the files inside the directory MFGTool-Dir/Profiles/Linux/OS Firmware/files path. If there are no files, copy the files from the pre-built images.
4. Change the board’s SW802 (boot mode) to 01 (from bit 1 to bit 2) to enter flash mode.
5. Power on the board. Use USB cable on the board OTG port, and connect a computer running Windows OS with the board.

Note: There are two USB micro ports in i.MX8MQuad EVK board: USB to UART, USB OTG. The USB to UART can be referenced as debug UART, and the USB OTG can be referenced as USB in the hardware image above. The debug UART can be used to watch the log of the hardware boot processing.

The SD card should be plugged in after the board is powered on.

6. Double-click the *.vbs file according to the target device as shown in the following table.

Target device and boot storage VBS file	*VBS file
i.MX8MQuad EVK	mfgtool2-yocto-mx8-evk-sdcard-sd2.vbs

7. Click Start to start flashing images.

   

   Figure 5. MFGTool interface

   The figure below shows flashing in progress, and the status bar shows the flash status. The flash may take one to two minutes depending on the host machine.

   

   Figure 6. MFGTool operation

   The figure below shows the tool when the flash is complete.

   

   Figure 7. MFGTool successful flash

8. Click Stop and disconnect the USB cable.
9. Change SW801 (boot mode) to 1100 and SW802 to 10 to switch the board back to J1601 boot mode.

Download NXP Android BSP Image

The pre-built NXP Android demo image provides a default system with certain features for the purpose of evaluation. Without modifying the system, users can perform some basic operations, and interact with the system to test hardware interfaces and develop a software application in the user space.

The pre-built images from the package are categorized by boot device and put in the directory with the device name. The latest pre-built image files can be found in Android section on the i.MX Software and Development Tool, or on the demo images downloader link.

Loading images and partition onto an SD card

Once you download the pre-built images, the script below can be used to partition an SD card:

 $ cd ${MY_ANDROID}/ $ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq /dev/sdX 

In /dev/sdX the X is the disk index from 'a' to 'z'. That may be different on each computer running Linux OS.

IMPORTANT The minimum SD card size required is 8 GB.

Different SD card sizes require different partition scripts:

• If the SD card is 8 GB, use:

   $ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq /dev/sdX

• If the SD card is 16 GB, use:

   $ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq -c 14 /dev/sdX

• If the SD card is 32 GB, use:

   $ sudo ./device/fsl/common/tools/fsl-sdcard-partition.sh -f imx8mq -c 28 /dev/sdX 

• Unmount all the SD card partitions before running the script.

   $ umount /dev/sdX 

Copy the related boot loader, boot image, system image, recovery image, GPT table image, and vendor image in your current directory.

This script requires to install the simg2img tool on the computer. simg2img is a tool that converts the sparse system image to raw system image on the Linux OS host computer. The android-toolsfsutils package includes the simg2img command for Ubuntu Linux OS.

Build your own Android BSP Image (Optional)

To build the Android source files a host computer running Linux OS is required. Ubuntu 14.04 (64-bit) version is the most tested OS for the Android NXP BSP Release.

Check whether you have all the necessary packages installed for an Android build. See "Setting up your machine" on the Android website Documentation .

In addition to the packages requested on the Android website, refer to Android User Guide to install the additional packages. Which can be found inside the Documentation bundle.

Source code

Get the Android source code from Google repo using the manifest and script provided inside the source code package.

 $ sudo apt-get install repo $ source ~/imx-o8.1.0_1.3.0_8mq_ga/imx_android_setup.sh 

By default, the imx_android_setup.sh script will create the source code build environment in the folder ~/android_build.

Note: ${MY_ANDROID} will be referred as the i.MX Android source code root directory in all i.MX Android release documentation.

 $ export MY_ANDROID=~/android_build 

Build

The build configuration command lunch can be issued with an argument strings.

 <build name>-<build> type></build></build> 

The following is an example on how to build the Android image with user type for the i.MX8MQuad EVK board:

 $ cd ~/myandroid $ source build/envsetup.sh $ lunch evk_8mq-user $ make 2>&1 | tee build-log.txt 

When the make command is complete, the build-log.txt file contains the execution output. Check for any errors.

The default configuration in the source code package takes internal eMMC as the boot storage. To change to SD card, refer to Android User’s Guide which can be found inside the Documentation bundle.

There are several additional information on how to build, customize and change the Android source code in the documents present in Documentation bundle.

Download UUU on Windows

Download the latest stable files from UUU GitHub page. An extensive tutorial for UUU can be found here

• uuu.exe
• libusb-1.0.dll
• Serial USB drivers (depending on your board and Windows installation)

Download the Latest Android Images

Download the Android demo files from NXP.com.

Extract the downloaded file into a know directory.

Burn the NXP Linux BSP Image to the Board

Copy the file named uuu from section Download UUU on Windows into the extracted Android demo directory.

Open Command Prompt and navigate to the extracted Android demo directory

> uuu.exe uuu-android-mx8mm-evk-sd.lst

Insert an SDcard on connector J1701. Turn on the board in serial download mode, uuu starts to copy the images to the board. To put the board in serial download mode follow the instructions on the Consult the Boot Switch Setup section.

When it finishes, turn off the board, and consult Boot switch setup to configure the board to boot from SDcard.

Download MCUXpresso SDK on Linux

Current releases of the MCUXpresso SDK and source code can be found at MCUXpresso SDK Builder.

To download the MCUXpresso SDK for i.MX8MQuad, follow these steps:

1. Click on “Select Development Board”.

2. Select evkmimx8mq under “Select a Device, Board, or Kit” and click on “Build MCUXpresso SDK” on the right.

   

3. Select “Host OS” as Linux.

4. Select “Toolchain/IDE” as GCC Arm Embedded.

5. Click on “Select Optional Middleware“, “Select All“ and hit “Save changes“.

6. Click on “Request Build”.

7. Wait for the SDK to build and download the package.

Build MCUXpresso SDK and install toolchain on Linux

1. Download and run the installer from launchpad.net/gcc-arm-embedded. This is the actual toolchain. The toolchain includes the compiler, linker, and so on. The GCC toolchain should correspond to the latest supported version, as described in the MCUXpresso SDK Release Notes found in the package already downloaded.

2. Export the toolchain location as ArmGCC_DIR.

   $ export ArmGCC_DIR=/usr

   Note: The /usr is the usual install directory when you apt-get gcc-arm-none-eabi. Change the directory if this changes.

3. Ensure that cmake is installed:

$ sudo apt-get install cmake

$ sudo apt-get install gcc-arm-none-eabi

Build MCUXpresso SDK

1. Change the directory of the command window to the demo armgcc directory and run the build command:

   $ <install_dir>/boards/evkmimx8mq/demo_apps/<demo_name>/armgcc</demo_name></install_dir>

   $ ./build_all.sh

2. There are two project configurations (build targets) supported for each MCUXpresso SDK project:

   Debug

   Compiler optimization is set to low, and debug information is generated for the executable. This target is selected for development and debug.

   Release

   Compiler optimization is set to high, and debug information is not generated. This target is selected for final application deployment.

   Note: There are script files provided to build both configurations. For this example, the Debug target is built and build_debug.sh is typed on the command line. If the Release target is desired, type build_release.sh instead.

3. The previous command generates the debug and release binaries (sdk20-app.bin). These files are in the debug and release folders.

4. Copy the bootable image sdk20-app.bin to the boot partition of the SD card.

Run applications using U-Boot

This section describes how to run applications using an SD card and pre-built U-Boot image for i.MX processor.

1. Following the steps on the Embedded Linux^® tab, prepare an SD card with a pre-built U-Boot + Linux image from Linux BSP package for the i.MX8MQuad processor. If you have already loaded the SD card with a Linux image, you can skip this step.

2. Insert the SD card in the host computer (Linux or Windows), and copy the application image (for example sdk20-app.bin) to the FAT partition of the SD card.
3. Safely remove the SD card from the PC.
4. Insert the SD card to the target board. Make sure to use the default boot SD slot and double check the Boot Switch Setup. The default configuration of the validation board boots from J1601, and on EVK board there is only one SD slot which is used for boot.

5. Connect the DEBUG UART slot on the board with to the PC through the USB cable. The Windows OS installs the USB driver automatically, and the Ubuntu OS will find the serial devices as well.

   See Serial Communication Console setup section in Out of the box for more instructions on serial communication applications.

6. Open a second terminal emulator on the i.MX8MQuad EVK board’s second enumerated serial port. This is the Cortex-M4’s serial console. Set the speed to 115200 bit/s, data bits 8, no parity, and power on the board.

7. Power up the board and stop the boot process by pressing any key before the U-Boot countdown reaches zero. At the U-Boot prompt on the first terminal emulator, type the following commands to U-Boot.

   => fatload mmc 1:1 0x7e0000 sdk20-app.bin

   => bootaux 0x7e0000

   These commands copy the image file from the first partition of the SD card into the Cortex-M4’s memory and release the Cortex-M4 from reset.

Download MCUXpresso SDK on Windows

Current releases of the MCUXpresso SDK and source code can be found at MCUXpresso SDK Builder.

To download the MCUXpresso SDK for i.MX8MQuad, follow these steps:

1. Click on “Select Development Board”.

2. Select evkmimx8mq under “Select a Device, Board, or Kit” and click on “Build MCUXpresso SDK” on the right.

   

3. Select “Host OS” as Linux.

4. Select “Toolchain/IDE” as GCC Arm Embedded.

5. Click on “Select Optional Middleware”, “Select All” and hit “Save changes”.

6. Click on “Request Build”.

7. Wait for the SDK to build and download the package.

Build NXP MCUXpressoSDK and install toolchain on Windows

Download and run the installer from launchpad.net/gcc-arm-embedded. This is the actual toolchain. The toolchain includes the compiler, linker, and so on. The toolchain includes the compiler, linker, and so on. The GCC toolchain should correspond to the latest supported version, as described in the MCUXpresso SDK Release Notes found in the package already downloaded.

Install MinGW

The Minimalist GNU for Windows (MinGW) development tools provide a set of tools not dependent on third-party C-Runtime DLLs (such as Cygwin). The build environment used by the MCUXpresso SDK does not utilize the MinGW build tools, but does leverage the base install of both MinGW and MSYS. MSYS provides a basic shell with a Unix-like interface and tools.

1. Download the latest MinGW mingw-get-setup installer from: Sourceforge website.

2. Run the installer. The recommended installation path is C:\MinGW, however, you may install to any location.

   Note: The installation path cannot contain any spaces.

3. Ensure that the mingw32-base and msys-base are selected under Basic Setup.

   

   Figure 13. MinGW files

4. Click Apply Changes in the Installation menu and follow the remaining instructions to complete the installation.

   

   Figure 14. Apply changes

5. Add the appropriate item to the Windows operating system Path environment variable. It can be found under Control Panel → System and Security → System → Advanced System Settings in the Environment Variables… section. The path is: <mingw_install_dir>\bin</mingw_install_dir>

   Important: Assuming the default installation path, C:\MinGW, an example is shown below. If the path is not set correctly, the toolchain does not work.
   If you have C:\MinGW\msys\x.x\bin in your PATH variable (as required by KSDK 1.0.0), remove it to ensure that the new GCC build system works correctly.

6. Create a new system environment variable and name it ArmGCC_DIR. The value of this variable should point to the Arm GCC Embedded tool chain installation path, which, for this example, is: C:\Program Files (x86)\GNU Tools Arm Embedded\4.8 2014q3

   Reference the installation folder of the GNU Arm GCC Embedded tools for the exact path name of your installation.

   

   Figure 15. Variable name

Install CMake

1. Download CMake 3.0.x

2. Before installing CMake, ensure that the option Add CMake to system PATH is selected. It is up to the user to select whether it is installed into the PATH for all users or just the current user. In this example, the assumption is that it is installed for all users.

   

   Figure 16. Install CMake

3. Follow the remaining instructions of the installer.

   Note: You may need to reboot your system for the PATH changes to take effect.

MCUXpresso SDK

1. Open a GCC Arm Embedded toolchain command window. To launch the window, from the Windows operating system Start menu, go to Programs → GNU Tools Arm Embedded version> and select GCC Command Prompt.

   

   Figure 17. GCC command prompt

2. Change the directory of the command window to the demo armgcc directory and run the build command:

   <install_dir>\boards\evkmimx8mq\demo_apps\<demo_name>\armgcc</demo_name></install_dir>

   Or double-click on the build_all.bat file in Explorer to perform the build. The expected output is shown in this figure:

   

   Figure 18. Build result

3. There are two project configurations (build targets) supported for each MCUXpresso SDK project:

   Debug

   • Compiler optimization is set to low, and debug information is generated for the executable. This target should be selected for development and debug.

   Release

   • Compiler optimization is set to high, and debug information is not generated. This target should be selected for final application deployment.

   Note: There are script files provided to build both configurations. For this example, the Debug target is built and build_debug.bat is typed on the command line. If the Release target is desired, type build_release.bat instead.

4. The previous command generates the debug and release binaries (sdk20-app.bin). These files are in the debug and release folders.

5. Copy the bootable image sdk20-app.bin to the boot partition of the SD card.

Run applications using U-Boot

This section describes how to run applications using an SD card and pre-built U-Boot image for i.MX processor.

1. Following the steps on the Embedded Linux^® tab, prepare an SD card with a pre-built U-Boot + Linux image from Linux BSP package for the i.MX8MQuad processor. If you have already loaded your SD card with a Linux image you can skip this step.
2. Insert the SD card to the host computer (Linux or Windows), and copy the application image (for example sdk20-app.bin) that you want to run to the FAT partition of the SD card.
3. Safely remove the SD card from the PC.
4. Insert the SD card to the target board. Make sure to use the default boot SD slot and double check the Boot Switch Setup. The default configuration of the validation board boots from J1601, and on EVK board there is only one SD slot which is used for boot.

5. Connect the DEBUG UART slot on the board with your PC through the USB cable. The Windows OS installs the USB driver automatically, and the Ubuntu OS will find the serial devices as well.

   See Serial Communication Console setup section in Out of the Box for more instructions for serial communication applications.

6. Open a second terminal emulator on the i.MX8MQuad EVK board’s second enumerated serial port. This is the Cortex-M4’s serial console. Set the speed to 115200 bps, data bits 8, no parity, and power on the board.

7. Power up the board and stop the boot process by pressing any key before the U-boot countdown reaches zero. At the U-Boot prompt on the first terminal emulator, type the following commands to U-Boot.

   => fatload mmc 1:1 0x7e0000 sdk20-app.bin

   => bootaux 0x7e0000

These commands copy the MCUXpressoSDK memory image file from the first partition of the SD card into the Cortex-M4’s memory and release the Cortex-M4 from reset.