1 files changed, 160 insertions, 64 deletions

diff --git a/docs/README.booting.zynqmp.md b/docs/README.booting.zynqmp.md
index c8f8aa21..44e6f2b7 100644
--- a/docs/README.booting.zynqmp.md
+++ b/docs/README.booting.zynqmp.md
@@ -5,10 +5,15 @@ NAND boot modes.
 
 * [Setting Up the Target](#setting-up-the-target)
 * [Booting from JTAG](#booting-from-jtag)
-  * [Loading boot components using XSCT](#loading-boot-components-using-xsct)
-  * [Loading Kernel, Root Filesystem and U-boot boot script](#loading-kernel-root-filesystem-and-u-boot-boot-script)
-    * [Using XSCT](#using-xsct)
-    * [Using TFTP](#using-tftp)
+  * [Sourcing the XSDB tools](#sourcing-the-xsdb-tools)
+  * [Deploying the images to target](#deploying-the-images-to-target)
+    * [Using devtool boot-jtag script](#using-devtool-boot-jtag-script)
+    * [Manually executing xsdb commands](#manually-executing-xsdb-commands)
+      * [Loading boot components using XSDB](#loading-boot-components-using-xsdb)
+      * [Loading Kernel, Root Filesystem and U-boot boot script](#loading-kernel-root-filesystem-and-u-boot-boot-script)
+        * [Using XSDB](#using-xsdb)
+        * [Using TFTP](#using-tftp)
+      * [Booting Linux](#booting-linux)
 * [Booting from SD](#booting-from-sd)
 * [Booting from QSPI](#booting-from-qspi)
 
@@ -34,37 +39,61 @@ NAND boot modes.
 
 ## Booting from JTAG
 
-This boot flow requires the use of the AMD Xilinx tools, specifically XSCT and 
+This boot flow requires the use of the AMD Xilinx tools, specifically XSDB and
 the associated JTAG device drivers. This also requires access to the JTAG interface
 on the board, a number of AMD Xilinx and third-party boards come with on-board JTAG
 modules.
 
-1. Source the Vivado or Vitis tools `settings.sh` scripts.
-2. Power on the board, Open the XSCT console in the Vitis IDE by clicking the
-   XSCT button. Alternatively, you can also open the XSCT console by selecting
-   Xilinx -> XSCT Console.
+### Sourcing the XSDB tools
+
+Source the Vivado or Vitis tools `settings.sh` scripts.
+
+### Deploying the images to target
+
+Deploying the images can be done in two methods.
+
+#### Using devtool boot-jtag script
+
+> **Note:** For Xen boot flow boot-jtag script doesn't include loading xen, kernel
+> and root filesystem, This step needs to be done manually as mentioned in XSDB
+> or TFTP method below.
+
+1. Run devtool command to generate the boot-jtag.tcl script.
+```
+$ devtool boot-jtag --help
+$ devtool boot-jtag --image core-image-minimal --hw_server TCP:<hostname/ip-addr>:3121
 ```
-$ xsct
+2. Script will be generated under ${DEPLOY_DIR_IMAGE}/boot-jtag.tcl
+3. Execute this script using xsdb tool as shown below.
 ```
-3. In the XSCT console, connect to the target over JTAG using the connect command.
+$ xsdb <absolute-path-to-deploy-dir-image>/boot-jtag.tcl
+```
+
+#### Manually executing xsdb commands
+
+1. Power on the board, Launch the XSDB shell from command line as shown below.
+```
+$ xsdb
+```
+2. In the XSDB console, connect to the target over JTAG using the connect command.
    Optionally user can use `-url` to specify the local/remote hw_server. The 
    connect command returns the channel ID of the connection.
 ```
-xsct% connect
+xsdb% connect
 ```
-4. The targets command lists the available targets and allows you to select a
+3. The targets command lists the available targets and allows you to select a
    target using its ID. The targets are assigned IDs as they are discovered on
    the JTAG chain, so the IDs can change from session to session.
 ```
-xsct% targets
+xsdb% targets
 ```
 
 > **Note:** For non-interactive usage such as scripting, you can use the `-filter`
    option to select a target instead of selecting the target using its ID.
 
-### Loading boot components using XSCT
+##### Loading boot components using XSDB
 
-1. Download the boot images for the target using XSCT with the `fpga` and `dow` 
+1. Download the boot images for the target using XSDB with the `fpga` and `dow`
    command. ZyqnMP boot images will be located in the `${DEPLOY_DIR_IMAGE}`
    directory. 
 
@@ -73,43 +102,46 @@ xsct% targets
 
 2. Program the bitstream or skip this step if you are loading from u-boot or linux.
 ```
-xsct% fpga -no-revision-check ${DEPLOY_DIR_IMAGE}/download.bit
+xsdb% fpga -no-revision-check ${DEPLOY_DIR_IMAGE}/download.bit
 ```
 3. By default, JTAG security gates are enabled. Disable the security gates for 
    DAP, PL TAP, and PMU (this makes the PMU MB target visible to the debugger).
 ```
-xsct% targets -set -nocase -filter {name =~ "*PSU*"}
-xsct% mask_write 0xFFCA0038 0x1C0 0x1C0
+xsdb% targets -set -nocase -filter {name =~ "*PSU*"}
+xsdb% mask_write 0xFFCA0038 0x1C0 0x1C0
 ```
 3. Verify if the PMU MB target is listed under the PMU device. Now, load the PMU
    firmware.
 ```
-xsct% targets -set -nocase -filter {name =~ "*MicroBlaze PMU*"}
-xsct% catch {stop}
-xsct% dow ${DEPLOY_DIR_IMAGE}/pmufw.elf
-xsct% con
+xsdb% targets -set -nocase -filter {name =~ "*MicroBlaze PMU*"}
+xsdb% catch {stop}
+xsdb% dow ${DEPLOY_DIR_IMAGE}/pmufw.elf
+xsdb% con
 ```
 5. Reset APU Cortex-A53 Core 0 to load and execute FSBL, This step is important, 
    because when the ZynqMP boots up in JTAG boot mode, all the APU and RPU cores
    are held in reset. You must clear the resets on each core before performing 
-   debugging on these cores. You can use the `rst` command in XSCT to clear the
+   debugging on these cores. You can use the `rst` command in XSDB to clear the
    resets.
 ```
-xsct% targets -set -nocase -filter {name =~ "*A53*#0"}
-xsct% rst -processor -clear-registers
+xsdb% targets -set -nocase -filter {name =~ "*A53*#0"}
+xsdb% rst -processor -clear-registers
 ```
 6. Download and run FSBL from APU Cortex-A53 Core 0
 ```
-xsct% dow ${DEPLOY_DIR_IMAGE}/zynqmp_fsbl.elf
-xsct% con
+xsdb% dow ${DEPLOY_DIR_IMAGE}/zynqmp_fsbl.elf
+xsdb% con
 ```
-7. Now download TF-A, U-boot.elf and Device tree to APU and execute.
+7. Now download TF-A, U-boot.elf and Device tree blob to APU and execute.
+
+> **Note:** For Xen boot system.dtb load address will vary, see below table.
+
 ```
-xsct% stop
-xsct% dow ${DEPLOY_DIR_IMAGE}/bl31.elf
-xsct% dow ${DEPLOY_DIR_IMAGE}/u-boot.elf
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/system.dtb 0x100000
-xsct% con
+xsdb% stop
+xsdb% dow ${DEPLOY_DIR_IMAGE}/bl31.elf
+xsdb% dow ${DEPLOY_DIR_IMAGE}/u-boot.elf
+xsdb% dow -data ${DEPLOY_DIR_IMAGE}/system.dtb 0x100000
+xsdb% con
 ```
 
 8. In the target Serial Terminal, press any key to stop the U-Boot auto-boot.
@@ -119,20 +151,37 @@ Hit any key to stop autoboot: 0
 U-Boot>
 ```
 
-### Loading Kernel, Root Filesystem and U-boot boot script
+##### Loading Kernel, Root Filesystem and U-boot boot script
 
 Load the images into the target DDR/PL DRR load address i.e.,
 `DDR base address + <image_offset>`. 
 
 Below example uses base DDR address as 0x0 which matches in vivado address editor.
 
+1. **Linux**
+
 | Image Type         | Base DDR Address | Image Offset | Load Address in DDR |
 |--------------------|------------------|--------------|---------------------|
-| Kernel             | 0x0              | 0x200000     | 0x200000            |
-| Device Tree        | 0x0              | 0x1000       | 0x1000              |
+| Linux Kernel       | 0x0              | 0x200000     | 0x200000            |
+| Device Tree Blob   | 0x0              | 0x100000     | 0x100000            |
 | Rootfs             | 0x0              | 0x04000000   | 0x4000000           |
 | U-boot boot script | 0x0              | 0x20000000   | 0x20000000          |
 
+2. **Xen**
+
+> **Note:** Xen, Rootfs and Device Tree image offset is calculated as shown below.
+> * `Xen Rootfs = Base DDR Address + Linux Kernel Image Offset(0xE00000) + Size of Linux Kernel Image`
+> * `Xen Kernel = Base DDR Address + Xen Rootfs Image Offset (Ex: 0x2600000) + Size of Xen Rootfs`
+> * `Device Tree Blob = Base DDR Address + Xen Kernel Image Offset (Ex: 0xBA00000) + Size of Device Tree Blob`
+
+| Image Type         | Base DDR Address | Image Offset | Load Address in DDR |
+|--------------------|------------------|--------------|---------------------|
+| Linux Kernel       | 0x0              | 0xE00000     | 0xE00000            |
+| Xen Rootfs         | 0x0              | 0x2600000    | 0x2600000           |
+| Xen Kernel         | 0x0              | 0xBA00000    | 0xBA00000           |
+| Device Tree Blob   | 0x0              | 0xC000000    | 0xC000000           |
+| U-boot boot script | 0x0              | 0x20000000   | 0x20000000          |
+
 > **Note:** 
 > 1. `<target-image>` refers to core-image-minimal or petalinux-image-minimal
 > 2. For pxeboot boot create a symlink for `<target-image>-${MACHINE}-${DATETIME}.cpio.gz.u-boot`
@@ -145,54 +194,101 @@ using U-Boot.
 > 4. If common ${DEPLOY_DIR_IMAGE}/system.dtb is used by u-boot and kernel, this
 > is already part of boot.bin we can skip loading dtb, else load kernel dtb.
 
-#### Using XSCT
+###### Using XSDB
 
-1. Suspend the execution of active target using `stop` command in XSCT.
+1. Suspend the execution of active target using `stop` command in XSDB.
 ```
-xsct% stop
+xsdb% stop
 ```
 2. Using the `dow` command to load the images into the target DDR/PL DDR load 
    address.
-```
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/Image 0x200000
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/system.dtb 0x100000
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/core-image-minimal-${MACHINE}.cpio.gz.u-boot 0x4000000
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/boot.scr 0x20000000
-```
 
-#### Using TFTP
+   * Linux XSDB
+   ```
+   xsdb% targets -set -nocase -filter {name =~ "*A53*#0"}
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/Image 0x200000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/system.dtb 0x100000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/core-image-minimal-${MACHINE}.cpio.gz.u-boot 0x4000000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/boot.scr 0x20000000
+   ```
 
-1. Configure the `ipaddr` and `serverip` of the U-Boot environment. 
-```
-Versal> set serverip <server ip>
-Versal> set ipaddr <board ip>
+   * Xen XSDB
+   ```
+   xsdb% targets -set -nocase -filter {name =~ "*A53*#0"}
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/Image 0xE00000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/core-image-minimal-${MACHINE}.cpio.gz 0x2600000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/xen 0xBA00000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/system.dtb 0xC000000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/boot.scr 0x20000000
+   ```
+
+###### Using TFTP
+
+1. Setup TFTP directory on host machine and copy the images to your TFTP directory
+   so that you can load them from U-Boot.
+2. Configure the `ipaddr` and `serverip` of the U-Boot environment.
 ```
-2. Load the images to DDR address. Make sure images are copied to tftp directory.
+ZynqMP> set serverip <host-server-ip-address>
+ZynqMP> set ipaddr <board-ip-address>
 ```
-U-Boot> tftpboot 0x200000 ${TFTPDIR}/Image
-U-Boot> tftpboot 0x100000 ${TFTPDIR}/system.dtb
-U-Boot> tftpboot 0x4000000 ${TFTPDIR}/core-image-minimal-${MACHINE}.cpio.gz.u-boot
-U-Boot> tftpboot 0x20000000 ${TFTPDIR}/boot.scr
+3. Load the images to DDR address.
 
-```
-### Booting Linux
+   * Linux TFTP
+   ```
+   U-Boot> tftpboot 0x200000 Image
+   U-Boot> tftpboot 0x100000 system.dtb
+   U-Boot> tftpboot 0x4000000 core-image-minimal-${MACHINE}.cpio.gz.u-boot
+   U-Boot> tftpboot 0x20000000 boot.scr
+   ```
+
+   * Xen TFTP
+   ```
+   U-Boot> tftpboot 0xE00000 Image
+   U-Boot> setenv kernel_size 0x$filesize
+   U-Boot> tftpboot 0x2600000 core-image-minimal-${MACHINE}.cpio.gz
+   U-Boot> setenv ramdisk_size 0x$filesize
+   U-Boot> tftpboot 0xBA00000 xen
+   U-Boot> tftpboot 0xC000000 system.dtb
+   U-Boot> tftpboot 0x20000000 boot.scr
+   ```
+
+##### Booting Linux
 
 Once the images are loaded continue the execution.
 
 1. After loading images resume the execution of active target using the `con`
-command in XSCT shell, Skip step 1 for if you have used TFTP to load images.
+command in XSDB shell, Skip step 1 for if you have used TFTP to load images.
 ```
-xsct% con
+xsdb% con
 ```
-2. Terminate xsct shell.
+2. Terminate xsdb shell.
 ```
-xsct% exit
+xsdb% exit
 ```
 3. In the target Serial Terminal, from U-Boot prompt run `boot` command.
+
+* Linux boot
 ```
 U-Boot> boot
 ```
 
+* XEN JTAG boot
+
+   * XSDB
+   > **Note:** You need to calculate the Kernel(kernel_size) and ramdisk(ramdisk_size)
+   > image size manually from `${DEPLOY_DIR_IMAGE}` directory. For example if your
+   > kernel size is 24269312 bytes you need to convert to hex 0x1725200 and use it.
+   ```
+   U-Boot> setenv kernel_size <filesize>
+   U-Boot> setenv ramdisk_size <filesize>
+   U-Boot> boot
+   ```
+
+   * TFTP
+   ```
+   U-Boot> boot
+   ```
+
 ## Booting from SD
 
 1. Load the SD card into the ZCU102 board in the J100 SD slot.
@@ -204,9 +300,9 @@ U-Boot> boot
 
 1. To boot ZCU012 board in QSPI boot mode, Power on the ZCU102 board and boot 
    using JTAG or SD boot mode, to ensure that U-Boot is running and also have 
-   boot.bin copied to DDR location using XSCT `dow` or `tftpboot` or `fatload`
+   boot.bin copied to DDR location using XSDB `dow` or `tftpboot` or `fatload`
    command.
 2. Follow Flash boot instructions [README](README.booting.flash.md) for more details.
 3. After flashing the images, turn off the power switch on the board, and change
    the SW6 boot mode pin settings to QSPI boot mode (1-ON, 2-ON, 3-OFF, 4-ON) by
-   setting the SW6. Refer [Setting Up the Target](#setting-up-the-target).
\ No newline at end of file
+   setting the SW6. Refer [Setting Up the Target](#setting-up-the-target).