Changes between Version 1 and Version 2 of catalina/bsp

Timestamp:

04/30/2026 05:41:47 PM (29 hours ago)

Author:

Tim Harvey

Comment:

added additional sections

catalina/bsp

@@ -93 +93 @@
 source ./setup-environment
 }}}
+
+[=#kernel]
+==== Modifying the stand-alone Linux Kernel
+The Gateworks Catalina BSP instructions [#build above] create an environment for building the Linux kernel among other targets.
+
+You can modify the default Gateworks kernel config as well as build it manually:
+ * Modify kernel menuconfig:
+{{{#!bash
+make linux-menuconfig
+}}}
+ * Make kernel by hand
+{{{#!bash
+source ./setup-environment
+cd linux
+make menuconfig
+make savedefconfig
+diff defconfig ../configs/imx95_catalina_linux-6.18_defconfig # show changes
+cp defconfig ../configs/imx95_catalina_linux-6.18_defconfig # copy changes (if desired)
+}}}
+
+[=#toolchain]
+== ARM64 Toolchain
+The buildroot based ARM64 toolchain is used can be used by sourcing the [https://github.com/Gateworks/bsp-catalina/blob/master/setup-environment setup-environment] file which adds to your PATH and sets the CROSS_COMPILE variables:
+{{{#!bash
+source ./setup-environment
+}}}
+
+Note this is not necessary to do if you are using the Makefile as it specifies the necessary ARCH and CROSS_COMPILE vars where needed.
+
+=== Buildroot based toolchain
+The Catalina BSP uses buildroot to build the ARM64 toolchain used to build everything that runs on the A55 cores: ATF, kernel and bootloader firmware.
+
+The buidlroot config is [https://github.com/Gateworks/bsp-catalina/blob/main/configs/buildroot_arm64_toolchain_defconfig configs/buildroot_arm64_toolchain_defconfig].
+
+The bsp [https://github.com/Gateworks/bsp-catalina/blob/main/Makefile Makefile] has an 'arm64-toolchain' target which is built as a pre-requisite for building code running on the A55 cores.
+
+The toolchain is built using buildroot 2026.02 with the following details (which are all defaults for this version of buildroot):
+ - Linux 6.18 kernel headers
+ - glib libc
+ - binutils 2.44
+ - gcc 13.4
+ - C++ support (default is to disable this; we enable it)
+
+Note there are other options you may want to change for your needs such as using a different libc, different compiler version, or enable WCHAR support or additional threading support. To do so you can:
+{{{#!bash
+make arm64-toolchain-menuconfig # select changes
+make clean-toolchain
+make
+}}}
+ * make sure you clean and rebuild when changing toolchain options
+
+=== External toolchain
+The Catalina BSP uses buildroot to build the toolchain used to build the kernel and bootloader firmware.
+
+While the BSP makefile will always build the buildroot ARM64 toolchain (unless you comment that out in the Makefile) you can easily use a toolchain of your liking by modifying the environment like 'setup-environment' does and adjusting the PATH and CROSS_COMPILE statements int he Makefile.
+
+
+=== Cross compile examples
+
+Examples of cross-compiling on your development host using the ARM64 buildroot toolchain
+ * ANSI-C hello world:
+{{{#!bash
+cat << EOF > helloworld.c
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv)
+{
+        printf("hello world!\n");
+
+        return 0;
+}
+EOF
+. ./setup-environment # setup environment for buildroot toolchain
+${CROSS_COMPILE}gcc helloworld.c --static -o helloworld
+}}}
+  - Note that if you want to use shared libraries you would either need to copy the toolchains libc (buildroot/output/target/lib/) to the target so that the interpreter and shared libs are present or you can use Ubuntu's cross-toolchain instead (see [wiki:/ubuntu#hello-world.c ubuntu/cross-compile])
+ * C++ hello world:
+{{{#!bash
+cat << EOF > helloworld.cpp
+#include <iostream>
+
+using namespace std;
+
+int main() {
+        cout << "Hello World!";
+        return 0;
+}
+EOF
+. ./setup-environment # setup environment for buildroot toolchain
+${CROSS_COMPILE}gcc helloworld.cpp --static -lstdc++ -o helloworld
+}}}
+  - Note that if you want to use shared libraries you would either need to copy the toolchains libc (buildroot/output/target/lib/) to the target so that the interpreter and shared libs are present or you can use Ubuntu's cross-toolchain instead (see [wiki:/ubuntu#hello-world.c ubuntu/cross-compile])
+ * kernel module:
+{{{#!bash
+. ./setup-environment # setup environment for buildroot toolchain
+make kernel_image # first build the kernel
+make -C linux M=$PWD/my-module modules
+}}}
+  - Note that some out-of-tree kernel modules do not follow the suggested Makefile standards and may need to be modified to use the CROSS_COMPILE prefix and/or specify the kernel directory (as opposed to the above example where you do a make in the linux dir and set M to the path of your module)
+
+
+[=#target-compile]
+== Building applications on the Catalina Target
+
+=== Out-of-Tree Kernel Modules on Target
+Gateworks Catalina BSP now creates images that have built in support for building external or out-of-tree kernel modules on a target board, allowing users to extend the functionality of the kernel with custom or third-party modules. Below are some examples demonstrating how to build and install external modules on a one of our Catalina boards:
+
+Before building any external kernel modules, it's essential to ensure your system has necessary dependencies installed. We recommend starting with an update of package lists followed by the installation of essential tools. Run the following commands:
+{{{#!bash
+apt update
+apt install -y build-essential git bc file flex bison
+}}}
+
+Examples:
+ 1. cryptodev-linux (a properly defined Makefile)
+{{{#!bash
+git clone http://github.com/cryptodev-linux/cryptodev-linux
+cd cryptodev-linux
+make && make modules_install
+modprobe cryptodev
+}}}
+1. something with an improper or problematic Makefile but with a single C file for example uiodma.c
+{{{#!bash
+git clone https://github.com/nxp-imx-support/uiodma-driver.git
+cd uiodma-driver/uiodma
+# build module
+make -C /lib/modules/$(uname -r)/build M=$PWD obj-m=uiodma.o modules
+# install module
+make -C /lib/modules/$(uname -r)/build M=$PWD obj-m=uiodma.o modules_install
+}}}
+ - The kernel build system will still look for a file named Makefile or Kbuild in your directory. If the existing files are so broken that it can't even parse them you will need to rename/remove them
+ - If you need to pass flags to the compiler define them as 'KCFLAGS' - ie 'KCFLAGS="-Wno-missing-prototypes -Wno-missing-declarations"
+
+These examples illustrate the process of building and installing external kernel modules. Users can adapt these instructions for other modules as needed, ensuring that dependencies are met and the module is properly installed and loaded into the kernel.
+
+