Fix formatting in documentation for out-of-tree kernel module setup and profiling, enhancing clarity in command syntax and instructions.

Author: madeline-underwood

content/learning-paths/embedded-and-microcontrollers/streamline-kernel-module/3_oot_module.md

@@ -214,7 +214,7 @@ Transfer the kernel module (`mychardrv.ko`) to your target device using the `scp
     scp mychardrv.ko root@<target-ip>:/root/
 ```
 
-{{% notice Note %}} Replace \<target-ip> with your target's IP address
+{{% notice Note %}} Replace `<target-ip>` with your target's IP address
 {{% /notice %}}
 
 SSH onto your target device:

content/learning-paths/embedded-and-microcontrollers/streamline-kernel-module/4_sl_profile_oot.md

@@ -28,7 +28,7 @@ Once Streamline is installed on the host machine, you can capture trace data of
 To communicate with the target, Streamline requires a daemon, called **gatord**, to be installed and running on the target. gatord must be running before you can capture trace data. There are two pre-built gatord binaries available in Streamline's install directory, one for *Armv7 (AArch32)* and one for *Armv8 or later(AArch64)*. Push **gatord** to the target device using **scp**.
 
 ```bash
-scp <install_directory>/streamline/bin/linux/arm64/gatord root@<target-ip>:/root/gatord
+scp `<install_directory>`/streamline/bin/linux/arm64/gatord root@<target-ip>:/root/gatord
 ```
 
 {{% notice Note %}}
@@ -54,14 +54,14 @@ Select **Select counters** to open the counter configuration dialogue.
 Add `L1 data Cache: Refill` and `L1 Data Cache: Access` and enable Event-Based Sampling (EBS) for both of them as shown in the screenshot and select **Save**.
 
 {{% notice Further reading %}}
-To learn more about counters and how to configure them please refer to [counter configuration guide](https://developer.arm.com/documentation/101816/latest/Capture-a-Streamline-profile/Counter-Configuration)
+To learn more about counters, see the Arm Developer [Counter Configuration Guide](https://developer.arm.com/documentation/101816/latest/Capture-a-Streamline-profile/Counter-Configuration).
 
-To learn more about EBS, please refer to [Streamline user guide](https://developer.arm.com/documentation/101816/9-7/Capture-a-Streamline-profile/Counter-Configuration/Setting-up-event-based-sampling)
+To learn more about EBS, see the [Streamline User Guide](https://developer.arm.com/documentation/101816/9-7/Capture-a-Streamline-profile/Counter-Configuration/Setting-up-event-based-sampling).
   {{% /notice %}}
 
 ![Streamline counter configuration dialog showing two counters, L1 data Cache Refill and L1 Data Cache Access, both enabled with Event-Based Sampling selected. The dialog includes checkboxes and dropdown menus for configuring counters. The wider environment is a desktop application window focused on performance profiling setup. Text in the image includes labels for the counters and options for enabling EBS. The emotional tone is neutral and technical, supporting a step-by-step configuration process for Arm performance analysis. alt-text#center](./images/img03_counter_config.png "Configure counters and enable event-based sampling")
 
-In the **Command** section, add the same shell command you used earlier to test our Linux module.
+In the **Command** section, add the same shell command you used earlier to test our Linux module:
 
 ```bash
 sh -c "echo 10000 > /dev/mychardrv"
@@ -93,12 +93,12 @@ In the **Functions** tab, look for the function `char_dev_cache_traverse()`. You
 
 To view the call path for `char_dev_cache_traverse()`, right-click the function name and select **Select in Call Paths**.
 
-This opens the Call Paths tab, where you can trace which functions called `char_dev_cache_traverse()`. In the **Locations** column, you'll see the sequence of calls—starting from the userspace `echo` command and ending in your kernel module `mychardrv.ko`. This helps you understand how execution flows from userspace into your kernel code, making it easier to spot where performance issues might begin.
+This opens the **Call Paths** tab, where you can trace which functions called `char_dev_cache_traverse()`. In the **Locations** column, you'll see the sequence of calls—starting from the userspace `echo` command and ending in your kernel module `mychardrv.ko`. This helps you understand how execution flows from userspace into your kernel code, making it easier to spot where performance issues might begin.
 ![Streamline Call Paths tab displaying a hierarchical call stack with the function char_dev_cache_traverse highlighted. The primary subject is the call path tree, showing the sequence of function calls from userspace echo command through to the kernel module mychardrv.ko. The wider environment is a desktop profiling application window with columns labeled Function, Image, and performance counters. Visible text includes function names, image names, and numerical metric values. The emotional tone is neutral and technical, supporting detailed analysis for Arm kernel module profiling and helping users trace performance issues through the call stack. alt-text#center](./images/img09_callpaths_tab.png "Trace function call paths in Streamline")
 
 Because you compiled your kernel module with debug information, Streamline can show you exactly which lines of code are responsible for cache misses.
 
-Double-tap the function name to open the *Code* tab. The top half of this view highlights each line of your source code and shows how many cache misses it caused. The bottom half displays the disassembly for those lines, with counter values for each assembly instruction. This makes it easy to spot which parts of your code are causing performance issues.
+Double-tap the function name to open the **Code** tab. The top half of this view highlights each line of your source code and shows how many cache misses it caused. The bottom half displays the disassembly for those lines, with counter values for each assembly instruction. This makes it easy to spot which parts of your code are causing performance issues.
 ![Streamline Code tab displaying annotated source code and disassembly for the function char_dev_cache_traverse in the kernel module mychardrv.ko. The primary subject is the code analysis panel, which highlights individual lines of C source code and corresponding assembly instructions, each with associated cache miss metrics. The top half of the window shows the source code with numerical values indicating cache misses per line, while the bottom half presents the disassembly view with counter values for each instruction. The wider environment is a desktop profiling application window with labeled columns such as Function, Image, and performance counters. Visible text includes function names, source code lines, assembly instructions, and numerical metric values. The emotional tone is neutral and technical, supporting detailed analysis for Arm kernel module profiling and helping users identify performance bottlenecks at the code level. alt-text#center](./images/img10_code_tab.png "Analyze code and disassembly for cache misses in Streamline")
 
 {{% notice Note %}}