import VXI RPC Language description

[libsigrok.git] / hardware / common / vxi.x

diff --git a/hardware/common/vxi.x b/hardware/common/vxi.x
new file mode 100644 (file)
index 0000000..31ca4c4
--- /dev/null
+++ b/hardware/common/vxi.x
@@ -0,0 +1,143 @@
+/* This is taken straight from Appendix C of the specification */
+
+typedef long Device_Link;
+
+enum Device_AddrFamily {
+       DEVICE_TCP,
+       DEVICE_UDP
+};
+
+typedef long Device_Flags;
+
+typedef long Device_ErrorCode;
+
+struct Device_Error {
+       Device_ErrorCode  error;
+};
+
+struct Create_LinkParms {
+       long              clientId;      /* implementation specific value */
+       bool              lockDevice;    /* attempt to lock the device */
+       unsigned long     lock_timeout;  /* time to wait on a lock */
+       string            device<>;      /* name of device */
+};
+
+struct Create_LinkResp {
+       Device_ErrorCode  error;
+       Device_Link       lid;
+       unsigned short    abortPort;     /* for the abort RPC */
+       unsigned long     maxRecvSize;   /* specifies max data size in bytes
+                                           device will accept on a write */
+};
+
+struct Device_WriteParms {
+       Device_Link       lid;           /* link id from create_link */
+       unsigned long     io_timeout;    /* time to wait for I/O */
+       unsigned long     lock_timeout;  /* time to wait for lock */
+       Device_Flags      flags;
+       opaque            data<>;        /* data length and the data itself */
+};
+
+struct Device_WriteResp {
+       Device_ErrorCode  error;
+       unsigned          long size;     /* number of bytes written */
+};
+
+struct Device_ReadParms {
+       Device_Link       lid;           /* link id from create_link */
+       unsigned long     requestSize;   /* bytes requested */
+       unsigned long     io_timeout;    /* time to wait for I/O */
+       unsigned long     lock_timeout;  /* time to wait for lock */
+       Device_Flags      flags;
+       char              termChar;      /* valid if flags & termchrset */
+};
+
+struct Device_ReadResp {
+       Device_ErrorCode  error;
+       long              reason;        /* reason(s) read completed */
+       opaque            data<>;        /* data.len and data.val */
+};
+
+struct Device_ReadStbResp {
+       Device_ErrorCode  error;         /* error code */
+       unsigned char     stb;           /* the returned status byte */
+};
+
+struct Device_GenericParms {
+       Device_Link       lid;           /* Device_Link id from connect call */
+       Device_Flags      flags;         /* flags with options */
+       unsigned long     lock_timeout;  /* time to wait for lock */
+       unsigned long     io_timeout;    /* time to wait for I/O */
+};
+
+struct Device_RemoteFunc {
+       unsigned long     hostAddr;      /* host servicing interrupt */
+       unsigned short    hostPort;      /* valid port # on client */
+       unsigned long     progNum;       /* DEVICE_INTR */
+       unsigned long     progVers;      /* DEVICE_INTR_VERSION */
+       Device_AddrFamily progFamily;    /* DEVICE_UDP | DEVICE_TCP */
+};
+
+struct Device_EnableSrqParms {
+       Device_Link       lid;
+       bool              enable;        /* enable or disable interrupts */
+       opaque            handle<40>;    /* host specific data */
+};
+
+struct Device_LockParms {
+       Device_Link       lid;           /* link id from create_link */
+       Device_Flags      flags;         /* contains the waitlock flag */
+       unsigned long     lock_timeout;  /* time to wait to acquire lock */
+};
+
+struct Device_DocmdParms {
+       Device_Link       lid;           /* link id from create_link */
+       Device_Flags      flags;         /* flags specifying various options */
+       unsigned long     io_timeout;    /* time to wait for I/O to complete */
+       unsigned long     lock_timeout;  /* time to wait on a lock */
+       long              cmd;           /* which command to execute */
+       bool              network_order; /* client's byte order */
+       long              datasize;      /* size of individual data elements */
+       opaque            data_in<>;     /* docmd data parameters */
+};
+
+struct Device_DocmdResp {
+       Device_ErrorCode  error;         /* returned status */
+       opaque            data_out<>;    /* returned data parameter */
+};
+
+struct Device_SrqParms {
+       opaque            handle<>;
+};
+
+program DEVICE_ASYNC{
+       version DEVICE_ASYNC_VERSION {
+               Device_Error       device_abort(Device_Link)               =  1;
+       } = 1;
+} = 0x0607B0;
+
+program DEVICE_CORE {
+       version DEVICE_CORE_VERSION {
+               Create_LinkResp    create_link(Create_LinkParms)           = 10;
+               Device_WriteResp   device_write(Device_WriteParms)         = 11;
+               Device_ReadResp    device_read(Device_ReadParms)           = 12;
+               Device_ReadStbResp device_readstb(Device_GenericParms)     = 13;
+               Device_Error       device_trigger(Device_GenericParms)     = 14;
+               Device_Error       device_clear(Device_GenericParms)       = 15;
+               Device_Error       device_remote(Device_GenericParms)      = 16;
+               Device_Error       device_local(Device_GenericParms)       = 17;
+               Device_Error       device_lock(Device_LockParms)           = 18;
+               Device_Error       device_unlock(Device_Link)              = 19;
+               Device_Error       device_enable_srq(Device_EnableSrqParms)= 20;
+               Device_DocmdResp   device_docmd(Device_DocmdParms)         = 22;
+               Device_Error       destroy_link(Device_Link)               = 23;
+               Device_Error       create_intr_chan(Device_RemoteFunc)     = 25;
+               Device_Error       destroy_intr_chan(void)                 = 26;
+       } = 1;
+} = 0x0607AF;
+
+program DEVICE_INTR {
+       version DEVICE_INTR_VERSION {
+               void               device_intr_srq(Device_SrqParms)        = 30;
+       } = 1;
+} = 0x0607B1;