1 files changed, 144 insertions, 51 deletions

diff --git a/docs/README.booting.versal.md b/docs/README.booting.versal.md
index afdeba2b..25738784 100644
--- a/docs/README.booting.versal.md
+++ b/docs/README.booting.versal.md
@@ -5,10 +5,15 @@ modes.
 
 * [Setting Up the Target](#setting-up-the-target)
 * [Booting from JTAG](#booting-from-jtag)
-  * [Loading boot.bin using XSCT](#loading-bootbin-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.bin using XSDB](#loading-bootbin-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)
 
@@ -37,37 +42,61 @@ 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
+```
+2. Script will be generated under ${DEPLOY_DIR_IMAGE}/boot-jtag.tcl
+3. Execute this script using xsdb tool as shown below.
 ```
-$ xsct
+$ xsdb <absolute-path-to-deploy-dir-image>/boot-jtag.tcl
 ```
-3. In the XSCT console, connect to the target over JTAG using the connect command.
+
+#### 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.bin using XSCT
+##### Loading boot.bin using XSDB
 
-1. Download the boot.bin for the target using XSCT with the `device program` command.
+1. Download the boot.bin for the target using XSDB with the `device program` command.
 Versal boot.bin will be located in the `${DEPLOY_DIR_IMAGE}` directory. Default
 boot.bin consists of boot pdi, plm.elf, psm.elf, bl31.elf, u-boot.elf and 
 system.dtb. This boot.bin is generated using bootgen tool by passing a .bif file.
@@ -76,15 +105,15 @@ system.dtb. This boot.bin is generated using bootgen tool by passing a .bif file
 > u-boot and kernel.
 
 ```
-xsct% targets -set -nocase -filter {name =~ "*PMC*"}
-xsct% device program ${DEPLOY_DIR_IMAGE}/boot.bin
-xsct% targets -set -nocase -filter {name =~ "*A72*#0"}
-xsct% stop
+xsdb% targets -set -nocase -filter {name =~ "*PMC*"}
+xsdb% device program ${DEPLOY_DIR_IMAGE}/boot.bin
+xsdb% targets -set -nocase -filter {name =~ "*A72*#0"}
+xsdb% stop
 ```
 2. After loading boot.bin resume the execution of active target using the `con`
-command in XSCT shell.
+command in XSDB shell.
 ```
-xsct% con
+xsdb% con
 ```
 3. In the target Serial Terminal, press any key to stop the U-Boot auto-boot.
 ```
@@ -93,20 +122,38 @@ 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              | 0x1000       | 0x1000              |
 | Rootfs             | 0x0              | 0x4000000    | 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`
@@ -119,55 +166,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 0x1000
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/core-image-minimal-${MACHINE}.cpio.gz.u-boot 0x4000000
-xsct% dow -data ${DEPLOY_DIR_IMAGE}/boot.scr 0x20000000
-xsct% targets -set -nocase -filter {name =~ "*A72*#0"}
-```
 
-#### Using TFTP
+   * Linux XSDB
+   ```
+   xsdb% targets -set -nocase -filter {name =~ "*A72*#0"}
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/Image 0x200000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/system.dtb 0x1000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/core-image-minimal-${MACHINE}.cpio.gz.u-boot 0x4000000
+   xsdb% dow -data ${DEPLOY_DIR_IMAGE}/boot.scr 0x20000000
+   ```
+
+   * Xen XSDB
+   ```
+   xsdb% targets -set -nocase -filter {name =~ "*A72*#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. Configure the `ipaddr` and `serverip` of the U-Boot environment. 
+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.
 ```
 Versal> set serverip <server ip>
 Versal> set ipaddr <board ip>
 ```
-2. Load the images to DDR address. Make sure images are copied to tftp directory.
-```
-U-Boot> tftpboot 0x200000 ${TFTPDIR}/Image
-U-Boot> tftpboot 0x1000 ${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 0x1000 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 VCK190 board in the J302 SD slot.
@@ -181,9 +274,9 @@ U-Boot> boot
    card (part number: X_EBM-01, REV_A01).
 2. With the card powered off, install the QSPI daughter card.
 3. Power on the VCK190 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
+   U-Boot is running and also have boot.bin copied to DDR location using XSDB
    `dow` or `tftpboot` or `fatload` command.
 4. Follow Flash boot instructions [README](README.booting.flash.md) for more details.
 5. After flashing the images, turn off the power switch on the board, and change
    the SW1 boot mode pin settings to QSPI boot mode (1-ON, 2-OFF, 3-ON, 4-ON) by
-   setting the SW1. Refer [Setting Up the Target](#setting-up-the-target).
\ No newline at end of file
+   setting the SW1. Refer [Setting Up the Target](#setting-up-the-target).