Uboot Freeze When Accessing TZPC Registers in Normal World

Uboot’s Access to TZPC Registers During Startup vs. Command Line Environment

The core issue revolves around the behavior of Uboot when accessing TrustZone Protection Controller (TZPC) registers on an Exynos 4412 board. During the startup process, Uboot initializes the TZPC registers through a routine called tzpc_init in the lowlevel_init_SCP.S file. This initialization suggests that Uboot has the ability to access the TZPC controller during its early stages. However, once Uboot enters the command line environment, attempting to access the TZPC registers using the md 0x10110000 1 command results in a freeze, likely due to a data abort exception.

The TZPC is a secure world component, and according to the ARM Trusted Firmware (ATF) documentation, Uboot operates in the normal world. This raises the question of how Uboot can access the TZPC registers during startup but fails to do so in the command line environment. The discrepancy suggests that there might be a change in the system’s state or configuration between the startup phase and the command line phase, affecting Uboot’s ability to access secure world components.

Secure vs. Non-Secure State Configuration and Address Validation

The primary cause of this issue lies in the distinction between the secure and non-secure states of the ARM Cortex-A9 processor on the Exynos 4412 board. During the early stages of Uboot’s execution, the system might be in a state that allows access to secure world components like the TZPC. This could be due to the initial bootloader or firmware configuration that temporarily grants Uboot access to secure resources. However, once the system transitions to the normal world, access to secure world components is restricted, leading to a data abort exception when Uboot attempts to access the TZPC registers.

Another potential cause is the correctness of the register address being accessed. The address 0x10110000 might not be valid or correctly mapped in the normal world, causing the access to fail. It is also possible that the TZPC registers are not properly initialized or configured for access from the normal world, leading to the observed behavior.

Implementing Secure World Configuration and Address Space Management

To resolve this issue, it is essential to ensure that the TZPC registers are correctly configured and accessed only from the appropriate world. Here are the detailed steps to troubleshoot and fix the problem:

1. Verify the System State During Uboot Startup:

   • Determine the state of the system (secure or non-secure) during Uboot’s early stages. This can be done by examining the bootloader or firmware code that runs before Uboot. If the system is in the secure state during startup, Uboot might have temporary access to secure world components.
   • Ensure that the transition from the secure state to the normal world is correctly handled. This involves configuring the appropriate registers and setting up the necessary security mechanisms to prevent unauthorized access to secure world components.

2. Check the TZPC Register Address and Configuration:

   • Verify that the address 0x10110000 is correct and properly mapped in the normal world. This can be done by consulting the Exynos 4412 datasheet and the TZPC documentation.
   • Ensure that the TZPC registers are correctly initialized and configured for access from the normal world. This might involve setting up the necessary permissions and security policies in the TZPC controller.

3. Modify Uboot Code to Handle Secure World Access:

   • If Uboot needs to access the TZPC registers during its operation, consider moving the initialization code to the secure world firmware, such as the ARM Trusted Firmware (ATF) EL3 level. This ensures that the TZPC registers are configured correctly before Uboot starts executing in the normal world.
   • Implement proper error handling in Uboot to detect and handle data abort exceptions gracefully. This can prevent the system from freezing and provide useful diagnostic information.

4. Use Debugging Tools to Analyze the Issue:

   • Utilize debugging tools such as JTAG or SWD to trace the execution of Uboot and monitor the system state during startup and command line phases. This can help identify the exact point where the access to the TZPC registers fails.
   • Analyze the memory map and register access patterns to ensure that there are no conflicts or misconfigurations that could lead to the observed behavior.

5. Consult ARM Documentation and Community Resources:

   • Refer to the ARM Architecture Reference Manual and the Exynos 4412 datasheet for detailed information on the TZPC controller and the secure/non-secure state transitions.
   • Engage with the ARM community and forums to seek advice and share experiences related to similar issues. This can provide valuable insights and potential solutions from other developers who have faced similar challenges.

By following these steps, you can systematically troubleshoot and resolve the issue of Uboot freezing when accessing TZPC registers in the normal world. The key is to ensure that the system state, register configuration, and access permissions are correctly managed to prevent unauthorized access to secure world components.