.. _build_steps_|dev_platform|:

Build Steps
^^^^^^^^^^^^^^^

.. IMPORTANT::

    - ${PSDK_RTOS_PATH} refers to the path where Processor SDK RTOS (PSDK RTOS) is installed
    - ${PSDK_QNX_PATH} refers to the path where Processor SDK QNX (PSDK QNX) is installed inside the ${PSDK_RTOS_PATH}
    - The build is tested on Ubuntu (x86_64) 22.04 system and may not work on earlier or later Ubuntu systems.
    - 20GB of free space is required to install and build PSDK RTOS + PSDK QNX
    - Make sure you have *sudo* access


Build
======

Steps 1: To Build PSDK QNX components along with QNX BSP
---------------------------------------------------------


Make sure that that the QNX SDP |qnx_sdp_version| installed in your PC as mentioned in :ref:`getting_started_|dev_platform|`

- On Command line call the below environment variables:


.. ifconfig:: QNX_SDP_VERSION in ('800')

  .. code:: bash

      export QNX_SDP_VERSION=800
      export QNX_BASE=<path_to_qnx800_dir>


.. ifconfig:: QNX_SDP_VERSION in ('710')

  .. code:: bash

      export QNX_SDP_VERSION=710
      export QNX_BASE=<path_to_qnx710_dir>

.. code:: bash

    export BUILD_QNX_MPU=yes
    export PROFILE=release
    export BOARD=j721s2_evm
    export SOC=j721s2

- Run the below commands to build the source code provided in the SDK installer, with "N" being the number of parallel threads

.. code:: bash

    cd ${PSDK_QNX_PATH}/qnx
    make all -jN
    make qnx_fs_create

- The generated QNX executable are stored at:

.. csv-table::
   :header: "Generated Files", "Path"
   :widths: 50, 130

    QNX® BSP IFS file , ${PSDK_QNX_PATH}/bootfs
    PSDK QNX binaries , ${PSDK_QNX_PATH}/qnxfs/tibin
    PSDK QNX libraries, ${PSDK_QNX_PATH}/qnxfs/tilib

Steps 2: Build SBL and associated IPC Echo Test Firmware Images (BootApp Images)
--------------------------------------------------------------------------------------------

- Make sure Step 1 above is completed.

- To build SBL along with bootApp, and Main R5s & C7x cores IPC Echo test images based on FreeRTOS, the following commands need to be run:

.. code:: bash

    cd ${PSDK_QNX_PATH}/qnx
    make sbl_echo_test

- The generated binaries are as below. The lateapp files will include IPC Echo test images.

.. csv-table::
   :header: "Generated Files", "Path"
   :widths: 50, 130

    SBL                , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/tiboot3.bin
    TIFS               , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/tifs.bin
    Boot App           , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/app
    Firmware Image 1   , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/lateapp1
    Firmware Image 2   , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/lateapp2
    ATF Appimage       , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/atf_optee.appimage
    QNX IFS Appimage   , ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/ifs_qnx.appimage

- Also, the following IPC Echo test images are generated which is useful when using SPL+Uboot.

.. csv-table::
   :header: "Generated Files", "Path"
   :widths: 50, 130

    Main R50_0 image    , ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f0_0-fw
    Main R50_1 image    , ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f0_1-fw
    Main R51_0 image    , ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f1_0-fw
    Main R51_1 image    , ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f1_1-fw
    C7x_0 image         , ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-c71_0-fw
    C7x_1 image         , ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-c71_1-fw

Run Instructions
=================

.. NOTE::

    Below run steps offer two different setups, where user should select between:

    -  Step 2a or Step 2b, do not run both

Step 1: Prepare SD card for boot (one time only)
-------------------------------------------------


- Insert SD card onto your PC SD card slot and format SD card in to three partitions. At-least a 16GB SD card recommended.

    - First partition - FAT32: for boot loader, 128MB size recommended
    - Second partition - EXT4: for root filesystem, 1GB size recommended. (Used only for SPL+Uboot boot to store firmware images)
    - Third partition - FAT32: for QNX filesystem that include may include vision app files, More than 12GB recommended

- You can use one of two options to format your SD card

    - Option 1: You can use the utility script ${PSDK_QNX_PATH}/qnx/scripts/mkcard_qnx.sh to make the partitions

        - Use the command "df -h" to identify the device used by SD card
        - Unmount the SD card before running the script
        - Example, if your SD card is on device /dev/sdb having three partitions, run below to unmount them

        .. code:: bash

            umount /dev/sdb1
            umount /dev/sdb2
            umount /dev/sdb3

        - Run the script as below to partition it, answer "y" to all questions asked when running the script

        .. code:: bash

            cd ${PSDK_QNX_PATH}
            sudo ${PSDK_QNX_PATH}/qnx/scripts/mkcard_qnx.sh --device /dev/sdb

        .. NOTE::

            Make sure to give the correct device name to this script, example /dev/sda is typically local hard-disk,
            if you give this by mistake, your whole hard disk will be wiped off !!!

    - Option 2: you can use "gparted" utility (sudo apt install gparted) to use a GUI based interface to create the partitions.

        - Make sure you set the first FAT32 partition name as "boot", flag as "lba". Size of 128MB recommended.
        - Make the second partition as EXT4 partition and name as "rootfs". Size of 1GB recommended.
        - Name the third FAT32 partition as "qnxfs". Size of >12GB recommended.

- After formatting, remove and insert the SD card for the freshly formatted partitions to get auto mounted on the host PC.

Step 2a: Copy files to the SD Card - QNX + SBL + IPC Echo Test Firmware Images (BootApp Images) 
-------------------------------------------------------------------------------------------------

- Copy/untar filesystem and boot files to SD card by executing the script as shown below

.. code:: bash

    cd ${PSDK_QNX_PATH}
    ## Remove existing files on bootfs and qnxfs
    rm -rf <path_to_SD_card_mount_dir>/boot/*
    rm -rf <path_to_SD_card_mount_dir>/qnxfs/*
    ## Copy QNX FS
    cp -fv ${PSDK_QNX_PATH}/bootfs/*                                 <path_to_SD_card_mount_dir>/boot
    ## Copy QNX FS binaries
    cp -fv ${PSDK_QNX_PATH}/qnxfs/*                                  <path_to_SD_card_mount_dir>/qnxfs
    ## Copy SBL + bootapps + remote core file (lateapp*) + A72 appimages
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/tiboot3.bin           <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/tifs.bin              <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/app                   <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/lateapp1              <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/lateapp2              <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/atf_optee.appimage    <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_QNX_PATH}/bootfs_sbl_echotest_freertos/ifs_qnx.appimage      <path_to_SD_card_mount_dir>/boot

Step 2b: Copy files to the SD Card - QNX + SPL-Uboot + IPC Echo Test Firmware Images
---------------------------------------------------------------------------------------

.. NOTE::

    The SPL-Uboot binaries must be downloaded directly from https://www.ti.com/tool/download/PROCESSOR-SDK-LINUX-J721S2

- Download and extract the boot-j721s2-evm-tar.gz file to a know location say ${PSDK_LINUX_UBOOT_PATH}

- Copy/untar filesystem and boot files to SD card by executing the script as shown below

.. code:: bash

    cd ${PSDK_QNX_PATH}
    ## Remove existing files on bootfs and qnxfs
    rm -rf <path_to_SD_card_mount_dir>/boot/*
    rm -rf <path_to_SD_card_mount_dir>/qnxfs/*
    ## Copy QNX FS
    cp -fv ${PSDK_QNX_PATH}/bootfs/*                            <path_to_SD_card_mount_dir>/boot
    ## Copy QNX FS binaries
    cp -fv ${PSDK_QNX_PATH}/qnxfs/*                             <path_to_SD_card_mount_dir>/qnxfs
    ## Copy SPL-Uboot
    cp -fv ${PSDK_QNX_PATH}/qnx/scripts/u-boot/uEnv_j721s2.txt  <path_to_SD_card_mount_dir>/boot/uEnv.txt
    cp -fv ${PSDK_LINUX_UBOOT_PATH}/tiboot3.bin                 <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_LINUX_UBOOT_PATH}/tispl.bin                   <path_to_SD_card_mount_dir>/boot
    cp -fv ${PSDK_LINUX_UBOOT_PATH}/u-boot.img                  <path_to_SD_card_mount_dir>/boot
    ## Remove existing files on rootfs
    sudo rm -rf <path_to_SD_card_mount_dir>/rootfs/*
    ## Copy remote proc images
    sudo mkdir -p <path_to_SD_card_mount_dir>/rootfs/lib/firmware
    sudo cp -fv ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f0_0-fw  <path_to_SD_card_mount_dir>/rootfs/lib/firmware
    sudo cp -fv ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f0_1-fw  <path_to_SD_card_mount_dir>/rootfs/lib/firmware
    sudo cp -fv ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f1_0-fw  <path_to_SD_card_mount_dir>/rootfs/lib/firmware
    sudo cp -fv ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-main-r5f1_1-fw  <path_to_SD_card_mount_dir>/rootfs/lib/firmware
    sudo cp -fv ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-c71_0-fw  <path_to_SD_card_mount_dir>/rootfs/lib/firmware
    sudo cp -fv ${PSDK_QNX_PATH}/rootfs_echotest_freertos/lib/firmware/j721s2-c71_1-fw  <path_to_SD_card_mount_dir>/rootfs/lib/firmware

Step 2e: xSPI Boot Mode
-----------------------

- To flash boot binaries to the xSPI flash, you need to have Uniflash flashprogrammer installed in the host PC. If you don't have this, install it from http://www.ti.com/tool/UNIFLASH

- Update the UNIFLASH_VERSION value in "psdkqa/qnx/scripts/sbl/makefile" to correspond to the downloaded version of uniflash.

- Make sure that the MCU UART is connected to the host PC. Note the port name of the second COM PORT of the MCU UART. You can find this using "dmesg | grep ttyUSB" in linux.
  For example let's assume it was '/dev/ttyUSB1'.

- Update the UNIFLASH_COM_PORT value in "psdkqa/qnx/scripts/sbl/makefile".

- Make sure the EVM board dip-switch are set for UART Boot mode. Please refer to :ref:`evm_setup_|dev_platform|` for more details.

- Run the below command to flash the xSPI.

.. code:: bash

    make sbl_echo_test_ospi_flashing

- Note: if using an HS device, you will instead need to run the below command:

.. code:: bash

    make sbl_echo_test_ospi_flashing_hs

- Important note for the step above: if you face a permissions issue when running the above command, you can run the below command first which changes the permissions of the /dev/ttyUSB* devices to not require sudo permissions

.. code:: bash

    sudo usermod -a -G dialout $USER

- Change the EVM board dip-switch settings to xSPI Boot mode. Please refer to :ref:`evm_setup_|dev_platform|` for more details.

- Put the SD card with the QNX filesystem into the EVM, as it will still require filesystem access in order to use xSPI boot mode.

- Boot the EVM.

Step 3: Boot the EVM with SD card
----------------------------------

- Make sure the EVM board dip-switch are set for SD Boot mode. Please refer to :ref:`evm_setup_|dev_platform|` for more details.

- Power on the board.

- Debug logs would be printed to respective UART debug consoles based on the bootloader and firmware image used.

.. csv-table::
   :header: "Debug UART ", "Debug log seen"
   :widths: 50, 130

    Main UART 0     , Uboot and QNX logs
    MCU UART 1      , SBL and BootAPP logs
