Tweaks

Author: madeline-underwood

content/learning-paths/automotive/zenacssdebug/config.md

@@ -8,7 +8,7 @@ weight: 4 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 
-## Debug configuration
+## Set up a debug configuration for the Zena CSS FVP
 
 Now you'll walk through setting up an Arm Development Studio debug configuration for the Zena CSS FVP using the Iris interface. This is a fast, reliable path to a working configuration.
 

content/learning-paths/automotive/zenacssdebug/connect.md

@@ -8,7 +8,7 @@ weight: 5 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 
-## Debug Connections
+## Overview
 
 You are now ready to create debug connections for each of the sub-systems within Zena CSS. In this section you will create the connections, which will be subsequently enhanced in the following section. You may prefer to fully set up one such connection before moving to others.
 
@@ -79,12 +79,8 @@ Create **Primary_Linux.launch** for Linux kernel debug with OS awareness:
 - Use **File > New > Model Connection**.
 - Select your **Zena_CSS_FVP** model.
 - In **Edit configuration**, expand **Linux Kernel Debug** and choose **ARM_Cortex-A720AEx16 SMP Cluster 1**.  
-  This connects to all 16 Cortex-A720AE processors described in the FVP. Only cores 0 to 3 are used by the default Linux configuration
+  This connects to all 16 Cortex-A720AE processors described in the FVP. Only cores 0 to 3 are used by the default Linux configuration.
 
 To learn more about OS awareness in Arm Debugger, see the [OS awareness documentation](https://developer.arm.com/documentation/101470/latest/Debugging-Embedded-Systems/About-OS-awareness).
 
-## Next steps: enhance connections (symbols, reset, semihosting)
 
-{{% notice Next %}}
-In the next section, you will enhance these connections with symbol loading, reset behavior, semihosting, and Linux kernel awareness settings.
-{{% /notice %}}

content/learning-paths/automotive/zenacssdebug/primarycompute.md

@@ -1,13 +1,13 @@
 ---
 # User change
-title: "Debug Primary Compute and Linux"
+title: "Debug primary compute and Linux"
 
 weight: 8 # 1 is first, 2 is second, etc.
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
-## Debug Primary Compute
+## Debug primary compute
 
 The Primary Compute application processors (`Cortex-A720AE`) are the final processors to be enabled.
 
@@ -39,7 +39,7 @@ Run to **bl2_entrypoint** and step through as required.
 Symbol loading is Exception Level–aware. If execution changes Exception Level, load symbols into the corresponding EL address space. For example, the processors start in EL3 and transition to EL2N when the Linux kernel is enabled.
 {{% /notice %}}
 
-## Debug the Linux kernel with OS awareness (SMP)
+## Debug the Linux kernel with OS awareness (symmetric multiprocessing)
 
 Switch to the `Primary_Linux.launch` connection you created earlier to enable Arm Development Studio OS awareness for the Linux kernel. Load the kernel symbols and set source mapping if your kernel sources are located outside the default paths:
 

content/learning-paths/automotive/zenacssdebug/rse.md

@@ -8,6 +8,8 @@ weight: 6 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 
+## Overview
+
 You'll now move on to debug the initial code that runs on the Runtime Security Engine (RSE) based on Cortex-M55 in the Zena CSS FVP. You will launch the model with the Iris debug server, connect from Arm Development Studio, load Trusted Firmware-M (TF‑M) symbols, and step from reset.
 
 ## Launch the FVP and hold at reset
@@ -43,12 +45,12 @@ The FVP configures the secure vector table (**VTOR_S**) at `0x11000000`. If you
 Load TF‑M symbols and map sources:
 
 - In **Debug Control**, open the pane menu and choose **Load...**
-- Select **Add Symbols file**
+- Select **Add Symbols file**.
 - Choose the TF‑M image, for example:
    ```bash
    /arm-auto-solutions/build/tmp_baremetal/work/fvp_rd_aspen-poky-linux/trusted-firmware-m/2.1.0/build/bin/bl1_1.axf
    ```
-- When prompted for **substitute path**, map build-time paths to your local sources, for example:
+When prompted for **substitute path**, map build-time paths to your local sources, for example:
    ```bash
    /usr/src/debug/trusted-firmware-m/2.1.0/
    /arm-auto-solutions/build/tmp_baremetal/work/fvp_rd_aspen-poky-linux/trusted-firmware-m/2.1.0/git/tfm/
@@ -69,10 +71,10 @@ Paths vary by environment. Use your actual build output and source locations whe
 
 Automate the connection steps by adding **Debugger Commands** to the `.launch` configuration so they run on every attach:
 
-- Open (double-click) your **RSE.launch** file
-- Go to the **Debugger** tab
-- Enable **Execute debugger commands**
-- Add commands similar to the following (adjust paths as needed)
+- Open (double-click) your **RSE.launch** file.
+- Go to the **Debugger** tab.
+- Enable **Execute debugger commands**.
+- Add commands similar to the following (adjust paths as needed).
 
 ```text
 stop

content/learning-paths/automotive/zenacssdebug/safetyisland.md

@@ -9,42 +9,48 @@ layout: "learningpathall"
 ---
 ## Debug Safety Island code from beginning
 
-The Safety Island (Cortex-R82AE) is released from reset by the RSE code, and so the RSE code must proceed to that point before the Safety Island core can execute.
+The Safety Island subsystem based on the Cortex-R82AE is released from reset by RSE code. To debug Safety Island from first instruction, you must let the RSE (Cortex‑M55) code reach the point where it enables Safety Island on the Zena CSS FVP.
 
-### Launch FVP
+## Launch the FVP and reconnect RSE
 
-If necessary, restart the FVP in the reset state as before, and reconnect `RSE`.
+If necessary, start (or restart) the FVP held at reset and reconnect the RSE model connection in Arm Development Studio:
 
 ```command
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- --iris-server --iris-port 7100"
 ```
 
-Set up the `SI` connection in a similar way as the `RSE` connection. Use the following commands in the `Debugger` pane. This will load debug symbols and perform the necessary path substitution. You can then set a breakpoint on the entry of the `SI` code, `arch_exception_reset`.
+{{% notice Tip %}}
+For remote debugging, add `-A` and ensure the chosen Iris port (default `7100`) is reachable.
+{{% /notice %}}
+
+## Connect the debugger to Safety Island (Cortex-R82AE)
 
-``` text
+Configure the **SI** model connection similarly to **RSE**. Add the following **Debugger commands** to load symbols, set up source path substitution, and break at the Safety Island reset entry (`arch_exception_reset`):
+
+```text
 stop
 add-symbol-file /arm-auto-solutions/build/tmp_baremetal/deploy/images/fvp-rd-aspen/si0_ramfw.elf
 set substitute-path /usr/src/debug/scp-firmware/2.14.0/ /arm-auto-solutions/build/tmp_baremetal/work/fvp_rd_aspen-poky-linux/scp-firmware/2.14.0/git/
 b arch_exception_reset
 ```
 
 {{% notice Note %}}
-Exact paths may differ for your set up.
+Paths vary by environment. Use your actual build output and source locations when adding symbols or configuring path substitution.
 {{% /notice %}}
 
-### Start execution
+## Start execution to release Safety Island
 
-Select the `RSE` connection in the `Debug Control` pane, and start execution (this will be unavailable in the `SI` connection, as that is currently powered down).
+In **Debug Control**, select the **RSE** connection and start execution (run). The **SI** connection remains unavailable to run until Safety Island is powered up.
 
-The `RSE` code will run until the point that the `SI` is enabled. This is reflected in the output log.
+When RSE enables Safety Island, you will see a log message like:
 
-``` output
+```output
 [INF] BL2: SI CL0 post load start
 ```
 
-#### Full output log
+## Full output log
 
-The full output lof is shown here for your reference:
+The full output log is shown here for your reference:
 
 ``` output
 Trying ::1...

content/learning-paths/automotive/zenacssdebug/zena.md

@@ -8,7 +8,7 @@ weight: 2 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 
-# Arm Zena Compute Subsystem
+## Arm Zena Compute Subsystem
 
 The Arm Zena Compute Subsystem (CSS) consists of a high-performance Arm Cortex-A720AE application processor system (primary compute), augmented with an Arm Cortex-R82AE–based Safety Island (SI) and a real-time domain to host additional system-safety monitoring and real-time services.
 
@@ -25,7 +25,7 @@ Follow the steps to download and build the software stack in the [Arm Zena CSS U
 Here the default **Arm Automotive Solutions Demo** build is used.
 
 {{% notice Note %}}
-The focus of this Learning Path primarily is to demonstrate how to debug the software stack.
+The primary focus of this Learning Path is to demonstrate how to debug the software stack.
 {{% /notice %}}
 
 ## Verify the build and execution
@@ -62,7 +62,7 @@ For more information, see [Arm Development Studio](https://developer.arm.com/Too
 
 Arm Development Studio is a commercial, license-managed product. For installation and setup instructions, see the [Arm Development Studio Install Guide](/install-guides/armds/).
 
-Launch the IDE. It’s recommended that you create a new workspace folder.
+Launch the IDE and create a new workspace folder.
 
 If you’re prompted by the launcher (this prompt is disabled by default), create a new folder there.