Lời nói đầu

Trong bài viết này mình sẽ thực hiện cách để tích hợp công cụ cross-compile bên thứ ba vào quy trình phát triển và biên dịch. Ở bài viết trước việc cài đặt SDK phụ thuộc vào package có sẵn trong Yocto mà nó cung cấp. Nhưng nó sẽ có những hạn chế của nó.

Như mình đã liệt kê bảng tính năng mà SDK tiêu chuẩn cung cấp ở bài viết trước thì chúng ta thấy rằng nó chỉ hỗ trợ 2 tính năng cơ bản nhất là biên dịch và debug. Vậy những tính năng nâng cao khác thì không có. Dẫn đến việc phát triển trên board nhúng cũng khó khăn
Một cái hạn chế phát sinh sau này khi bạn sử dụng trên một thiết bị phần cứng cụ thể như sử dụng chip NXP, TI, Qualcomn thì phải tích hợp SDK của riêng bên vendor cung cấp thì mới có thể biên dịch được source code.

Hiện nay có rất nhiều cross-compiler bên thứ ba, chẳng hạn như các công cụ do Linaro, GNU Toolchain, GCC, v.v., đều là open-source để hỗ trợ cho các kiến trúc ARM trên board nhúng phổ biến hiện nay.

Tải công cụ

Mình sẽ chọn GNU Toolchain để tải về. Đây là một trong những bộ công cụ biên dịch phổ biến nhất. Lõi GCC hỗ trợ nhiều kiến trúc khác nhau như ARM, x86, RISC-V, v.v. Nó được sử dụng rộng rãi trong cộng đồng phát triển opensource và update cho đến thời gian hiện tại. Dưới đây là các bản phát hành của GCC.

Hình 1: Các bản phát hành gcc (Nguồn lấy từ internet)

Để tránh các lỗi không cần thiết ở các version mới nhất, vì vậy mình sẽ chọn version 13.3 cho ổn định trong quá trình sử dụng. Các bạn có thể xem các danh sách các package gcc của version 13.3.

Hình 2: Danh sách các toolchains x86_64 Linux cho kiến trúc AArch32 và AArch64 (Nguồn lấy từ internet)

Deploy Toolchain

Đầu tiên chúng tạo sẽ tạo một folder yocto để chứa các file và phần mềm liên quan

**~/**
mkdir yocto
cd yocto

Tải về package toolchain:

Ở đây mình đang sử máy tính với kiến trúc x86 thế nên mình sẽ tải gcc cho arm tại arm-gnu-toolchain-13.3.rel1-x86_64-aarch64-none-elf.tar.xz

Giải nén package toolchain:

**~/yocto**
tar xJf arm-gnu-toolchain-13.3.rel1-x86_64-aarch64-none-elf.tar.xz

Kiểm tra toolchain bằng cách chạy lệnh gcc -v

Sau khi giải nén xong, bạn có thể kiểm tra toolchain vừa cài đặt bằng cách chạy lệnh kiểm tra phiên bản của compiler (trình biên dịch):

**~/yocto**
./gcc-arm-13.3-x86_64-aarch64-none-linux-gnu/bin/aarch64-none-linux-gnu-gcc -v

gcc -v sẽ hiển thị phiên bản của gcc, thông tin cấu hình và target của compiler.

Kết quả bạn sẽ thấy thông tin như sau:

**Output**
COLLECT_GCC=./gcc-arm-13.3-x86_64-aarch64-none-linux-gnu/bin/aarch64-none-linux-gnu-gcc
COLLECT_LTO_WRAPPER=...
Target: aarch64-none-linux-gnu
Thread model: posix
gcc version 13.3 20191025 ...

Điều này xác nhận rằng bạn đã cài đặt thành công toolchain để biên dịch mã nguồn cho mục tiêu aarch64-none-linux-gnu (đây là kiến trúc ARM 64-bit dành cho hệ thống Linux có thể là raspberry pi, BBB, hay board nxp).

Cuối cùng copy toàn bộ source poky vào folder yocto để dễ quản lí:

**~/**
sudo cp -r /poky /home/user/yocto

Tải và cấu hình meta-arm

Tiếp theo, chúng ta cần tải xuống meta-arm, đây là layer chứa các recipe để hỗ trợ bộ toolchain của Arm.

**~/home/user/yocto/poky**
git clone https://git.yoctoproject.org/meta-arm -b scarthgap

Trong source meta-arm vừa tải, chúng ta cần xem qua file README trong meta-arm-toolchain:

**Output**
meta-arm-toolchain Yocto Layer
==============================

This layer contains recipes for the prebuilt GNU Arm toolchains.

Information regarding contributing, reporting bugs, etc can be found in the
top-level meta-arm readme file.

Recipes for pre-built GNU Arm toolchain for Linux development are provided under
``recipes-devtools/external-arm-toolchain/``.

external-arm-toolchain.bb
~~~~~~~~~~~~~~~~~~~~~~~~~

This recipe provides support for pre-built GNU toolchains targeting processors
from the Arm Cortex-A family and implementing the Arm A-profile architecture.

Usage
^^^^^

In order to use any of pre-built Arm toolchain versions (8.2, 8.3, 9.2 and so
on), a user needs to download and untar tool-set on host machine at a particular
installation path eg: ``/opt/toolchain/``. Then user needs to specify following
in ``conf/local.conf`` in order to replace OE toolchain with pre-built GNU-A
toolchain:

TCMODE = "external-arm"
EXTERNAL_TOOLCHAIN = "<path-to-the-toolchain>"

-  Eg. for AArch64 (eg. qemuarm64 machine in poky distro)
   EXTERNAL_TOOLCHAIN = "\
     <installation-path>/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu \
   "

-  Eg. for AArch32 (eg. qemuarm machine in poky distro)
   EXTERNAL_TOOLCHAIN = "\
     <installation-path>/gcc-arm-9.2-2019.12-x86_64-arm-none-linux-gnueabihf \
   "

Supported distros and machines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Since this pre-built GNU-A tool-set simply replaces OE toolchain, so it is
meant to be distro and machine agnostic as long as one is cross-compiling for
Arm A-profile architecture.

Tested distro and machines (for zeus stable release):
1.  Distro: poky; machines: qemuarm and qemuarm64 (build and boot tested)
2.  Distro: RPB; machines: dragonboard-410c (build and boot tested)
3.  Distro: world; machines: qemuarm and qemuarm64. Build tested for following
    layers:
    - poky/meta
    - poky/meta-poky
    - poky/meta-yocto-bsp
    - meta-openembedded/meta-oe
    - meta-openembedded/meta-python
    - meta-openembedded/meta-networking

SDK support
^^^^^^^^^^^

Pre-built toochain provides support to build OE SDK which has been tested using
following commands:

$ bitbake core-image-base -c populate_sdk
$ bitbake core-image-base -c testsdk

Note: Currently generated SDK only uses glibc provided by pre-built toolchain.
      The cross compiler, binutils, gdb/gdbserver etc. are built from source.
      This is something we would like to improve in future in order to package
      most of the components from pre-built toolchain instead.

Pre-built Arm toolchain for bare-metal development
--------------------------------------------------

Recipes for pre-built GNU Arm toolchain for bare-metal development are provided
under ``recipes-devtools/external-arm-toolchain/``.

gcc-arm-none-eabi_<version>.bb
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This recipe provides support for pre-built GNU Arm Embedded toolchain for
bare-metal software development on devices based on 32-bit Arm Cortex-A,
Cortex-R and Cortex-M processors.

Supported version: 9-2019-q4-major

gcc-aarch64-none-elf_<version>.bb
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This recipe provides support for pre-built GNU Arm toolchain for bare-metal
software development on devices based on 64-bit Arm Cortex-A processors.

Supported version: 9.2-2019.12

Layer maintainer(s)
-------------------
* Sumit Garg <sumit.garg@linaro.org>
* Denys Dmytriyenko <denis@denix.org>

Trong file README ở trên thì có 2 biến quan trọng chúng ta cần để ý:

Biến TCMODE

TCMODE là biến chỉ định loại toolchain mà hệ thống build của OpenEmbedded sẽ sử dụng. Toolchain là tập hợp các tool dùng để biên dịch source code và tạo ra các package phần mềm hoặc OS.
Mặc định, Yocto sẽ tự xây dựng toolchain của chính nó (gọi là internal toolchain). Tuy nhiên, nếu bạn muốn sử dụng một toolchain đã được biên dịch sẵn từ bên ngoài (như toolchain của ARM), bạn cần thay đổi giá trị của biến TCMODE thành "external-arm".
Khi bạn đặt TCMODE = "external-arm", hệ thống build sẽ sử dụng tệp cấu hình tcmode-external-arm.inc trong thư mục meta-arm-toolchain. Tệp này chứa hướng dẫn cho Yocto biết cách sử dụng toolchain bên ngoài.

Biến EXTERNAL_TOOLCHAIN

EXTERNAL_TOOLCHAIN là biến dùng để chỉ định đường dẫn đến thư mục nơi bạn đã cài đặt toolchain bên ngoài trên máy tính.
Ví dụ: nếu bạn đã tải xuống và giải nén toolchain ARM trong thư mục /home/eric/yocto/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu, bạn sẽ thiết lập biến như sau:

EXTERNAL_TOOLCHAIN = "/home/peeta/yocto/gcc-arm-13.3-x86_64-aarch64-none-linux-gnu"

Thêm Layer toolchain

Trước khi thêm Layer toolchain, cần phải khời tạo môi trường build của Yocto.

**~/yocto/poky**
source ./poky/oe-init-build-env

Sau khi thiết lập môi trường chúng ta mở và chỉnh sửa file bblayers.conf để thêm layer toolchian vào file bằng câu lệnh sau.

**~/yocto/poky**
nano conf/bblayers.conf

**~/yocto/poky/bblayer.conf**
BBLAYERS ?= " \ 
  /home/eric/yocto/poky/meta-arm/meta-arm-toolchain \   # Dòng này thêm lớp toolchain
  /home/eric/yocto/poky/meta \
  /home/eric/yocto/poky/meta-poky \
  /home/eric/yocto/poky/meta-yocto-bsp \
"

Cấu hình biến toolchain

Sau khi đọc qua file readme ở trong folder meta-amr-toolchain ở trên, mình đã giới thiệu 2 biến cần phải thêm vào file local.conf

**~/yocto/poky**
cd build
nano conf/local.conf

**~/yocto/poky/conf/local.conf**
...
TCMODE = "external-arm"
EXTERNAL_TOOLCHAIN = "/home/peeta/yocto/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu"
...

thêm 2 biến TCMODE và EXTERNAL_TOOLCHAIN vào cuối file

Biên dịch và kiểm tra

**~/yocto/poky/build**
bitbake core-image-minimal

Sau khi bitbake thì đã không có lỗi nào xảy ra

Cuối cùng chạy trên qemu để kiểm tra

**~/yocto/poky/build**
runqemu qemuarm64