Updates

madeline-underwood · madeline-underwood · commit 196ccb6c003b · 2025-09-23T21:00:10.000Z
diff --git a/content/learning-paths/automotive/zenacssdebug/config.md b/content/learning-paths/automotive/zenacssdebug/config.md
@@ -10,7 +10,7 @@ layout: "learningpathall"
 
 ## Debug configuration
 
-Set up an Arm Development Studio **debug configuration** for the Zena CSS FVP using the Iris interface. This page shows a fast, reliable path to a working configuration.
+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.
 
 As of Arm Development Studio 2025.0, there is no out-of-the-box configuration for the Zena CSS FVP. Creating one, however, is straightforward.
 
@@ -23,33 +23,33 @@ Launch the FVP with the Iris server enabled:
 ```bash
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- --iris-server --iris-port 7100"
 ```
-or if connecting to the FVP remotely:
+If connecting to the FVP remotely, you can use this command:
 
 ```bash
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- --iris-server --iris-port 7100 -A"
 ```
 
 {{% notice Note %}}
-This Learning Path assumes a **local** connection for the remaining steps.
+This example modeled below uses a local connection for the remaining steps.
 {{% /notice %}}
 
 ## Create a configuration database in Arm Development Studio
 
-Debug configurations are stored in a **configuration database**. Create a local database to store your model configuration:
+Debug configurations are stored in a configuration database. Create a local database to store your model configuration:
 
-- In Arm Development Studio, go to **File > New > Other**
-- Select **Configuration Database > Configuration Database**
-- Click **Next**, enter a **Name**, then click **Finish**
+- In Arm Development Studio, go to **File > New > Other**.
+- Select **Configuration Database > Configuration Database**.
+- Click **Next**, enter a **Name**, then click **Finish**.
 
 ## Create a model configuration for Zena CSS FVP (Iris)
 
-- Open the same wizard (**File > New > Other**), then choose **Configuration Database > Model Configuration**
-- Click **Next**, select the **Configuration Database** you created, then click **Next**
-- For **Model Interface**, choose **Iris**, then click **Next**
-- Choose **Browse for model running on local host**. The debugger detects and interrogates the FVP  
-- If connecting remotely, choose **Connect to model running on either local or remote host** and provide the host and port
+- Open the same wizard (**File > New > Other**), then choose **Configuration Database > Model Configuration**.
+- Click **Next**, select the **Configuration Database** you created, then click **Next**.
+- For **Model Interface**, choose **Iris**, then click **Next**.
+- Choose **Browse for model running on local host**. The debugger detects and interrogates the FVP.  
+- If connecting remotely, choose **Connect to model running on either local or remote host** and provide the host and port.
 
-Arm Development Studio generates a **model.mdf** file that enumerates all CPUs in the FVP.
+Arm Development Studio generates a `model.mdf` file that enumerates all CPUs in the FVP.
 
 Optionally, update **Manufacturer Name** (for example, `Arm`) and **Platform Name** (for example, `Zena_CSS_FVP`). Then **Save** and **Import** the model into the configuration database.
 
@@ -59,6 +59,6 @@ If the FVP is not detected, verify the Iris server is running on the expected po
 
 A `model.mdf` file will be created that identifies all CPUs within the FVP.
 
-You can change the `Manufacturer Name` and `Platform Name` to something more meaningful (such as `Arm` and `Zena_CSS_FVP`), then `Save`, and `Import` into the configuration database.
+You can change the **Manufacturer Name** and **Platform Name** to something more meaningful (such as `Arm` and `Zena_CSS_FVP`), then **Save**, and **Import** into the configuration database.
 
 The debugger is now aware of the FVP and you are ready to debug.
diff --git a/content/learning-paths/automotive/zenacssdebug/connect.md b/content/learning-paths/automotive/zenacssdebug/connect.md
@@ -12,77 +12,79 @@ layout: "learningpathall"
 
 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.
 
-Arm Development Studio has full support for Heterogeneous systems such as Zena CSS, and so you can connect to all processors simultaneously.
+Arm Development Studio has full support for heterogeneous systems such as Zena CSS, and so you can connect to all processors simultaneously.
 
-## Debug connection project
+## Create a project for connection files
 
-First, create a project to store these connections (`.launch` files) in.
+First, create a project to store these connections (`.launch` files).
 
-Select **File** > **New...** > **Project** > **General** > **Project**, and give it a meaningful name (`Connections`).
+Select **File** > **New...** > **Project** > **General** > **Project**, and give it a meaningful name (for example, `Connections`).
 
-## RSE (Cortex-M55)
+## Create an RSE (Cortex-M55) model connection
 
-Runtime Security Engine (RSE) is based on [Cortex-M55](https://developer.arm.com/Processors/Cortex-M55) core and is a security subsystem fulfilling the role of Root of Trust.
+Runtime Security Engine (RSE) is based on the [Cortex-M55](https://developer.arm.com/Processors/Cortex-M55) core and is a security subsystem fulfilling the role of Root of Trust.
 
 Select **File** > **New** > **Model Connection**.
 
 {{% notice Note %}}
-You can also use **File** > **New** > **Other** > **Arm Debugger** > **Model Connection**, or **Create a debug connection**...` shortcut in the **Debug Control** pane.
+You can also use **File** > **New** > **Other** > **Arm Debugger** > **Model Connection**, or the **Create a debug connection**... shortcut in the **Debug Control** pane.
 {{% /notice %}}
 
-Specify a connection name (`RSE`), and associate with the above `Connections` project. Click `Next`.
+Specify a connection name (`RSE`), and associate with the above `Connections` project. Click **Next**.
 
-Locate the FVP based on the name you gave it previously (`Zena_CSS_FVP`). The text filter can help you locate it easily.
+Locate the FVP based on the name you gave it previously (`Zena_CSS_FVP`). You can use the text filter to locate it quickly.
 
-You will then be presented with the `Edit configuration` pane. In the `Connection` tab, scroll down to locate `Bare Metal Debug` > `Arm_Cortex-M55`.
+You will then be presented with the **Edit configuration** pane. In the **Connection** tab, scroll down to locate **Bare Metal Debug** > **Arm_Cortex-M55**.
 
-As you will be later launching the FVP with the software stack loaded, select `Connect to an already running model`.
+As you will be later launching the FVP with the software stack loaded, select **Connect to an already running model**.
 
-Assuming the same host will be running both the FVP and the debugger, specify the `Connection address` as the default `127.0.0.1:7100`.
+Assuming the same host will be running both the FVP and the debugger, specify the **Connection address** as the default `127.0.0.1:7100`.
 
 {{% notice Note %}}
 `127.0.0.1` is the same as `localhost`, which targets the host running the FVP. For a remote FVP, specify the remote IP address and start the FVP with `-A`. Port `7100` is the default Iris port and can be adjusted if needed.
 {{% /notice %}}
 
-Arm Development Studio creates **RSE.launch** inside the **Connections** project.
+Arm Development Studio creates `RSE.launch` inside the **Connections** project.
 
-## Safety Island (Cortex-R82AE)
+## Create a Safety Island (Cortex-R82AE) model connection
 
 The Safety Island is based on the [Cortex-R82AE](https://developer.arm.com/Processors/Cortex-R82AE) core and manages power, clocks, and CMN control.
 
 Follow the same steps as for RSE, with this change:
 
-- In **Edit configuration**, expand **Bare Metal Debug** and select **Arm_Cortex-R82AE**
+In **Edit configuration**, expand **Bare Metal Debug** and select **Arm_Cortex-R82AE**.
 
 {{% notice Tip %}}
-To save time, copy **RSE.launch** to **SI.launch** and update the CPU selection to **Arm_Cortex-R82AE**.
+To save time, copy `RSE.launch` to `SI.launch` and update the CPU selection to **Arm_Cortex-R82AE**.
 {{% /notice %}}
 
-## Primary Compute (Cortex-A720AE)
+## Create Primary compute (Cortex-A720AE) connections
 
-Primary Compute comprises four clusters intended to run a rich OS such as Linux. Each cluster has four [Cortex-A720AE](https://developer.arm.com/Processors/Cortex-A720AE) cores alongside a [DSU-120AE](https://developer.arm.com/Processors/DSU-120AE) DynamIQ Shared Unit.
+Primary compute comprises four clusters intended to run a rich OS such as Linux. Each cluster has four [Cortex-A720AE](https://developer.arm.com/Processors/Cortex-A720AE) cores alongside a [DSU-120AE](https://developer.arm.com/Processors/DSU-120AE) DynamIQ Shared Unit.
 
 You will create two connections: one for bare-metal initialization and one with Linux kernel awareness for SMP debug.
 
-## Primary init (bare metal)
+### Primary init (bare metal, CPU0 only)
 
-Create **Primary_init.launch**:
+Create `Primary_init.launch`:
 
-- Use **File > New > Model Connection**
-- Select your **Zena_CSS_FVP** model
-- In **Edit configuration**, expand **Bare Metal Debug** and select **ARM_Cortex-A720AE_0** to attach to CPU0 only. This leaves other CPUs running
+- Select **File > New > Model Connection**.
+- Select your `Zena_CSS_FVP` model.
+- In **Edit configuration**, expand **Bare Metal Debug** and select **ARM_Cortex-A720AE_0** to attach to CPU0 only. This leaves other CPUs running.
 
-#### Primary Linux (kernel awareness, SMP)
+### Primary Linux (SMP, OS awareness)
 
 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
+- 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
 
 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 %}}
diff --git a/content/learning-paths/automotive/zenacssdebug/launch.md b/content/learning-paths/automotive/zenacssdebug/launch.md
@@ -1,26 +1,26 @@
 ---
 # User change
-title: "Launch FVP"
+title: "Launch the FVP"
 
 weight: 3 # 1 is first, 2 is second, etc.
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
 
-## Launch the FVP
+## Start the FVP from the build environment
 
 You can launch the FVP within the build environment with the software stack loaded:
 
 ```command
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose"
 ```
 
-See the [documentation](https://arm-auto-solutions.docs.arm.com/en/v2.0/rd-aspen/user_guide/reproduce.html#run-the-fvp) for details.
+See the [Arm Zena CSS User Guide](https://arm-auto-solutions.docs.arm.com/en/v2.0/rd-aspen/user_guide/reproduce.html#run-the-fvp) for further information.
 
 While you can continue to use this method during debugging, it does not enable the Iris debug server in the model, so the system cannot be debugged from Arm Development Studio. Additional command-line options are required.
 
-You will use the following options (see `FVP_RD_Aspen --help` for the full list). **Options are case-sensitive.**
+You will use the following options (see `FVP_RD_Aspen --help` for the full list). Options are case-sensitive.
 
 | Option                  | Alias | Notes                                                 |
 |-------------------------|:-----:|-------------------------------------------------------|
@@ -29,25 +29,25 @@ You will use the following options (see `FVP_RD_Aspen --help` for the full list)
 | `--run`                 | `-R`  | Run the simulation when the debug server starts       |
 | `--iris-allow-remote`   | `-A`  | Allow remote connections (only if required)           |
 
-## Launch the FVP with additional options
+## Enable the Iris debug server for Arm Development Studio
 
 Append `--` to pass model options through `runfvp`.
 
-**Start the model with the debug server and hold at reset:**
+Start the model with the debug server and hold at reset:
 ```command
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- --iris-server --iris-port 7100"
 ```
 
-Start the model with the debug server and begin execution (so boot can progress):
+Start the model with the debug server and begin execution so that boot can progress:
 ```command
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- --iris-server --iris-port 7100 --run"
 ```
 
-Allow remote debug connections (only if needed), using option aliases:
+If required, allow remote debug connections using option aliases:
 ```command
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- -I -A --iris-port 7100"
 ```
 
 {{% notice Note %}}
-Specify the Iris port explicitly (even when using the default) so it matches your debugger connection settings. If you enable remote connections, ensure your firewall allows inbound access to the chosen port.
+Even when using the default, specify the Iris port explicitly so it matches your debugger connection settings. If you enable remote connections, ensure your firewall allows inbound access to the chosen port.
 {{% /notice %}}
diff --git a/content/learning-paths/automotive/zenacssdebug/primarycompute.md b/content/learning-paths/automotive/zenacssdebug/primarycompute.md
@@ -7,7 +7,6 @@ weight: 8 # 1 is first, 2 is second, etc.
 # Do not modify these elements
 layout: "learningpathall"
 ---
-
 ## Debug Primary Compute
 
 The Primary Compute application processors (`Cortex-A720AE`) are the final processors to be enabled.
@@ -16,11 +15,11 @@ As before, you can connect whilst powered down and monitor the point that they a
 
 You can debug the initialization code and the final Linux Operating System (OS) threads.
 
-### Connect debugger to target
+## Connect debugger to target
 
 Use the following debugger commands in the `Primary_init.launch` to load the symbols for the `BL2` initialization code, setting a breakpoint at `bl2_entrypoint`.
 
-Note that an address "offset" is used to specify the exception level that the image is relevant to. If the processor changes exception level, the debug information would need to also be loaded to the corresponding EL address space.
+Note that an address offset is used to specify the Exception Level (EL) that the image is relevant to. If the processor changes Exception Level, the debug information would need to also be loaded to the corresponding EL address space.
 
 For example the processors start in `EL3` and move to `EL2N` when the Linux kernel is enabled.
 
@@ -29,43 +28,52 @@ stop
 add-symbol-file /arm-auto-solutions/build/tmp_baremetal/work/fvp_rd_aspen-poky-linux/trusted-firmware-a/2.11.0+git/image/firmware/bl2.elf EL3:0x0
 tbreak bl2_entrypoint
 ```
+
 {{% notice Note %}}
-Exact paths may differ for your set up.
+Exact paths might differ depending on your build output.
 {{% /notice %}}
 
-Run the code to the `bl2_entrypoint` and you can debug as expected.
+Run to **bl2_entrypoint** and step through as required.
 
-### Debug Linux kernel modules
+{{% notice Tip %}}
+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 %}}
 
-To make use of the OS awareness feature, disconnect `Primary_init` and connect to `Primary_Linux` as created previously. Load the symbols from the `vmlinux` image.
+## Debug the Linux kernel with OS awareness (SMP)
 
-``` text
+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:
+
+```text
 stop
 add-symbol-file /arm-auto-solutions/build/tmp_baremetal/work/fvp_rd_aspen-poky-linux/linux-yocto/6.6.54+git/linux-fvp_rd_aspen-standard-build/vmlinux EL2N:0x0
 set substitute-path /usr/src/kernel/ /arm-auto-solutions/build/tmp_baremetal/work-shared/fvp-rd-aspen/kernel-source/
 ```
+
 Run the FVP until the OS prompt appears.
 
 {{% notice %}}
-If you are only interested in kernel debug, modify the launch command for the FVP to include `--run` to start execution immediately.
+If you only need kernel debugging, start the model with the debug server **and** begin execution immediately by adding `--run`:
 
-``` command
+```command
 kas shell -c "../layers/meta-arm/scripts/runfvp -t tmux --verbose -- --iris-server --iris-port 7100 --run"
 ```
 {{% /notice %}}
 
-You can now enable the `Threads` view in the `Debug Control` pane.
+## View Linux threads with OS awareness
 
-Right-click on the connection, and select `Display Threads`. You can also do this by entering `thread` in the `Command` pane.
+Enable the **Threads** view to inspect kernel threads instead of raw CPUs:
 
-The view will then change from listing the 16 application processors to the OS threads.
+In **Debug Control**, right-click the **Primary_Linux** connection and select **Display Threads**
+2. Alternatively, enter `thread` in the **Command** pane.
+
+The view changes from listing the 16 application processors to the active OS threads.
 
 {{% notice Note %}}
-A warning of the form:
-``` text
+You might see a warning like:
+```text
 WARNING(ROS60): Could not enable OS support as the OS does not appear to be initialized. This might be caused by a mismatch between the loaded symbols and the code on the target or because the OS is not up and running. Enabling OS support will be re-attempted when the target next stops.
 ```
-may be emitted if the OS is not booted when you connect. It can safely be ignored.
+This occurs if the OS has not completed boot when you connect; it is safe to ignore and will clear after the next target stop.
 {{% /notice %}}
 
 You have successfully learnt how to use Arm Development Studio to explore and debug the Arm Zena CSS Reference Software Stack.
diff --git a/content/learning-paths/automotive/zenacssdebug/rse.md b/content/learning-paths/automotive/zenacssdebug/rse.md
diff --git a/content/learning-paths/automotive/zenacssdebug/zena.md b/content/learning-paths/automotive/zenacssdebug/zena.md
