• Stars
    star
    172
  • Rank 216,821 (Top 5 %)
  • Language
    C
  • Created about 9 years ago
  • Updated 8 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Xilinx Virtual Cable (XVC) is a TCP/IP-based protocol that acts like a JTAG cable and provides a means to access and debug your FPGA or SoC design without using a physical cable.

XilinxVirtualCable

Description: Xilinx Virtual Cable (XVC) is a TCP/IP-based protocol that acts like a JTAG cable and provides a means to access and debug your FPGA or SoC design without using a physical cable.

This capability helps facilitate hardware debug for designs that:

  • Have the FPGA in a hard-to-access location, where a "lab-PC" is not close by
  • Do not have direct access to the FPGA pins โ€“ e.g. the JTAG pins are only accessible via a local processor interface
  • Need to efficiently debug Xilinx FPGA or SoC systems deployed in the field to save on costly or impractical travel and reduce the time it takes to debug a remotely located system.

Key Features & Benefits

  • Ability to debug a system over an internal network, or even the internet.
  • Debug via Vivado Logic Analyzer IDE exactly as if directly connected to design via standard JTAG or parallel cable
  • Zynqยฎ-7000 demonstration with Application Note and Reference Designs available in XAPP1251 - Xilinx Virtual Cable Running on Zynq-7000 Using the PetaLinux Tools
  • Extensible to allow for safe, secure connections

Directory layout

โ”œโ”€โ”€ versal                   # XVC 1.1 source code for Versal SoC devices
โ”œโ”€โ”€ zynq7000                 # XVC 1.0 source code for Zynq-7000 SoC devices
โ”œโ”€โ”€ zynqMP                   # XVC 1.0 source code for Zynq-Ultrascale+ SoC devices
โ””โ”€โ”€ README.md

XVC 1.0 Protocol

XVC 1.0 Protocol 
Copyright 2015-2021 Xilinx, Inc.  All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Overview

Xilinx Virtual Cable (XVC) is a TCP/IP-based communication protocol that acts like a JTAG cable and provides a means to access and debug your FPGA or SoC design without using a physical cable. In this document are the general details of this XVC 1.0 protocol. For source code examples of this protocol please visit:

https://github.com/Xilinx/XilinxVirtualCable

The XVC protocol is used by a TCP/IP client and server to transfer low level JTAG vectors from a high level application to a device. The client, for instance Xilinx's EDA tools, will connect to an XVC server using standard TCP/IP client/server connection methods. Once connected, the client will issue an XVC message (getinfo:) to the server requesting the server version. After the client validates the protocol version, a new message is sent to the XVC server to set the JTAG tck rate for future shift operations.

The shift message is the main command used between the client and the server to transfer low level JTAG vectors. The client will issue shift operations to determine the JTAG chain composition and then perform various JTAG instructions for instance driving pins or programming a device.

In summary, XVC 1.0 protocol defines a simple JTAG communication method with sufficient capabilities for high level clients, like Xilinx Vivado and SDK tools, to perform complex functions like programming and debug of devices. In this document is a basic description of the protocol. The intent of this document is to provide a blueprint for users of the XVC 1.0 protocol to create their own custom clients and servers.

Protocol

The XVC 1.0 communication protocol consists of the following three messages:

getinfo:
settck:<period in ns>
shift:<num bits><tms vector><tdi vector>

For each message the client is expected to send the message and wait for a response from the server. The server needs to process each message in the order recieved and promptly provide a response. Note that for the XVC 1.0 protocol only one connection is assumed so as to avoid interleaving locking and interleaving issues that may occur with concurrent client communication.

MESSAGE: "getinfo:"

The primary use of "getinfo:" message is to get the XVC server version. The server version provides a client a way of determining the protocol capabilites of the server.

Syntax

Client Sends:

"getinfo:"

Server Returns:

โ€œxvcServer_v1.0:<xvc_vector_len>\nโ€

Where:

<xvc_vector_len> is the max width of the vector that can be shifted 
                 into the server

MESSAGE: "settck:"

The "settck:" message configures the server TCK period. When sending JTAG vectors the TCK rate may need to be varied to accomodate cable and board signal integrity conditions. This command is used by clients to adjust the TCK rate in order to slow down or speed up the shifting of JTAG vectors.

Syntax:

Client Sends:

"settck:<set period>"

Server Returns:

โ€œ<current period>โ€

Where:

<set period>      is TCK period specified in ns. This value is a little-endian 
                  integer value.
<current period>  is the value set on the server by the settck command. If 
                  the server cannot set the value then it will return the 
                  current value.

MESSAGE: "shift:"

The "shift:" message is used to shift JTAG vectors in and out of a device. The number of bits to shift is specified as the first shift command parameter followed by the TMS and TDI data vectors. The TMS and TDI vectors are sized according to the number of bits to shift, rouneded to the nearest byte. For instance if shifting in 13 bits the byte vectors will be rounded to 2 bytes. Upon completion of the JTAG shift operation the server will return a byte sized vector containing the sampled target TDO value for each shifted TCK clock.

Syntax:

Client Sends:

"shift:<num bits><tms vector><tdi vector>"

Server Returns:

โ€œ<tdo vector>โ€

Where:

<num bits>   : is a integer in little-endian mode. This represents the number 
               of TCK clk toggles needed to shift the vectors out
<tms vector> : is a byte sized vector with all the TMS shift in bits Bit 0 in 
               Byte 0 of this vector is shifted out first. The vector is 
               num_bits and rounds up to the nearest byte.
<tdi vector> : is a byte sized vector with all the TDI shift in bits Bit 0 in 
               Byte 0 of this vector is shifted out first. The vector is 
               num_bits and rounds up to the nearest byte.
<tdo vector> : is a byte sized vector with all the TDO shift out bits Bit 0 in 
               Byte 0 of this vector is shifted out first. The vector is 
               num_bits and rounds up to the nearest byte.

XVC 1.1 Protocol

XVC 1.1 Protocol 
Copyright 2015-2021 Xilinx, Inc.  All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Overview

In addition to XVC 1.0 capabilities, XVC 1.1 supports the "mrd" and "mwr" messages which can be used to read/write debug addresses.

Protocol

The XVC 1.1 communication protocol consists of the following five messages:

getinfo:
mrd:<flags><address><num bytes>
mwr:<flags><address><num bytes><data>
settck:<period in ns>
shift:<num bits><tms vector><tdi vector>

For each message the client is expected to send the message and wait for a response from the server. The server needs to process each message in the order received and promptly provide a response. Note that for the XVC 1.1 protocol only one connection is assumed so as to avoid interleaving locking and interleaving issues that may occur with concurrent client communication.

MESSAGE: "getinfo:"

The primary use of "getinfo:" message is to get the XVC server version. The server version provides a client a way of determining the protocol capabilities of the server.

Syntax

Client Sends:

"getinfo:"

Server Returns:

โ€œxvcServer_v1.1:<xvc_vector_len>\nโ€

Where:

<xvc_vector_len> is the max width of the vector that can be shifted 
                 into the server

MESSAGE: "mrd:"

The primary use of "mrd:" message is to read an address.

Syntax

Client Sends:

"mrd:<flags><address><num bytes>"

Server Returns:

โ€œ<data><status>"

Where:

<flags> ULEB128 bit field for future flag use
<address> ULEB128 starting address for memory read
<num bytes> ULEB128 number of bytes to read
<data> byte vector of data read

MESSAGE: "mwr:"

The primary use of "mwr:" message is to write at an address.

Syntax

Client Sends:

"mwr:<flags><address><num bytes><data>"

Server Returns:

โ€œ<status>"

Where:

<flags> ULEB128 bit field for future flag use
<address> ULEB128 starting address for memory write
<num bytes> ULEB128 number of bytes to write
<data> byte vector to write

MESSAGE: "settck:"

Similar to XVC 1.0

MESSAGE: "shift:"

Similar to XVC 1.0

Note

XVC server 1.1 for Versal performs reads and writes (mrd and mwr) as multi-word transactions. On some platforms performing accesses unaligned to 64-bits addresses may throw "Bus Error". In such cases, uncomment ENABLE_SINGLE_WORD_RW definition in xvc_mem.c to perform single word (32-bits) read/write transactions.

More Repositories

1

PYNQ

Python Productivity for ZYNQ
Jupyter Notebook
1,894
star
2

Vitis-AI

Vitis AI is Xilinxโ€™s development stack for AI inference on Xilinx hardware platforms, including both edge devices and Alveo cards.
Python
1,400
star
3

linux-xlnx

The official Linux kernel from Xilinx
C
1,205
star
4

brevitas

Brevitas: neural network quantization in PyTorch
Python
1,107
star
5

Vitis-Tutorials

Vitis In-Depth Tutorials
C
891
star
6

Vitis_Libraries

Vitis Libraries
C++
818
star
7

embeddedsw

Xilinx Embedded Software (embeddedsw) Development
HTML
766
star
8

finn

Dataflow compiler for QNN inference on FPGAs
Python
679
star
9

BNN-PYNQ

Quantized Neural Networks (QNNs) on PYNQ
Jupyter Notebook
652
star
10

u-boot-xlnx

The official Xilinx u-boot repository
C
531
star
11

XRT

Run Time for AIE and FPGA based platforms
C++
529
star
12

Vitis_Accel_Examples

Vitis_Accel_Examples
Makefile
467
star
13

Vitis-HLS-Introductory-Examples

C++
420
star
14

dma_ip_drivers

Xilinx QDMA IP Drivers
C
400
star
15

HLS

Vitis HLS LLVM source code and examples
375
star
16

Vitis-AI-Tutorials

354
star
17

PYNQ_Workshop

Jupyter Notebook
354
star
18

SDAccel_Examples

SDAccel Examples
C++
350
star
19

ml-suite

Getting Started with Xilinx ML Suite
Jupyter Notebook
334
star
20

CHaiDNN

HLS based Deep Neural Network Accelerator Library for Xilinx Ultrascale+ MPSoCs
C++
315
star
21

xfopencv

C++
313
star
22

XilinxTclStore

Xilinx Tcl Store
Tcl
310
star
23

mlir-aie

An MLIR-based toolchain for AMD AI Engine-enabled devices.
MLIR
257
star
24

RapidWright

Build Customized FPGA Implementations for Vivado
Java
248
star
25

QNN-MO-PYNQ

Jupyter Notebook
234
star
26

XilinxBoardStore

Python
224
star
27

libsystemctlm-soc

SystemC/TLM-2.0 Co-simulation framework
Verilog
200
star
28

qemu

Xilinx's fork of Quick EMUlator (QEMU) with improved support and modelling for the Xilinx platforms.
C
200
star
29

DPU-PYNQ

DPU on PYNQ
Tcl
189
star
30

device-tree-xlnx

Linux device tree generator for the Xilinx SDK (Vivado > 2014.1)
Tcl
181
star
31

PYNQ-ComputerVision

Computer Vision Overlays on Pynq
Jupyter Notebook
173
star
32

finn-hlslib

Vitis HLS Library for FINN
C++
168
star
33

graffitist

Graph Transforms to Quantize and Retrain Deep Neural Nets in TensorFlow
Python
168
star
34

open-nic

AMD OpenNIC Project Overview
Shell
166
star
35

finn-examples

Dataflow QNN inference accelerator examples on FPGAs
Jupyter Notebook
163
star
36

SDSoC-Tutorials

SDSoCโ„ข (Software-Defined System-On-Chip) Environment Tutorials
C++
142
star
37

xilinx-tiny-cnn

C++
140
star
38

FPGA_as_a_Service

Go
136
star
39

xup_vitis_network_example

VNx: Vitis Network Examples
Jupyter Notebook
124
star
40

meta-xilinx

Collection of Yocto Project layers to enable AMD Xilinx products
C
123
star
41

Vitis-In-Depth-Tutorial

C++
113
star
42

systemctlm-cosim-demo

QEMU libsystemctlm-soc co-simulation demos.
C++
106
star
43

Vitis_Embedded_Platform_Source

Tcl
105
star
44

SDAccel-Tutorials

SDAccel Development Environment Tutorials
C++
101
star
45

nanotube

LLVM
101
star
46

RFNoC-HLS-NeuralNet

CMake
92
star
47

Embedded-Design-Tutorials

91
star
48

PYNQ-DL

Xilinx Deep Learning IP
VHDL
91
star
49

PYNQ-HelloWorld

This repository contains a "Hello World" introduction application to the Xilinx PYNQ framework.
Jupyter Notebook
90
star
50

LSTM-PYNQ

C++
86
star
51

Vivado-Design-Tutorials

Tcl
83
star
52

SDSoC_Examples

C++
82
star
53

Kria-PYNQ

PYNQ support and examples for Kria SOMs
Jupyter Notebook
82
star
54

meta-petalinux

meta-petalinux distro layer supporting Xilinx Tools
BitBake
82
star
55

kria-vitis-platforms

Kria KV260 Vitis platforms and overlays
SystemVerilog
81
star
56

IIoT-EDDP

The repository contains the design database and documentation for Electric Drives Demonstration Platform
VHDL
79
star
57

logicnets

Python
78
star
58

AI-Model-Zoo

75
star
59

RecoNIC

RecoNIC is a software/hardware shell used to enable network-attached processing within an RDMA-featured SmartNIC for scale-out computing.
SystemVerilog
75
star
60

ACCL

Alveo Collective Communication Library: MPI-like communication operations for Xilinx Alveo accelerators
C++
75
star
61

open-nic-shell

AMD OpenNIC Shell includes the HDL source files
SystemVerilog
70
star
62

mlir-air

C++
70
star
63

Applications

C
67
star
64

llvm-aie

Fork of LLVM to support AMD AIEngine processors
LLVM
66
star
65

XilinxUnisimLibrary

Xilinx Unisim Library in Verilog
Verilog
64
star
66

PYNQ_Composable_Pipeline

PYNQ Composabe Overlays
Tcl
61
star
67

gemx

Matrix Operation Library for FPGA https://xilinx.github.io/gemx/
C++
56
star
68

PYNQ_RFSOC_Workshop

Open-sourcing the PYNQ & RFSoC workshop materials
Jupyter Notebook
55
star
69

merlin-compiler

C++
52
star
70

meta-xilinx-tools

Yocto Project layer enables AMD Xilinx tools related metadata for MicroBlaze, Zynq, ZynqMP and Versal devices.
BitBake
50
star
71

RFSoC-PYNQ

Python productivity for RFSoC platforms
Jupyter Notebook
49
star
72

ResNet50-PYNQ

Quantized ResNet50 Dataflow Acceleration on Alveo, with PYNQ
C++
48
star
73

Alveo-PYNQ

Introductory examples for using PYNQ with Alveo
Jupyter Notebook
47
star
74

xup_compute_acceleration

Hands-on experience using the Vitis unified software platform with Xilinx FPGA hardware
C++
46
star
75

xup_high_level_synthesis_design_flow

AMD Xilinx University Program HLS tutorial
C
46
star
76

Vitis_Model_Composer

Vitis Model Composer Examples and Tutorials
C++
46
star
77

Vitis-AWS-F1-Developer-Labs

C++
44
star
78

PYNQ_Bootcamp

PYNQ Bootcamp 2019-2022 teaching materials.
Jupyter Notebook
44
star
79

PYNQ-Networking

Networking Overlay on PYNQ
Tcl
44
star
80

KRS

The Kria Robotics Stack (KRS) is a ROS 2 superset for industry, an integrated set of robot libraries and utilities to accelerate the development, maintenance and commercialization of industrial-grade robotic solutions while using adaptive computing.
HTML
43
star
81

Get_Moving_With_Alveo

For publishing the source for UG1352 "Get Moving with Alveo"
C++
42
star
82

blockchainacceleration

Tcl
42
star
83

HLS_packet_processing

C++
41
star
84

HLS_arbitrary_Precision_Types

C++
40
star
85

DSRL

40
star
86

inference-server

C++
40
star
87

Xilinx_Kria_KV260_Workshop

39
star
88

chipscopy

ChipScoPy (ChipScope Python API) is an open source Python API to the various ChipScope services provided by the TCF-based (Target Communication Framework) ChipScope Server (cs_server).
Jupyter Notebook
38
star
89

VVAS

Vitis Video Analytics SDK
C
37
star
90

vcu-ctrl-sw

C
36
star
91

XilinxCEDStore

This store contains Configurable Example Designs.
Tcl
36
star
92

pyxir

Python
36
star
93

pytorch-ocr

Python
35
star
94

DSP-PYNQ

A PYNQ overlay demonstrating Pythonic DSP running on Zynq UltraScale+
Tcl
35
star
95

xup_aie_training

Hands-on experience programming AI Engines using Vitis Unified Software Platform
Jupyter Notebook
34
star
96

open-nic-driver

AMD OpenNIC driver includes the Linux kernel driver
C
33
star
97

pcie-model

PCI Express controller model
C
32
star
98

qemu-devicetrees

Device trees used by QEMU to describe the hardware
Makefile
32
star
99

bootgen

bootgen source code
C++
31
star
100

hdmi-modules

Xilinx Soft-IP HDMI Rx/Tx core Linux drivers
C
30
star