Supporting custom carrier boards with a single image for Nvidia Jetson Orin Nano

Issue Overview

Users of the Nvidia Jetson Orin Nano Dev board are seeking to support different variants of carrier boards using a single set of firmware files. The challenge lies in implementing a mechanism to dynamically check hardware presence and apply appropriate configurations or perform boot-time tasks based on the detected hardware. This functionality is particularly important for manufacturers developing multiple carrier board variants who wish to streamline their firmware management process.

Possible Causes

1. Limited documentation: The lack of comprehensive documentation on implementing custom hardware detection and configuration mechanisms for the Jetson Orin Nano platform.

2. Complexity of UEFI implementation: The current UEFI implementation relies on specific EEPROM structures, which may not be suitable for all custom carrier board designs.

3. Absence of flexible hardware detection: The existing system may not provide easy-to-use methods for detecting hardware variants without pre-programmed EEPROMs.

4. Lack of examples: There appears to be a shortage of readily available examples demonstrating how to interact with I2C devices or implement custom hardware detection methods in the boot process.

Troubleshooting Steps, Solutions & Fixes

1. Understand the current EEPROM reading mechanism:

   • The UEFI uses the eeprom-manager in the device tree to read EEPROM data.
   • Examine the device tree to locate the eeprom-manager configuration.
   • Review the NVIDIA EDK2 platform support repository for implementation details:

     https://github.com/NVIDIA/edk2-nvidia
     

2. Explore alternative hardware detection methods:

   • Instead of using pre-programmed AT24-compatible EEPROMs, consider using I2C GPIO expanders with resistor settings to detect hardware variants and revisions.
   • This approach can provide more flexibility and reduce the need for pre-programming components.

3. Implement custom hardware detection:

   • Develop a custom driver or module that can interact with I2C devices during the boot process.
   • Focus on creating a solution that can read GPIO states or communicate with I2C GPIO expanders to determine the hardware configuration.

4. Extend the existing mechanism:

   • Modify the UEFI code to include your custom hardware detection method.
   • Update the TEGRA_CPUBL_PARAMS structure to include the results of your hardware detection.

5. Implement dynamic configuration application:

   • Develop a method to apply DTB (Device Tree Blob) overlays based on the detected hardware configuration.
   • Create a mechanism to perform simple boot-time tasks, such as I2C calls to GPIO expanders for enabling serial access.

6. Consult NVIDIA documentation and support:

   • Review the Jetson Linux Developer Guide for information on customizing the boot process and device tree:

     https://docs.nvidia.com/jetson/archives/r35.3.1/DeveloperGuide/index.html
     

   • Reach out to NVIDIA developer support or community forums for guidance on implementing custom hardware detection methods that align with NVIDIA’s implementations.

7. Develop and test incrementally:

   • Start with a simple implementation that detects a single hardware variant.
   • Gradually expand the detection capabilities to cover all your carrier board variants.
   • Thoroughly test each implementation to ensure it doesn’t interfere with the standard boot process.

8. Document your custom implementation:

   • Create detailed documentation of your custom hardware detection and configuration process.
   • Include information on how to maintain and update the system as new carrier board variants are developed.

9. Consider contributing back to the community:

   • If you develop a robust and flexible solution, consider sharing it with the NVIDIA developer community or submitting it as a potential enhancement to the official NVIDIA repositories.

By following these steps and developing a custom solution, you should be able to create a single firmware image that can support multiple carrier board variants for the Nvidia Jetson Orin Nano Dev board. Remember to thoroughly test your implementation to ensure compatibility and reliability across all your hardware configurations.