From 8170612e88968475877e1b94268698147fcc57f5 Mon Sep 17 00:00:00 2001 From: Simone Mannarino Date: Mon, 2 Mar 2026 15:42:43 +0100 Subject: [PATCH 1/4] Fix docs and adding petalinux login credentials (#1534) * Fix docs and adding petalinux login credentials * Fix PuTTY link --------- Co-authored-by: Simone Mannarino --- docs/source/pynq_remote/quickstart.rst | 4 +++- docs/source/pynq_sd_card.rst | 25 ++++--------------------- sdbuild/README.md | 2 +- 3 files changed, 8 insertions(+), 23 deletions(-) diff --git a/docs/source/pynq_remote/quickstart.rst b/docs/source/pynq_remote/quickstart.rst index 846efcba6..e667a0518 100644 --- a/docs/source/pynq_remote/quickstart.rst +++ b/docs/source/pynq_remote/quickstart.rst @@ -42,7 +42,9 @@ Step 2: Prepare and Boot the Target Device * Create a PYNQ.remote image using the instructions in :doc:`image_build`. * Flash the image to your SD card (see :doc:`../appendix/sdcard` for instructions on how to flash the image). * Insert the SD card and power on the device (make sure it is connected to your network). -* Wait for the device to boot up. You can check the device's IP address using a serial console (e.g. `minicom `_ or `PuTTY `_) or by checking your router's DHCP client list. +* Wait for the device to boot up. You can check the device's IP address using a serial console (e.g. `minicom `_ or `PuTTY `_) or by checking your router's DHCP client list. + +Be aware that the default login credentials have changed with Petalinux. The username is `petalinux`. On first boot, you will be prompted to set a new password. .. note:: diff --git a/docs/source/pynq_sd_card.rst b/docs/source/pynq_sd_card.rst index b1f6bf29c..889be86a7 100644 --- a/docs/source/pynq_sd_card.rst +++ b/docs/source/pynq_sd_card.rst @@ -232,34 +232,17 @@ Unmount images before building again Sometimes the SD image building process can error out, leaving mounted images in your host OS. You need to unmount these images before trying the make process again. Starting from image v2.6, users can do the following to -unmount the images. +unmount and delete the failed images, and remove all the previously +built images at different stages: .. code-block:: console cd /sdbuild/ - make delete - -The above command not only unmounts all the images, but also deletes the -failed images. This makes sure the users do not use the failed images when -continuing the SD build process. - -To unmount images but not delete them, use the following command instead. + make clean -.. code-block:: console - - cd /sdbuild/ - make unmount If you want to ignore all the previous staged or cached SD build -artifacts and start from scratch again, you can use the following command. -This will unmount and delete the failed images, and remove all the previously -built images at different stages. - -.. code-block:: console - - cd /sdbuild/ - make clean - +artifacts and start from scratch again, you can use the command above. Retargeting to a Different Board ================================ diff --git a/sdbuild/README.md b/sdbuild/README.md index 69f34813a..b0afda07d 100644 --- a/sdbuild/README.md +++ b/sdbuild/README.md @@ -72,7 +72,7 @@ source /home/user/petalinux/settings.sh ``` Ensure that the prebuilt pynq sdist and rootfs tarballs are in the `sdbuild/prebuilt` -folder, then build your image: +folder named `pynq_sdist.tar.gz` and `pynq_rootfs..tar.gz` , then build your image: ``` cd sdbuild From 4118f1ec07df5ac87dee60e4426be775e9d76b17 Mon Sep 17 00:00:00 2001 From: Simone Mannarino Date: Mon, 2 Mar 2026 15:43:26 +0100 Subject: [PATCH 2/4] Fix OverflowError in remote MMIO reads for register values >= 0x80000000 (#1539) Co-authored-by: Simone Mannarino --- pynq/remote/mmio_pb2.py | 2 +- .../meta-pynq/recipes-apps/pynq-cpp/files/protos/mmio.proto | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pynq/remote/mmio_pb2.py b/pynq/remote/mmio_pb2.py index 7cb5fc0fb..0bb1ff866 100644 --- a/pynq/remote/mmio_pb2.py +++ b/pynq/remote/mmio_pb2.py @@ -14,7 +14,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nmmio.proto\x12\x04mmio\"3\n\x0eGetMmioRequest\x12\x11\n\tbase_addr\x18\x01 \x01(\x04\x12\x0e\n\x06length\x18\x02 \x01(\x04\"]\n\x0fGetMmioResponse\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x10\n\x03msg\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x14\n\x07mmio_id\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x06\n\x04_msgB\n\n\x08_mmio_id\"R\n\x0bReadRequest\x12\x0f\n\x07mmio_id\x18\x01 \x01(\t\x12\x0e\n\x06length\x18\x02 \x01(\x04\x12\x0e\n\x06offset\x18\x03 \x01(\x04\x12\x12\n\nword_order\x18\x04 \x01(\t\"T\n\x0cReadResponse\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x10\n\x03msg\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x11\n\x04\x64\x61ta\x18\x03 \x01(\x05H\x01\x88\x01\x01\x42\x06\n\x04_msgB\x07\n\x05_data\"=\n\x0cWriteRequest\x12\x0f\n\x07mmio_id\x18\x01 \x01(\t\x12\x0e\n\x06offset\x18\x02 \x01(\x04\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"9\n\rWriteResponse\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x10\n\x03msg\x18\x02 \x01(\tH\x00\x88\x01\x01\x42\x06\n\x04_msg2\xa6\x01\n\x04Mmio\x12\x39\n\x08get_mmio\x12\x14.mmio.GetMmioRequest\x1a\x15.mmio.GetMmioResponse\"\x00\x12/\n\x04read\x12\x11.mmio.ReadRequest\x1a\x12.mmio.ReadResponse\"\x00\x12\x32\n\x05write\x12\x12.mmio.WriteRequest\x1a\x13.mmio.WriteResponse\"\x00\x62\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nmmio.proto\x12\x04mmio\"3\n\x0eGetMmioRequest\x12\x11\n\tbase_addr\x18\x01 \x01(\x04\x12\x0e\n\x06length\x18\x02 \x01(\x04\"]\n\x0fGetMmioResponse\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x10\n\x03msg\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x14\n\x07mmio_id\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x06\n\x04_msgB\n\n\x08_mmio_id\"R\n\x0bReadRequest\x12\x0f\n\x07mmio_id\x18\x01 \x01(\t\x12\x0e\n\x06length\x18\x02 \x01(\x04\x12\x0e\n\x06offset\x18\x03 \x01(\x04\x12\x12\n\nword_order\x18\x04 \x01(\t\"T\n\x0cReadResponse\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x10\n\x03msg\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x11\n\x04\x64\x61ta\x18\x03 \x01(\rH\x01\x88\x01\x01\x42\x06\n\x04_msgB\x07\n\x05_data\"=\n\x0cWriteRequest\x12\x0f\n\x07mmio_id\x18\x01 \x01(\t\x12\x0e\n\x06offset\x18\x02 \x01(\x04\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"9\n\rWriteResponse\x12\x0e\n\x06status\x18\x01 \x01(\x08\x12\x10\n\x03msg\x18\x02 \x01(\tH\x00\x88\x01\x01\x42\x06\n\x04_msg2\xa6\x01\n\x04Mmio\x12\x39\n\x08get_mmio\x12\x14.mmio.GetMmioRequest\x1a\x15.mmio.GetMmioResponse\"\x00\x12/\n\x04read\x12\x11.mmio.ReadRequest\x1a\x12.mmio.ReadResponse\"\x00\x12\x32\n\x05write\x12\x12.mmio.WriteRequest\x1a\x13.mmio.WriteResponse\"\x00\x62\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/mmio.proto b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/mmio.proto index d4f5982f7..a0ed428a5 100644 --- a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/mmio.proto +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/mmio.proto @@ -29,7 +29,7 @@ message ReadRequest { message ReadResponse { bool status = 1; optional string msg = 2; - optional int32 data = 3; + optional uint32 data = 3; } message WriteRequest { From 09eae40e40c71db8ea06b29c15e66836c2d8ce15 Mon Sep 17 00:00:00 2001 From: Simone Mannarino Date: Thu, 11 Jun 2026 11:18:23 +0100 Subject: [PATCH 3/4] Adding xrfdc and xrfclk support for PYNQ.remote (#1542) * Add remote xrfdc and xrfclk support for PYNQ.remote * add REMOTE_PACKAGES mechanism for PYNQ.remote rootfs * included per-board tics files and made xrfclk board-aware * xrfclk remote: add program_lmk/program_lmx RPCs for on-target TICS * pynq-cpp: program xrfclk from on-target TICS files by frequency * xrfclk: on-target TICS fallback with per-device multi-board overrides; drop bundled tics * xrfclk: document remote clock-file usage in module docstring * xrfclk: resolve TICS from active venv site-packages * xrfclk: drop redundant ip_addr guard in TICS lookup * docs: fix comments on RFSoC specific packages --------- Co-authored-by: josh goldsmith --- pynq/__init__.py | 4 + pynq/remote/xrfclk.py | 232 + pynq/remote/xrfclk_pb2.py | 46 + pynq/remote/xrfclk_pb2.pyi | 58 + pynq/remote/xrfclk_pb2_grpc.py | 274 + pynq/remote/xrfdc.py | 971 ++++ pynq/remote/xrfdc_pb2.py | 226 + pynq/remote/xrfdc_pb2.pyi | 1069 ++++ pynq/remote/xrfdc_pb2_grpc.py | 3370 +++++++++++++ sdbuild/Makefile | 27 +- .../pynq-cpp/files/cpp/CMakeLists.txt | 114 + .../pynq-cpp/files/cpp/pynq-remote.cc | 73 + .../recipes-apps/pynq-cpp/files/cpp/xrfclk.cc | 622 +++ .../recipes-apps/pynq-cpp/files/cpp/xrfclk.h | 116 + .../recipes-apps/pynq-cpp/files/cpp/xrfdc.cc | 4469 +++++++++++++++++ .../recipes-apps/pynq-cpp/files/cpp/xrfdc.h | 563 +++ .../pynq-cpp/files/protos/xrfclk.proto | 47 + .../pynq-cpp/files/protos/xrfdc.proto | 733 +++ .../recipes-apps/pynq-cpp/pynq-cpp.bb | 11 + .../recipes-bsp/rfdc/rfdc_%.bbappend | 3 + 20 files changed, 13022 insertions(+), 6 deletions(-) create mode 100644 pynq/remote/xrfclk.py create mode 100644 pynq/remote/xrfclk_pb2.py create mode 100644 pynq/remote/xrfclk_pb2.pyi create mode 100644 pynq/remote/xrfclk_pb2_grpc.py create mode 100644 pynq/remote/xrfdc.py create mode 100644 pynq/remote/xrfdc_pb2.py create mode 100644 pynq/remote/xrfdc_pb2.pyi create mode 100644 pynq/remote/xrfdc_pb2_grpc.py create mode 100644 sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.cc create mode 100644 sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.h create mode 100644 sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.cc create mode 100644 sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.h create mode 100644 sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfclk.proto create mode 100644 sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfdc.proto create mode 100644 sdbuild/boot/meta-pynq/recipes-bsp/rfdc/rfdc_%.bbappend diff --git a/pynq/__init__.py b/pynq/__init__.py index 1ef532a68..bee98e27e 100755 --- a/pynq/__init__.py +++ b/pynq/__init__.py @@ -17,6 +17,10 @@ from .pl_server.remote_device import RemoteGPIO as GPIO from .pl_server.remote_device import RemoteInterrupt as Interrupt from .pl_server.remote_device import RemoteUioController as UioController + import sys + from .remote import xrfdc as _remote_xrfdc, xrfclk as _remote_xrfclk + sys.modules["xrfdc"] = _remote_xrfdc + sys.modules["xrfclk"] = _remote_xrfclk else: from .gpio import GPIO from .interrupt import Interrupt diff --git a/pynq/remote/xrfclk.py b/pynq/remote/xrfclk.py new file mode 100644 index 000000000..ef8f68d96 --- /dev/null +++ b/pynq/remote/xrfclk.py @@ -0,0 +1,232 @@ +"""Remote xrfclk: set RFSoC reference clocks over gRPC. + +Used exactly like classic PYNQ: + + import xrfclk + xrfclk.set_ref_clks(lmk_freq=245.76, lmx_freq=491.52) + +The only difference from classic is where the clock (TICS) files come from. + +Normally you don't need additional clock files. Each board's remote image +already ships its own, so set_ref_clks works for the frequencies the board +supports. Any unsupported frequency raises "Frequency MHz is not valid". + +To override or add a frequency, put a clock file named CHIPNAME_FREQUENCY.txt +in the directory you run from. A local file takes precedence over the board's. + +When driving multiple boards from the same host, place board-specific files +in a subdirectory so they do not clash. The most specific match wins: + + /** applies to every board, every working directory + ./ applies to every board + .// one board model, e.g. ./RFSoC4x2/ or ./ZCU208/ + .// one specific board + +Two boards of the same model can only be told apart by .//. +""" + +import os +import sys +import glob +import re +import sysconfig +import grpc +from collections import defaultdict +from pynq.pl_server import Device +from pynq.pl_server.remote_device import RemoteDevice +from pynq.remote import xrfclk_pb2, xrfclk_pb2_grpc + +# Per-device TICS register cache: _Config[device][chip][freq] = [reg, ...]. +# Keyed by device so multiple boards (even sharing a chip + frequency) do not collide. +_Config = defaultdict(lambda: defaultdict(dict)) +_Devices = defaultdict(dict) + +# Classic (single-board) compatibility surface, read as xrfclk.lmk_devices / +# xrfclk.lmx_devices. With multiple boards these reflect only the most recently +# resolved device; per-device chip identities live in _Devices[device]. +lmk_devices = [] +lmx_devices = [] + +# Self-alias for classic compatibility: expose xrfclk.xrfclk as this module. +xrfclk = sys.modules[__name__] + +# get target devices +def _get_device(device): + """Return device if it is a RemoteDevice, else the active remote device.""" + if not isinstance(device, RemoteDevice): + try: + device = Device.active_device + except Exception: + raise RuntimeError("No remote device found. Either use the " + "PYNQ_REMOTE_DEVICES environment variable or pass " + "a device explicitly.") + if not isinstance(device, RemoteDevice): + raise RuntimeError("This function is only supported on remote devices.") + return device + + +def _write_LMK_regs(reg_vals, device=None): + device = _get_device(device) + request = xrfclk_pb2.WriteLmkRegsRequest(reg_vals=reg_vals) + try: + device._stub['xrfclk'].write_lmk_regs(request) + except Exception as e: + raise RuntimeError(f"Failed to write LMK registers: {e}") + + +def _write_LMX_regs(reg_vals, device=None): + device = _get_device(device) + request = xrfclk_pb2.WriteLmxRegsRequest(reg_vals=reg_vals) + try: + device._stub['xrfclk'].write_lmx_regs(request) + except Exception as e: + raise RuntimeError(f"Failed to write LMX registers: {e}") + + +def _program_LMK(lmk_freq, device=None): + """Ask the target to program the LMK from its own on-target TICS file.""" + device = _get_device(device) + request = xrfclk_pb2.ProgramLmkRequest(freq=lmk_freq) + try: + device._stub['xrfclk'].program_lmk(request) + except grpc.RpcError as e: + if e.code() == grpc.StatusCode.NOT_FOUND: + raise RuntimeError(f"Frequency {lmk_freq} MHz is not valid.") + raise RuntimeError(f"Failed to program LMK: {e}") + + +def _program_LMX(lmx_freq, device=None): + """Ask the target to program the LMX from its own on-target TICS file.""" + device = _get_device(device) + request = xrfclk_pb2.ProgramLmxRequest(freq=lmx_freq) + try: + device._stub['xrfclk'].program_lmx(request) + except grpc.RpcError as e: + if e.code() == grpc.StatusCode.NOT_FOUND: + raise RuntimeError(f"Frequency {lmx_freq} MHz is not valid.") + raise RuntimeError(f"Failed to program LMX: {e}") + + +def _set_LMK_regs(lmk_freq, device): + """Set the LMK: use a matching local TICS file if present, else the target's own file.""" + lmk = _Devices[device]['lmk'] + config = _Config[device] + if lmk_freq in config.get(lmk, {}): + _write_LMK_regs(config[lmk][lmk_freq], device) + else: + _program_LMK(lmk_freq, device) + + +def _set_LMX_regs(lmx_freq, device): + """Set the LMX: use a matching local TICS file if present, else the target's own file.""" + lmx = _Devices[device]['lmx'] + config = _Config[device] + if lmx_freq in config.get(lmx, {}): + _write_LMX_regs(config[lmx][lmx_freq], device) + else: + _program_LMX(lmx_freq, device) + + +def set_ref_clks(lmk_freq=122.88, lmx_freq=409.6, device=None): + device = _get_device(device) + + if device not in _Devices or 'lmk' not in _Devices[device]: + _find_devices(device) + + # Load this device's local TICS overrides; per chip, a local match wins, + # otherwise the target programs from its own on-target files. LMK before LMX. + _read_tics_output(device) + _set_LMK_regs(lmk_freq, device) + _set_LMX_regs(lmx_freq, device) + + +def set_all_ref_clks(lmx_freq=409.6, device=None): + """Deprecated; retained for classic compatibility. Calls set_ref_clks.""" + return set_ref_clks(122.88, lmx_freq, device) + +# find clock devices +def _find_devices(device=None): + device = _get_device(device) + if not hasattr(device, '_stub'): + device._stub = {} + device._stub['xrfclk'] = xrfclk_pb2_grpc.XrfclkStub(device.client.channel) + response = device._stub['xrfclk'].find_devices(xrfclk_pb2.FindDevicesRequest()) + + # Per-device chip identities, used by the dispatch (safe with multiple boards). + _Devices[device]['lmk'] = response.lmk_device + _Devices[device]['lmx'] = response.lmx_device + + # Classic-compatible flat globals: reflect the device just resolved. + global lmk_devices, lmx_devices + lmk_devices = [{'compatible': response.lmk_device}] + lmx_devices = [{'compatible': response.lmx_device}] + + +def _load_tics_file(path, config): + """Parse one CHIPNAME_FREQUENCY.txt TICS file into config[chip][freq]. + + The file (e.g. LMK04828_245.76.txt) holds the register values for that chip at + that frequency, stored as config[chip][freq] = [reg, ...]. Files whose name does + not match the CHIPNAME_FREQUENCY pattern are skipped. Entries are overwritten, so + a file loaded later overrides one loaded earlier for the same chip+freq. + """ + name = os.path.splitext(os.path.basename(path).lower())[0] + match = re.match(r'^([a-z0-9]+)_([\d.]+)$', name) + if not match: + return + chip, freq = match.group(1), float(match.group(2)) + regs = [] + with open(path) as f: + for line in f: + m = re.search(r'0x[0-9A-Fa-f]+', line) + if m: + regs.append(int(m.group(0), 16)) + if not regs: + raise RuntimeError(f"No register values found in TICS file: {path}") + config[chip][freq] = regs + + +def _load_tics_dir(dir_path, config): + """Load the TICS files directly in dir_path (non-recursive) into config. + + A missing directory yields no files (skipped). + """ + for path in sorted(glob.glob(os.path.join(dir_path, '*.txt'))): + _load_tics_file(path, config) + + +def _load_venv_tics(config): + """Load TICS files from anywhere under the active environment's site-packages. + + Resolved from the running interpreter (honours an active virtualenv), so it + tracks whichever environment PYNQ is executing in, and searched recursively so + TICS files bundled inside any installed package are found. + """ + site_packages = sysconfig.get_paths()['purelib'] + for path in sorted(glob.glob(os.path.join(site_packages, '**', '*.txt'), + recursive=True)): + _load_tics_file(path, config) + + +def _read_tics_output(device): + """Load this device's local TICS overrides, most-specific directory winning. + + Search order (a later directory overrides an earlier one for the same file): + /** environment-wide default (searched recursively) + ./ shared / single-board (classic layout) + .// per board model, e.g. RFSoC4x2, ZCU208 + .// per board instance (distinguishes identical boards) + + Frequencies found here are programmed by sending their register values to the + target (host file wins). Frequencies with no local file fall back to the board's + on-target files via set_ref_clks. An empty result is valid: it just means every + frequency comes from the target. + """ + config = _Config[device] + config.clear() + _load_venv_tics(config) + cwd = os.getcwd() + _load_tics_dir(cwd, config) + if device.name: + _load_tics_dir(os.path.join(cwd, device.name), config) + _load_tics_dir(os.path.join(cwd, str(device.ip_addr)), config) diff --git a/pynq/remote/xrfclk_pb2.py b/pynq/remote/xrfclk_pb2.py new file mode 100644 index 000000000..eb0e9818e --- /dev/null +++ b/pynq/remote/xrfclk_pb2.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: xrfclk.proto +# Protobuf Python Version: 5.26.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cxrfclk.proto\x12\x06xrfclk\"\x14\n\x12\x46indDevicesRequest\"=\n\x13\x46indDevicesResponse\x12\x12\n\nlmk_device\x18\x01 \x01(\t\x12\x12\n\nlmx_device\x18\x02 \x01(\t\"\'\n\x13WriteLmkRegsRequest\x12\x10\n\x08reg_vals\x18\x01 \x03(\r\"\x16\n\x14WriteLmkRegsResponse\"\'\n\x13WriteLmxRegsRequest\x12\x10\n\x08reg_vals\x18\x01 \x03(\r\"\x16\n\x14WriteLmxRegsResponse\"!\n\x11ProgramLmkRequest\x12\x0c\n\x04\x66req\x18\x01 \x01(\x01\"\x14\n\x12ProgramLmkResponse\"!\n\x11ProgramLmxRequest\x12\x0c\n\x04\x66req\x18\x01 \x01(\x01\"\x14\n\x12ProgramLmxResponse2\xf7\x02\n\x06Xrfclk\x12G\n\x0c\x66ind_devices\x12\x1a.xrfclk.FindDevicesRequest\x1a\x1b.xrfclk.FindDevicesResponse\x12K\n\x0ewrite_lmk_regs\x12\x1b.xrfclk.WriteLmkRegsRequest\x1a\x1c.xrfclk.WriteLmkRegsResponse\x12K\n\x0ewrite_lmx_regs\x12\x1b.xrfclk.WriteLmxRegsRequest\x1a\x1c.xrfclk.WriteLmxRegsResponse\x12\x44\n\x0bprogram_lmk\x12\x19.xrfclk.ProgramLmkRequest\x1a\x1a.xrfclk.ProgramLmkResponse\x12\x44\n\x0bprogram_lmx\x12\x19.xrfclk.ProgramLmxRequest\x1a\x1a.xrfclk.ProgramLmxResponseb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'xrfclk_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + DESCRIPTOR._loaded_options = None + _globals['_FINDDEVICESREQUEST']._serialized_start=24 + _globals['_FINDDEVICESREQUEST']._serialized_end=44 + _globals['_FINDDEVICESRESPONSE']._serialized_start=46 + _globals['_FINDDEVICESRESPONSE']._serialized_end=107 + _globals['_WRITELMKREGSREQUEST']._serialized_start=109 + _globals['_WRITELMKREGSREQUEST']._serialized_end=148 + _globals['_WRITELMKREGSRESPONSE']._serialized_start=150 + _globals['_WRITELMKREGSRESPONSE']._serialized_end=172 + _globals['_WRITELMXREGSREQUEST']._serialized_start=174 + _globals['_WRITELMXREGSREQUEST']._serialized_end=213 + _globals['_WRITELMXREGSRESPONSE']._serialized_start=215 + _globals['_WRITELMXREGSRESPONSE']._serialized_end=237 + _globals['_PROGRAMLMKREQUEST']._serialized_start=239 + _globals['_PROGRAMLMKREQUEST']._serialized_end=272 + _globals['_PROGRAMLMKRESPONSE']._serialized_start=274 + _globals['_PROGRAMLMKRESPONSE']._serialized_end=294 + _globals['_PROGRAMLMXREQUEST']._serialized_start=296 + _globals['_PROGRAMLMXREQUEST']._serialized_end=329 + _globals['_PROGRAMLMXRESPONSE']._serialized_start=331 + _globals['_PROGRAMLMXRESPONSE']._serialized_end=351 + _globals['_XRFCLK']._serialized_start=354 + _globals['_XRFCLK']._serialized_end=729 +# @@protoc_insertion_point(module_scope) diff --git a/pynq/remote/xrfclk_pb2.pyi b/pynq/remote/xrfclk_pb2.pyi new file mode 100644 index 000000000..30d2569ba --- /dev/null +++ b/pynq/remote/xrfclk_pb2.pyi @@ -0,0 +1,58 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Optional as _Optional + +DESCRIPTOR: _descriptor.FileDescriptor + +class FindDevicesRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class FindDevicesResponse(_message.Message): + __slots__ = ("lmk_device", "lmx_device") + LMK_DEVICE_FIELD_NUMBER: _ClassVar[int] + LMX_DEVICE_FIELD_NUMBER: _ClassVar[int] + lmk_device: str + lmx_device: str + def __init__(self, lmk_device: _Optional[str] = ..., lmx_device: _Optional[str] = ...) -> None: ... + +class WriteLmkRegsRequest(_message.Message): + __slots__ = ("reg_vals",) + REG_VALS_FIELD_NUMBER: _ClassVar[int] + reg_vals: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, reg_vals: _Optional[_Iterable[int]] = ...) -> None: ... + +class WriteLmkRegsResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class WriteLmxRegsRequest(_message.Message): + __slots__ = ("reg_vals",) + REG_VALS_FIELD_NUMBER: _ClassVar[int] + reg_vals: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, reg_vals: _Optional[_Iterable[int]] = ...) -> None: ... + +class WriteLmxRegsResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class ProgramLmkRequest(_message.Message): + __slots__ = ("freq",) + FREQ_FIELD_NUMBER: _ClassVar[int] + freq: float + def __init__(self, freq: _Optional[float] = ...) -> None: ... + +class ProgramLmkResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class ProgramLmxRequest(_message.Message): + __slots__ = ("freq",) + FREQ_FIELD_NUMBER: _ClassVar[int] + freq: float + def __init__(self, freq: _Optional[float] = ...) -> None: ... + +class ProgramLmxResponse(_message.Message): + __slots__ = () + def __init__(self) -> None: ... diff --git a/pynq/remote/xrfclk_pb2_grpc.py b/pynq/remote/xrfclk_pb2_grpc.py new file mode 100644 index 000000000..f82010cb7 --- /dev/null +++ b/pynq/remote/xrfclk_pb2_grpc.py @@ -0,0 +1,274 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + +from pynq.remote import xrfclk_pb2 as xrfclk__pb2 + +GRPC_GENERATED_VERSION = '1.64.0' +GRPC_VERSION = grpc.__version__ +EXPECTED_ERROR_RELEASE = '1.65.0' +SCHEDULED_RELEASE_DATE = 'June 25, 2024' +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + warnings.warn( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in xrfclk_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},' + + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.', + RuntimeWarning + ) + + +class XrfclkStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.find_devices = channel.unary_unary( + '/xrfclk.Xrfclk/find_devices', + request_serializer=xrfclk__pb2.FindDevicesRequest.SerializeToString, + response_deserializer=xrfclk__pb2.FindDevicesResponse.FromString, + _registered_method=True) + self.write_lmk_regs = channel.unary_unary( + '/xrfclk.Xrfclk/write_lmk_regs', + request_serializer=xrfclk__pb2.WriteLmkRegsRequest.SerializeToString, + response_deserializer=xrfclk__pb2.WriteLmkRegsResponse.FromString, + _registered_method=True) + self.write_lmx_regs = channel.unary_unary( + '/xrfclk.Xrfclk/write_lmx_regs', + request_serializer=xrfclk__pb2.WriteLmxRegsRequest.SerializeToString, + response_deserializer=xrfclk__pb2.WriteLmxRegsResponse.FromString, + _registered_method=True) + self.program_lmk = channel.unary_unary( + '/xrfclk.Xrfclk/program_lmk', + request_serializer=xrfclk__pb2.ProgramLmkRequest.SerializeToString, + response_deserializer=xrfclk__pb2.ProgramLmkResponse.FromString, + _registered_method=True) + self.program_lmx = channel.unary_unary( + '/xrfclk.Xrfclk/program_lmx', + request_serializer=xrfclk__pb2.ProgramLmxRequest.SerializeToString, + response_deserializer=xrfclk__pb2.ProgramLmxResponse.FromString, + _registered_method=True) + + +class XrfclkServicer(object): + """Missing associated documentation comment in .proto file.""" + + def find_devices(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def write_lmk_regs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def write_lmx_regs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def program_lmk(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def program_lmx(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_XrfclkServicer_to_server(servicer, server): + rpc_method_handlers = { + 'find_devices': grpc.unary_unary_rpc_method_handler( + servicer.find_devices, + request_deserializer=xrfclk__pb2.FindDevicesRequest.FromString, + response_serializer=xrfclk__pb2.FindDevicesResponse.SerializeToString, + ), + 'write_lmk_regs': grpc.unary_unary_rpc_method_handler( + servicer.write_lmk_regs, + request_deserializer=xrfclk__pb2.WriteLmkRegsRequest.FromString, + response_serializer=xrfclk__pb2.WriteLmkRegsResponse.SerializeToString, + ), + 'write_lmx_regs': grpc.unary_unary_rpc_method_handler( + servicer.write_lmx_regs, + request_deserializer=xrfclk__pb2.WriteLmxRegsRequest.FromString, + response_serializer=xrfclk__pb2.WriteLmxRegsResponse.SerializeToString, + ), + 'program_lmk': grpc.unary_unary_rpc_method_handler( + servicer.program_lmk, + request_deserializer=xrfclk__pb2.ProgramLmkRequest.FromString, + response_serializer=xrfclk__pb2.ProgramLmkResponse.SerializeToString, + ), + 'program_lmx': grpc.unary_unary_rpc_method_handler( + servicer.program_lmx, + request_deserializer=xrfclk__pb2.ProgramLmxRequest.FromString, + response_serializer=xrfclk__pb2.ProgramLmxResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'xrfclk.Xrfclk', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + server.add_registered_method_handlers('xrfclk.Xrfclk', rpc_method_handlers) + + + # This class is part of an EXPERIMENTAL API. +class Xrfclk(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def find_devices(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfclk.Xrfclk/find_devices', + xrfclk__pb2.FindDevicesRequest.SerializeToString, + xrfclk__pb2.FindDevicesResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def write_lmk_regs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfclk.Xrfclk/write_lmk_regs', + xrfclk__pb2.WriteLmkRegsRequest.SerializeToString, + xrfclk__pb2.WriteLmkRegsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def write_lmx_regs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfclk.Xrfclk/write_lmx_regs', + xrfclk__pb2.WriteLmxRegsRequest.SerializeToString, + xrfclk__pb2.WriteLmxRegsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def program_lmk(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfclk.Xrfclk/program_lmk', + xrfclk__pb2.ProgramLmkRequest.SerializeToString, + xrfclk__pb2.ProgramLmkResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def program_lmx(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfclk.Xrfclk/program_lmx', + xrfclk__pb2.ProgramLmxRequest.SerializeToString, + xrfclk__pb2.ProgramLmxResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) diff --git a/pynq/remote/xrfdc.py b/pynq/remote/xrfdc.py new file mode 100644 index 000000000..052ef8230 --- /dev/null +++ b/pynq/remote/xrfdc.py @@ -0,0 +1,971 @@ +# Copyright (c) 2018, Xilinx, Inc. +# SPDX-License-Identifier: BSD-3-Clause + +""" +Remote gRPC driver for Xilinx RF Data Converter IP. +Mirrors the classic PYNQ xrfdc API using data-driven property generation. +""" + +from . import xrfdc_pb2, xrfdc_pb2_grpc +from pynq.overlay import DefaultIP + +# ============================================================================ +# Constants (matching C driver / classic xrfdc) +# ============================================================================ + +XRFDC_ADC_TILE = 0 +XRFDC_DAC_TILE = 1 + +CLK_SRC_PLL = 0x1 +CLK_SRC_EXT = 0x2 + +EVNT_SRC_IMMEDIATE = 0x00000000 +EVNT_SRC_SLICE = 0x00000001 +EVNT_SRC_TILE = 0x00000002 +EVNT_SRC_SYSREF = 0x00000003 +EVNT_SRC_MARKER = 0x00000004 +EVNT_SRC_PL = 0x00000005 +EVENT_MIXER = 0x00000001 +EVENT_CRSE_DLY = 0x00000002 +EVENT_QMC = 0x00000004 + +MIXER_MODE_OFF = 0x0 +MIXER_MODE_C2C = 0x1 +MIXER_MODE_C2R = 0x2 +MIXER_MODE_R2C = 0x3 +MIXER_MODE_R2R = 0x4 + +MIXER_TYPE_COARSE = 0x1 +MIXER_TYPE_FINE = 0x2 +MIXER_TYPE_OFF = 0x3 + +COARSE_MIX_OFF = 0x0 +COARSE_MIX_SAMPLE_FREQ_BY_TWO = 0x2 +COARSE_MIX_SAMPLE_FREQ_BY_FOUR = 0x4 +COARSE_MIX_MIN_SAMPLE_FREQ_BY_FOUR = 0x8 +COARSE_MIX_BYPASS = 0x10 + +MIXER_SCALE_AUTO = 0x0 +MIXER_SCALE_1P0 = 0x1 +MIXER_SCALE_0P7 = 0x2 + +FAB_CLK_DIV1 = 0x1 +FAB_CLK_DIV2 = 0x2 +FAB_CLK_DIV4 = 0x3 +FAB_CLK_DIV8 = 0x4 +FAB_CLK_DIV16 = 0x5 + +THRESHOLD_CLRMD_MANUAL_CLR = 0x1 +THRESHOLD_CLRMD_AUTO_CLR = 0x2 +TRSHD_OFF = 0x0 +TRSHD_STICKY_OVER = 0x1 +TRSHD_STICKY_UNDER = 0x2 +TRSHD_HYSTERISIS = 0x3 + +XRFDC_CAL_BLOCK_OCB1 = 0 +XRFDC_CAL_BLOCK_OCB2 = 1 +XRFDC_CAL_BLOCK_GCB = 2 +XRFDC_CAL_BLOCK_TSCB = 3 + + +# ============================================================================ +# Helpers +# ============================================================================ + +class PropertyDict(dict): + """Compatibility dict that triggers callback on updates.""" + def __init__(self, *args, **kwargs): + self.callback = lambda _: 0 + self.update(*args, **kwargs) + + def set_callback(self, callback): + self.callback = callback + + def __setitem__(self, key, value): + dict.__setitem__(self, key, value) + self.callback(self) + + def update(self, *args, **kwargs): + dict.update(self, *args, **kwargs) + self.callback(self) + + +def _as_property_dict(value, callback=None): + dct = PropertyDict(value) + if callback is not None: + dct.set_callback(callback) + return dct + + +class CalCoeffStruct(dict): + """Dict that also supports attribute access like CFFI struct. + Supports both cal['coeff0'] and cal.Coeff0. + """ + def __getattr__(self, name): + if name.startswith('Coeff'): + key = name.lower() + if key in self: + return self[key] + raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'") + + +# ============================================================================ +# HWH Config parsing (populates protobuf RFdcConfig from HWH parameters) +# ============================================================================ + +_DAC_ADP = [ + ('block_available', 'C_DAC_Slice{}{}_Enable', 'int'), + ('inv_sync_enable', 'C_DAC_Invsinc_Ctrl{}{}', 'int'), + ('mix_mode', 'C_DAC_Mixer_Mode{}{}', 'int'), + ('decoder_mode', 'C_DAC_Decoder_Mode{}{}', 'int') +] + +_DAC_DDP = [ + ('mixer_input_data_type', 'C_DAC_Data_Type{}{}', 'int'), + ('data_width', 'C_DAC_Data_Width{}{}', 'int'), + ('interpolation_mode', 'C_DAC_Interpolation_Mode{}{}', 'int'), + ('mixer_type', 'C_DAC_Mixer_Type{}{}', 'int') +] + +_ADC_ADP = [ + ('block_available', 'C_ADC_Slice{}{}_Enable', 'int'), + ('mix_mode', 'C_ADC_Mixer_Mode{}{}', 'int') +] + +_ADC_DDP = [ + ('mixer_input_data_type', 'C_ADC_Data_Type{}{}', 'int'), + ('data_width', 'C_ADC_Data_Width{}{}', 'int'), + ('decimation_mode', 'C_ADC_Decimation_Mode{}{}', 'int'), + ('mixer_type', 'C_ADC_Mixer_Type{}{}', 'int') +] + +_DAC_Tile = [ + ('enable', 'C_DAC{}_Enable', 'int'), + ('pll_enable', 'C_DAC{}_PLL_Enable', 'int'), + ('sampling_rate', 'C_DAC{}_Sampling_Rate', 'double'), + ('ref_clk_freq', 'C_DAC{}_Refclk_Freq', 'double'), + ('fab_clk_freq', 'C_DAC{}_Fabric_Freq', 'double'), + ('feedback_div', 'C_DAC{}_FBDIV', 'int'), + ('output_div', 'C_DAC{}_OutDiv', 'int'), + ('ref_clk_div', 'C_DAC{}_Refclk_Div', 'int'), + ('multiband_config', 'C_DAC{}_Band', 'int'), + ('max_sample_rate', 'C_DAC{}_Fs_Max', 'double'), + ('num_slices', 'C_DAC{}_Slices', 'int') +] + +_ADC_Tile = [ + ('enable', 'C_ADC{}_Enable', 'int'), + ('pll_enable', 'C_ADC{}_PLL_Enable', 'int'), + ('sampling_rate', 'C_ADC{}_Sampling_Rate', 'double'), + ('ref_clk_freq', 'C_ADC{}_Refclk_Freq', 'double'), + ('fab_clk_freq', 'C_ADC{}_Fabric_Freq', 'double'), + ('feedback_div', 'C_ADC{}_FBDIV', 'int'), + ('output_div', 'C_ADC{}_OutDiv', 'int'), + ('ref_clk_div', 'C_ADC{}_Refclk_Div', 'int'), + ('multiband_config', 'C_ADC{}_Band', 'int'), + ('max_sample_rate', 'C_ADC{}_Fs_Max', 'double'), + ('num_slices', 'C_ADC{}_Slices', 'int') +] + +_Config = [ + ('adc_type', 'C_High_Speed_ADC', 'int'), + ('adc_sysref_source', 'C_Sysref_Source', 'int'), + ('dac_sysref_source', 'C_Sysref_Source', 'int'), + ('ip_type', 'C_IP_Type', 'int'), + ('si_revision', 'C_Silicon_Revision', 'int') +] + +_bool_dict = {'true': 1, 'false': 0} + + +def _to_value(val, dtype): + if dtype == 'int': + return _bool_dict[val] if val in _bool_dict else int(val, 0) + elif dtype == 'double': + return float(val) + raise ValueError(f"{dtype} is not int or double") + + +def _set_configs(obj, params, config, *args): + for c in config: + setattr(obj, c[0], _to_value(params[c[1].format(*args)], c[2])) + + +def populate_config(obj, params): + _set_configs(obj, params, _Config) + for i in range(4): + dac_tile = obj.dac_tile_config.add() + _set_configs(dac_tile, params, _DAC_Tile, i) + adc_tile = obj.adc_tile_config.add() + _set_configs(adc_tile, params, _ADC_Tile, i) + for j in range(4): + dac_analog = dac_tile.dac_block_analog_config.add() + _set_configs(dac_analog, params, _DAC_ADP, i, j) + dac_digital = dac_tile.dac_block_digital_config.add() + _set_configs(dac_digital, params, _DAC_DDP, i, j) + adc_analog = adc_tile.adc_block_analog_config.add() + _set_configs(adc_analog, params, _ADC_ADP, i, j) + adc_digital = adc_tile.adc_block_digital_config.add() + _set_configs(adc_digital, params, _ADC_DDP, i, j) + + +# ============================================================================ +# Property factory functions (mirrors classic xrfdc's _create_c_property) +# ============================================================================ + +def _create_scalar_property(name, get_stub, get_field, set_stub=None, + set_req=None, set_kwarg=None): + """Generate a scalar property. Getter returns resp., + setter passes {set_kwarg: value} to the set request.""" + def _get(self): + return getattr(self._call_grpc(get_stub), get_field) + + if set_stub is None: + return property(_get) + + def _set(self, value): + self._call_grpc(set_stub, getattr(xrfdc_pb2, set_req), + **{set_kwarg: value}) + return property(_get, _set) + + +def _create_dict_property(name, get_stub, resp_attr, field_map, + set_stub=None, set_req=None, set_msg=None, + readonly=True, callback_event=None): + """Generate a dict property with PropertyDict callback support. + field_map: {PythonKey: grpc_field} for both get and set directions.""" + inv_map = {v: k for k, v in field_map.items()} + + def _do_get(self): + resp = self._call_grpc(get_stub) + src = getattr(resp, resp_attr) if resp_attr else resp + return {py_key: getattr(src, grpc_key) for py_key, grpc_key in field_map.items()} + + def _do_set(self, value): + kwargs = {grpc: value[inv_map[grpc]] for grpc in inv_map} + msg = getattr(xrfdc_pb2, set_msg)(**kwargs) + self._call_grpc(set_stub, getattr(xrfdc_pb2, set_req), settings=msg) + if callback_event is not None: + self.UpdateEvent(callback_event) + + def _get(self): + result = _do_get(self) + if readonly: + return _as_property_dict(result) + return _as_property_dict(result, callback=lambda v: _do_set(self, v)) + + if readonly: + return property(_get) + + def _set(self, value): + _do_set(self, value) + return property(_get, _set) + + +# ============================================================================ +# Property spec tables +# ============================================================================ + +# Block-level scalar properties: (name, get_stub, get_field, set_stub, set_req, set_kwarg) +_block_scalar_props = [ + ('NyquistZone', 'GetNyquistZone', 'nyquist_zone', + 'SetNyquistZone', 'SetNyquistZoneRequest', 'nyquist_zone'), + ('EnabledInterrupts', 'GetEnabledInterrupts', 'value'), +] + +# Block-level dict properties: (name, get_stub, resp_attr, field_map, set_stub, set_req, set_msg, readonly, callback_event) +_block_dict_props = [ + ('MixerSettings', 'GetMixerSettings', 'settings', + {'Freq': 'freq', 'PhaseOffset': 'phase_offset', 'EventSource': 'event_source', + 'CoarseMixFreq': 'coarse_mix_freq', 'MixerMode': 'mixer_mode', + 'FineMixerScale': 'fine_mixer_scale', 'MixerType': 'mixer_type'}, + 'SetMixerSettings', 'SetMixerSettingsRequest', 'MixerSettings', False, EVENT_MIXER), + ('QMCSettings', 'GetQMCSettings', 'settings', + {'EnablePhase': 'enable_phase', 'EnableGain': 'enable_gain', + 'EnableOffsetCorr': 'enable_offset_corr', + 'GainCorrectionFactor': 'gain_correction_factor', + 'PhaseCorrectionFactor': 'phase_correction_factor', + 'OffsetCorrectionFactor': 'offset_correction_factor', + 'EventSource': 'event_source'}, + 'SetQMCSettings', 'SetQMCSettingsRequest', 'QMCSettings', False, None), + ('CoarseDelaySettings', 'GetCoarseDelaySettings', 'settings', + {'CoarseDelay': 'coarse_delay', 'EventSource': 'event_source'}, + 'SetCoarseDelaySettings', 'SetCoarseDelaySettingsRequest', 'CoarseDelaySettings', + False, None), + ('PwrMode', 'GetPwrMode', 'settings', + {'DisableIPControl': 'disable_ip_control', 'PwrMode': 'pwr_mode'}, + 'SetPwrMode', 'SetPwrModeRequest', 'PwrModeSettings', False, None), +] + +# ADC block scalar properties +_adc_scalar_props = [ + ('DecimationFactor', 'GetDecimationFactor', 'dec_factor', + 'SetDecimationFactor', 'SetDecimationFactorRequest', 'dec_factor'), + ('CalibrationMode', 'GetCalibrationMode', 'value', + 'SetCalibrationMode', 'SetCalibrationModeRequest', 'value'), + ('FabRdVldWords', 'GetFabRdVldWords', 'value', + 'SetFabRdVldWords', 'SetFabRdVldWordsRequest', 'value'), + ('FabWrVldWords', 'GetFabWrVldWords', 'value'), + ('DecimationFactorObs', 'GetDecimationFactorObs', 'dec_factor', + 'SetDecimationFactorObs', 'SetDecimationFactorRequest', 'dec_factor'), + ('FabRdVldWordsObs', 'GetFabRdVldWordsObs', 'value', + 'SetFabRdVldWordsObs', 'SetFabRdVldWordsRequest', 'value'), + ('FabWrVldWordsObs', 'GetFabWrVldWordsObs', 'value'), + ('Dither', 'GetDither', 'value', + 'SetDither', 'SetDitherRequest', 'value'), +] + +# ADC block dict properties +_adc_dict_props = [ + ('CalFreeze', 'GetCalFreeze', 'settings', + {'CalFrozen': 'cal_frozen', 'DisableFreezePin': 'disable_freeze_pin', + 'FreezeCalibration': 'freeze_calibration'}, + 'SetCalFreeze', 'SetCalFreezeRequest', 'CalFreezeSettings', False, None), + ('DSA', 'GetDSA', 'settings', + {'DisableRTS': 'disable_rts', 'Attenuation': 'attenuation'}, + 'SetDSA', 'SetDSARequest', 'DSASettings', False, None), +] + +# DAC block scalar properties +_dac_scalar_props = [ + ('InterpolationFactor', 'GetInterpolationFactor', 'interp_factor', + 'SetInterpolationFactor', 'SetInterpolationFactorRequest', 'interp_factor'), + ('DecoderMode', 'GetDecoderMode', 'value', + 'SetDecoderMode', 'SetDecoderModeRequest', 'value'), + ('OutputCurr', 'GetOutputCurr', 'value'), + ('InvSincFIR', 'GetInvSincFIR', 'value', + 'SetInvSincFIR', 'SetInvSincFIRRequest', 'value'), + ('FabRdVldWords', 'GetFabRdVldWords', 'value'), + ('FabWrVldWords', 'GetFabWrVldWords', 'value', + 'SetFabWrVldWords', 'SetFabWrVldWordsRequest', 'value'), + ('DataPathMode', 'GetDataPathMode', 'value', + 'SetDataPathMode', 'SetDataPathModeRequest', 'value'), + ('IMRPassMode', 'GetIMRPassMode', 'value', + 'SetIMRPassMode', 'SetIMRPassModeRequest', 'value'), + ('DACCompMode', 'GetDACCompMode', 'value', + 'SetDACCompMode', 'SetDACCompModeRequest', 'value'), +] + +# Tile scalar properties +_tile_scalar_props = [ + ('FabClkOutDiv', 'GetFabClkOutDiv', 'fab_clk_div', + 'SetFabClkOutDiv', 'SetFabClkOutDivRequest', 'fab_clk_div'), + ('FIFOStatus', 'GetFIFOStatus', 'enable'), + ('ClockSource', 'GetClockSource', 'clock_source'), + ('PLLLockStatus', 'GetPLLLockStatus', 'lock_status'), +] + +# Tile dict properties +_tile_dict_props = [ + ('PLLConfig', 'GetPLLConfig', 'settings', + {'Enabled': 'enabled', 'RefClkFreq': 'ref_clk_freq', 'SampleRate': 'sample_rate', + 'RefClkDivider': 'ref_clk_divider', 'FeedbackDivider': 'feedback_divider', + 'OutputDivider': 'output_divider', 'FractionalMode': 'fractional_mode', + 'FractionalData': 'fractional_data', 'FractWidth': 'fract_width'}, + None, None, None, True, None), +] + + +# ============================================================================ +# Tile and Block Hierarchy +# ============================================================================ + +class RFdcThreshold: + def __init__(self, parent, index): + self._parent = parent + self._index = index + + def SetClrMode(self, clr_mode): + self._parent._call_grpc( + 'SetThresholdClrMode', xrfdc_pb2.SetThresholdClrModeRequest, + threshold_to_update=self._index + 1, clr_mode=clr_mode) + + def StickyClear(self): + self._parent._call_grpc( + 'ThresholdStickyClear', xrfdc_pb2.ThresholdStickyClearRequest, + threshold_to_update=self._index + 1) + + @property + def Settings(self): + raw = self._parent.GetThresholdSettings() + return { + 'ThresholdMode': raw['ThresholdMode'][self._index], + 'ThresholdAvgVal': raw['ThresholdAvgVal'][self._index], + 'ThresholdUnderVal': raw['ThresholdUnderVal'][self._index], + 'ThresholdOverVal': raw['ThresholdOverVal'][self._index], + } + + @Settings.setter + def Settings(self, settings): + self._parent.SetThresholdSettings( + update_threshold=self._index + 1, + threshold_mode=settings['ThresholdMode'], + threshold_avg_val=settings['ThresholdAvgVal'], + threshold_under_val=settings['ThresholdUnderVal'], + threshold_over_val=settings['ThresholdOverVal']) + + +class RFdcBlock: + """Base class for RFdc block — shared by ADC and DAC blocks.""" + def __init__(self, parent, index): + self._parent = parent + self._index = index + + def _call_grpc(self, method_name, req_class=None, **kwargs): + if req_class is None: + req_class = xrfdc_pb2.BlockRequest + # Build block-identification fields, only including those the + # protobuf message actually defines (some Set* messages omit + # tile_type because they are ADC-only or DAC-only). + descriptor = req_class.DESCRIPTOR + field_names = {f.name for f in descriptor.fields} + id_fields = {} + if 'tile_type' in field_names: + id_fields['tile_type'] = self._parent._type + if 'tile_id' in field_names: + id_fields['tile_id'] = self._parent._index + if 'block_id' in field_names: + id_fields['block_id'] = self._index + req = req_class(**id_fields, **kwargs) + resp = getattr(self._parent._parent._stub, method_name)(req) + if resp.status.code != 0: + raise RuntimeError(f"{method_name} failed: {resp.status.message}") + return resp + + # --- Explicit methods (unique logic or keyword-arg API) --- + + def SetupFIFO(self, enable): + self._call_grpc('SetupFIFO', xrfdc_pb2.SetupFIFORequest, enable=enable) + + def GetBlockStatus(self): + resp = self._call_grpc('GetBlockStatus') + samp_freq = resp.sampling_freq + if samp_freq == 0: + rfdc = self._parent._parent + if hasattr(rfdc, 'config_pb'): + tile_id = self._parent._index + try: + if self._parent._type == XRFDC_DAC_TILE: + hwh_rate = rfdc.config_pb.dac_tile_config[tile_id].sampling_rate + else: + hwh_rate = rfdc.config_pb.adc_tile_config[tile_id].sampling_rate + if hwh_rate > 0: + samp_freq = hwh_rate + except (IndexError, AttributeError): + pass + return { + 'SamplingFreq': samp_freq, + 'AnalogDataPathStatus': resp.analog_data_path_status, + 'DigitalDataPathStatus': resp.digital_data_path_status, + 'DataPathClocksStatus': resp.data_path_clocks_status, + 'IsFIFOFlagsEnabled': resp.is_fifo_flags_enabled, + 'IsFIFOFlagsAsserted': resp.is_fifo_flags_asserted, + } + + @property + def BlockStatus(self): + return _as_property_dict(self.GetBlockStatus()) + + def GetFIFOStatus(self): + resp = self._call_grpc('GetFIFOStatus') + return {'Enable': resp.enable} + + def SetMixerSettings(self, freq, phase_offset=0.0, event_source=EVNT_SRC_IMMEDIATE, + coarse_mix_freq=COARSE_MIX_OFF, mixer_mode=MIXER_MODE_C2C, + fine_mixer_scale=MIXER_SCALE_AUTO, mixer_type=MIXER_TYPE_FINE): + settings = xrfdc_pb2.MixerSettings( + freq=freq, phase_offset=phase_offset, event_source=event_source, + coarse_mix_freq=coarse_mix_freq, mixer_mode=mixer_mode, + fine_mixer_scale=fine_mixer_scale, mixer_type=mixer_type) + self._call_grpc('SetMixerSettings', xrfdc_pb2.SetMixerSettingsRequest, + settings=settings) + + def GetMixerSettings(self): + s = self._call_grpc('GetMixerSettings').settings + return {'Freq': s.freq, 'PhaseOffset': s.phase_offset, + 'EventSource': s.event_source, 'CoarseMixFreq': s.coarse_mix_freq, + 'MixerMode': s.mixer_mode, 'FineMixerScale': s.fine_mixer_scale, + 'MixerType': s.mixer_type} + + def SetQMCSettings(self, enable_phase=False, enable_gain=False, enable_offset_corr=False, + gain_correction_factor=0.0, phase_correction_factor=0.0, + offset_correction_factor=0, event_source=EVNT_SRC_IMMEDIATE): + settings = xrfdc_pb2.QMCSettings( + enable_phase=enable_phase, enable_gain=enable_gain, + enable_offset_corr=enable_offset_corr, + gain_correction_factor=gain_correction_factor, + phase_correction_factor=phase_correction_factor, + offset_correction_factor=offset_correction_factor, + event_source=event_source) + self._call_grpc('SetQMCSettings', xrfdc_pb2.SetQMCSettingsRequest, + settings=settings) + + def GetQMCSettings(self): + s = self._call_grpc('GetQMCSettings').settings + return {'EnablePhase': s.enable_phase, 'EnableGain': s.enable_gain, + 'EnableOffsetCorr': s.enable_offset_corr, + 'GainCorrectionFactor': s.gain_correction_factor, + 'PhaseCorrectionFactor': s.phase_correction_factor, + 'OffsetCorrectionFactor': s.offset_correction_factor, + 'EventSource': s.event_source} + + def SetCoarseDelaySettings(self, coarse_delay, event_source=EVNT_SRC_IMMEDIATE): + settings = xrfdc_pb2.CoarseDelaySettings( + coarse_delay=coarse_delay, event_source=event_source) + self._call_grpc('SetCoarseDelaySettings', + xrfdc_pb2.SetCoarseDelaySettingsRequest, settings=settings) + + def GetCoarseDelaySettings(self): + s = self._call_grpc('GetCoarseDelaySettings', + xrfdc_pb2.GetCoarseDelaySettingsRequest).settings + return {'CoarseDelay': s.coarse_delay, 'EventSource': s.event_source} + + def GetPwrMode(self): + s = self._call_grpc('GetPwrMode').settings + return {'DisableIPControl': s.disable_ip_control, 'PwrMode': s.pwr_mode} + + def SetPwrMode(self, disable_ip_control, pwr_mode): + settings = xrfdc_pb2.PwrModeSettings( + disable_ip_control=disable_ip_control, pwr_mode=pwr_mode) + self._call_grpc('SetPwrMode', xrfdc_pb2.SetPwrModeRequest, settings=settings) + + def ResetNCOPhase(self): + self._call_grpc('ResetNCOPhase', xrfdc_pb2.ResetNCOPhaseRequest) + + def UpdateEvent(self, Event): + self._call_grpc('UpdateEvent', xrfdc_pb2.UpdateEventRequest, event=Event) + + def ResetInternalFIFOWidth(self): + self._call_grpc('ResetInternalFIFOWidth') + + def GetConnectedIData(self): + return self._call_grpc('GetConnectedIData').value + + def GetConnectedQData(self): + return self._call_grpc('GetConnectedQData').value + + +class RFdcAdcBlock(RFdcBlock): + """ADC block with ADC-specific methods.""" + def __init__(self, parent, index): + super().__init__(parent, index) + self.thresholds = [RFdcThreshold(self, i) for i in range(2)] + + def SetDecimationFactor(self, dec_factor): + self._call_grpc('SetDecimationFactor', + xrfdc_pb2.SetDecimationFactorRequest, dec_factor=dec_factor) + + def GetDecimationFactor(self): + return self._call_grpc('GetDecimationFactor').dec_factor + + def SetThresholdSettings(self, update_threshold, threshold_mode, + threshold_avg_val, threshold_under_val=0, + threshold_over_val=0): + def _pack(value): + if update_threshold == 1: + return [value, 0] + if update_threshold == 2: + return [0, value] + if update_threshold == 3: + return [value, value] + raise ValueError("update_threshold must be 1, 2, or 3.") + + settings = xrfdc_pb2.ThresholdSettings( + update_threshold=update_threshold, + threshold_mode=_pack(threshold_mode), + threshold_avg_val=_pack(threshold_avg_val), + threshold_under_val=_pack(threshold_under_val), + threshold_over_val=_pack(threshold_over_val)) + self._call_grpc('SetThresholdSettings', + xrfdc_pb2.SetThresholdSettingsRequest, settings=settings) + + def GetThresholdSettings(self): + s = self._call_grpc('GetThresholdSettings').settings + return {'UpdateThreshold': s.update_threshold, + 'ThresholdMode': list(s.threshold_mode), + 'ThresholdAvgVal': list(s.threshold_avg_val), + 'ThresholdUnderVal': list(s.threshold_under_val), + 'ThresholdOverVal': list(s.threshold_over_val)} + + def SetDecimationFactorObs(self, dec_factor): + self._call_grpc('SetDecimationFactorObs', + xrfdc_pb2.SetDecimationFactorRequest, dec_factor=dec_factor) + + def DisableCoefficientsOverride(self, CalibrationBlock): + self._call_grpc('DisableCoefficientsOverride', + xrfdc_pb2.DisableCoefficientsOverrideRequest, + calibration_block=CalibrationBlock) + + def ResetInternalFIFOWidthObs(self): + self._call_grpc('ResetInternalFIFOWidthObs') + + def SetCalCoefficients(self, CalibrationBlock, *args, **kwargs): + """Set calibration coefficients. + Supports: (block, struct), (block, c0..c7), (block, coeff0=v, ...) + """ + if len(args) == 1 and hasattr(args[0], 'Coeff0'): + coeffs_list = [getattr(args[0], f'Coeff{i}', 0) for i in range(8)] + elif len(args) >= 7: + coeffs_list = list(args[:8]) + [0] * (8 - len(args)) + elif kwargs: + coeffs_list = [kwargs.get(f'coeff{i}', 0) for i in range(8)] + else: + raise ValueError( + "SetCalCoefficients requires: (1) CFFI struct with Coeff0-Coeff7, " + "(2) 7-8 positional values, or (3) keyword args coeff0-coeff7") + coeffs = xrfdc_pb2.CalibrationCoefficients( + **{f'coeff{i}': coeffs_list[i] for i in range(8)}) + self._call_grpc('SetCalCoefficients', + xrfdc_pb2.SetCalCoefficientsRequest, + calibration_block=CalibrationBlock, coeffs=coeffs) + + def GetCalCoefficients(self, CalibrationBlock): + resp = self._call_grpc('GetCalCoefficients', + xrfdc_pb2.GetCalCoefficientsRequest, + calibration_block=CalibrationBlock) + return CalCoeffStruct({f'coeff{i}': getattr(resp.coeffs, f'coeff{i}') + for i in range(8)}) + + def IntrHandler(self, *args, **kwargs): + raise NotImplementedError( + "Interrupt handlers are not supported in PYNQ.remote mode.") + + def IntrEnable(self, *args, **kwargs): + raise NotImplementedError( + "Interrupt control is not supported in PYNQ.remote mode.") + + def IntrDisable(self, *args, **kwargs): + raise NotImplementedError( + "Interrupt control is not supported in PYNQ.remote mode.") + + def IntrClear(self, *args, **kwargs): + raise NotImplementedError( + "Interrupt control is not supported in PYNQ.remote mode.") + + +class RFdcDacBlock(RFdcBlock): + """DAC block with DAC-specific methods.""" + + def SetInterpolationFactor(self, interp_factor): + self._call_grpc('SetInterpolationFactor', + xrfdc_pb2.SetInterpolationFactorRequest, + interp_factor=interp_factor) + + def GetInterpolationFactor(self): + return self._call_grpc('GetInterpolationFactor').interp_factor + + def SetDACVOP(self, uACurrent): + self._call_grpc('SetDACVOP', xrfdc_pb2.SetDACVOPRequest, + uA_current=uACurrent) + + +class RFdcTile: + """Base tile class.""" + def __init__(self, parent, index): + self._parent = parent + self._index = index + self._type = None # Set by subclass + + def _call_grpc(self, method_name, req_class=None, **kwargs): + if req_class is None: + req_class = xrfdc_pb2.TileRequest + req = req_class(tile_type=self._type, tile_id=self._index, **kwargs) + resp = getattr(self._parent._stub, method_name)(req) + if resp.status.code != 0: + raise RuntimeError(f"{method_name} failed: {resp.status.message}") + return resp + + def StartUp(self): + self._call_grpc('StartUp', xrfdc_pb2.TileControlRequest) + + def Shutdown(self): + self._call_grpc('Shutdown', xrfdc_pb2.TileControlRequest) + + def ShutDown(self): + self.Shutdown() + + def Reset(self): + self._call_grpc('Reset', xrfdc_pb2.TileControlRequest) + + def SetupFIFO(self, Enable, block_id=0): + self._call_grpc('SetupFIFO', xrfdc_pb2.SetupFIFORequest, + enable=Enable, block_id=block_id) + + def DynamicPLLConfig(self, source, ref_clk_freq, samp_rate): + """Configure PLL dynamically. Auto-calls StartUp() for cold tiles.""" + from time import sleep + self._call_grpc('DynamicPLLConfig', xrfdc_pb2.DynamicPLLConfigRequest, + source=source, ref_clk_freq=ref_clk_freq, samp_rate=samp_rate) + sleep(0.6) + self.StartUp() + + def DumpRegs(self): + self._call_grpc('DumpRegs') + + def GetPLLConfig(self): + s = self._call_grpc('GetPLLConfig').settings + return {'Enabled': s.enabled, 'RefClkFreq': s.ref_clk_freq, + 'SampleRate': s.sample_rate, 'RefClkDivider': s.ref_clk_divider, + 'FeedbackDivider': s.feedback_divider, + 'OutputDivider': s.output_divider, + 'FractionalMode': s.fractional_mode, + 'FractionalData': s.fractional_data, 'FractWidth': s.fract_width} + + +class RFdcAdcTile(RFdcTile): + """ADC tile with blocks.""" + def __init__(self, parent, index): + super().__init__(parent, index) + self._type = XRFDC_ADC_TILE + self.blocks = [RFdcAdcBlock(self, i) for i in range(4)] + + def SetupFIFOObs(self, Enable): + self._call_grpc('SetupFIFOObs', xrfdc_pb2.SetupFIFORequest, + enable=Enable, block_id=0) + + def SetupFIFOBoth(self, Enable): + self._call_grpc('SetupFIFOBoth', xrfdc_pb2.SetupFIFORequest, + enable=Enable, block_id=0) + + def GetFIFOStatusObs(self): + resp = self._call_grpc('GetFIFOStatusObs') + return {'Enable': resp.enable} + + +class RFdcDacTile(RFdcTile): + """DAC tile with blocks.""" + def __init__(self, parent, index): + super().__init__(parent, index) + self._type = XRFDC_DAC_TILE + self.blocks = [RFdcDacBlock(self, i) for i in range(4)] + + +# ============================================================================ +# Attach data-driven properties to classes (like classic xrfdc) +# ============================================================================ + +for spec in _block_scalar_props: + setattr(RFdcBlock, spec[0], _create_scalar_property(*spec)) +for spec in _block_dict_props: + setattr(RFdcBlock, spec[0], _create_dict_property(*spec)) + +for spec in _adc_scalar_props: + setattr(RFdcAdcBlock, spec[0], _create_scalar_property(*spec)) +for spec in _adc_dict_props: + setattr(RFdcAdcBlock, spec[0], _create_dict_property(*spec)) + +for spec in _dac_scalar_props: + setattr(RFdcDacBlock, spec[0], _create_scalar_property(*spec)) + +for spec in _tile_scalar_props: + setattr(RFdcTile, spec[0], _create_scalar_property(*spec)) +for spec in _tile_dict_props: + setattr(RFdcTile, spec[0], _create_dict_property(*spec)) + + +# ============================================================================ +# Top-Level RFdc Class +# ============================================================================ + +class RFdc(DefaultIP): + """Remote driver for Xilinx RF Data Converter with automatic initialization. + + Communicates with RFdc hardware via gRPC. API-compatible with classic + xrfdc.RFdc. RFDC is automatically configured upon instantiation. + """ + + bindto = ["xilinx.com:ip:usp_rf_data_converter:2.6", + "xilinx.com:ip:usp_rf_data_converter:2.4", + "xilinx.com:ip:usp_rf_data_converter:2.3"] + + def __init__(self, description, clock_config=None, enabled_tiles=None): + if 'parameters' not in description: + raise ValueError("RFdc requires HWH parameters in description") + + super().__init__(description) + + # Create/get stub + if not hasattr(self.device, '_stub'): + self.device._stub = {} + if 'xrfdc' not in self.device._stub: + self.device._stub['xrfdc'] = xrfdc_pb2_grpc.XrfdcStub( + self.device.client.channel) + self._stub = self.device._stub['xrfdc'] + + # Extract base address + if 'phys_addr' in description: + base_addr = description['phys_addr'] + elif 'addr_range' in description: + base_addr = description['addr_range'][0] + else: + raise ValueError("Cannot determine base address from description") + + # Extract size + if 'addr_range' in description: + ar = description['addr_range'] + if isinstance(ar, list) and len(ar) >= 2: + size = ar[1] - ar[0] + elif isinstance(ar, int): + size = ar + else: + raise ValueError(f"Unexpected addr_range shape: {ar!r}") + elif 'size' in description: + size = description['size'] + else: + raise ValueError("Cannot determine RFDC register region size from description") + + # Build config from HWH parameters + self.config_pb = xrfdc_pb2.RFdcConfig() + populate_config(self.config_pb, description['parameters']) + self.config_pb.base_addr = base_addr + + # Initialize remote instance + req = xrfdc_pb2.CfgInitializeRequest(config=self.config_pb, size=size) + resp = self._stub.CfgInitialize(req) + if resp.status.code != 0: + raise RuntimeError(f"Remote RFdc init failed: {resp.status.message}") + + # Create tile hierarchy (length comes from the populated HWH config) + self.adc_tiles = [RFdcAdcTile(self, i) + for i in range(len(self.config_pb.adc_tile_config))] + self.dac_tiles = [RFdcDacTile(self, i) + for i in range(len(self.config_pb.dac_tile_config))] + + def _detect_enabled_tiles(self): + """Auto-detect which tiles are enabled from HWH configuration.""" + return { + 'dac': [i for i, tc in enumerate(self.config_pb.dac_tile_config) if tc.enable], + 'adc': [i for i, tc in enumerate(self.config_pb.adc_tile_config) if tc.enable], + } + + def startup_tiles(self, enabled_tiles=None): + """Configure and start the enabled RFDC tiles from the HWH clock settings. + + ref_clk_freq is MHz; sampling_rate is GHz and DynamicPLLConfig wants MSPS. + """ + from time import sleep + if enabled_tiles is None: + enabled_tiles = self._detect_enabled_tiles() + + for tile_id in enabled_tiles.get('dac', []): + tile = self.dac_tiles[tile_id] + tc = self.config_pb.dac_tile_config[tile_id] + try: + tile.ShutDown() + sleep(0.2) + except Exception: + pass + tile.DynamicPLLConfig(CLK_SRC_PLL, tc.ref_clk_freq, tc.sampling_rate * 1000) + try: + tile.SetupFIFO(True) + except Exception: + pass + + for tile_id in enabled_tiles.get('adc', []): + tile = self.adc_tiles[tile_id] + tc = self.config_pb.adc_tile_config[tile_id] + try: + tile.ShutDown() + sleep(0.2) + except Exception: + pass + tile.DynamicPLLConfig(CLK_SRC_PLL, tc.ref_clk_freq, tc.sampling_rate * 1000) + try: + tile.SetupFIFO(True) + except Exception: + pass + + @property + def IPStatus(self): + req = xrfdc_pb2.GetIPStatusRequest() + resp = self._stub.GetIPStatus(req) + if resp.status.code != 0: + raise RuntimeError(f"GetIPStatus failed: {resp.status.message}") + + def _tile_status(tile): + blocks = [] + for b in tile.block_status: + blocks.append({ + 'SamplingFreq': b.sampling_freq, + 'AnalogDataPathStatus': int(b.analog_data_path_status), + 'DigitalDataPathStatus': int(b.digital_data_path_status), + 'DataPathClocksStatus': b.data_path_clocks_status, + 'IsFIFOFlagsEnabled': int(b.is_fifo_flags_enabled), + 'IsFIFOFlagsAsserted': int(b.is_fifo_flags_asserted), + }) + return { + 'IsEnabled': tile.is_enabled, + 'TileState': tile.tile_state, + 'BlockStatusMask': tile.block_status_mask, + 'PowerUpState': tile.power_up_state, + 'PLLState': tile.pll_state, + 'BlockStatus': blocks, + } + + return _as_property_dict({ + 'DACTileStatus': [_tile_status(t) for t in resp.ip_status.dac_tile_status], + 'ADCTileStatus': [_tile_status(t) for t in resp.ip_status.adc_tile_status], + 'State': resp.ip_status.state, + }) + + def GetClkDistribution(self): + req = xrfdc_pb2.GetClkDistributionRequest() + resp = self._stub.GetClkDistribution(req) + if resp.status.code != 0: + raise RuntimeError(f"GetClkDistribution failed: {resp.status.message}") + + def _tile_clk(ts): + return {'SourceType': ts.source_type, 'SourceTile': ts.source_tile, + 'PLLEnable': ts.pll_enable, 'RefClkFreq': ts.ref_clk_freq, + 'SampleRate': ts.sample_rate, 'DivisionFactor': ts.division_factor, + 'DistributedClock': ts.distributed_clock, 'Delay': ts.delay} + + dist = resp.settings.distribution_info + return { + 'DAC': [_tile_clk(t) for t in resp.settings.dac], + 'ADC': [_tile_clk(t) for t in resp.settings.adc], + 'DistributionInfo': { + 'Source': dist.source, 'UpperBound': dist.upper_bound, + 'LowerBound': dist.lower_bound, 'MaxDelay': dist.max_delay, + 'MinDelay': dist.min_delay, 'IsDelayBalanced': dist.is_delay_balanced, + }, + } + + def SetClkDistribution(self, distribution_settings): + settings = xrfdc_pb2.ClkDistributionSettings() + _CLK_DIST_FIELDS = { + 'SourceType': 'source_type', 'SourceTile': 'source_tile', + 'PLLEnable': 'pll_enable', 'RefClkFreq': 'ref_clk_freq', + 'SampleRate': 'sample_rate', 'DivisionFactor': 'division_factor', + 'DistributedClock': 'distributed_clock', 'Delay': 'delay', + } + for d in distribution_settings.get('DAC', []): + t = settings.dac.add() + for k, v in d.items(): + setattr(t, _CLK_DIST_FIELDS[k], v) + for d in distribution_settings.get('ADC', []): + t = settings.adc.add() + for k, v in d.items(): + setattr(t, _CLK_DIST_FIELDS[k], v) + if 'DistributionInfo' in distribution_settings: + di = distribution_settings['DistributionInfo'] + settings.distribution_info.source = di.get('Source', 0) + settings.distribution_info.upper_bound = di.get('UpperBound', 0) + settings.distribution_info.lower_bound = di.get('LowerBound', 0) + settings.distribution_info.max_delay = di.get('MaxDelay', 0) + settings.distribution_info.min_delay = di.get('MinDelay', 0) + settings.distribution_info.is_delay_balanced = di.get('IsDelayBalanced', 0) + + req = xrfdc_pb2.SetClkDistributionRequest(settings=settings) + resp = self._stub.SetClkDistribution(req) + if resp.status.code != 0: + raise RuntimeError(f"SetClkDistribution failed: {resp.status.message}") + + @property + def ClkDistribution(self): + settings = self.GetClkDistribution() + return _as_property_dict(settings, callback=lambda v: self.SetClkDistribution(v)) + + @ClkDistribution.setter + def ClkDistribution(self, value): + self.SetClkDistribution(value) diff --git a/pynq/remote/xrfdc_pb2.py b/pynq/remote/xrfdc_pb2.py new file mode 100644 index 000000000..c5c09c0b1 --- /dev/null +++ b/pynq/remote/xrfdc_pb2.py @@ -0,0 +1,226 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: xrfdc.proto +# Protobuf Python Version: 5.26.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0bxrfdc.proto\x12\x05xrfdc\"{\n\x06Status\x12\x0c\n\x04\x63ode\x18\x01 \x01(\r\x12\x0f\n\x07message\x18\x02 \x01(\t\x12\x11\n\toperation\x18\x04 \x01(\t\x12\x16\n\x0etile_type_name\x18\x05 \x01(\t\x12\x0f\n\x07tile_id\x18\x06 \x01(\x05\x12\x10\n\x08\x62lock_id\x18\x07 \x01(\x05J\x04\x08\x03\x10\x04\"\xda\x01\n\x0b\x42lockStatus\x12\x15\n\rsampling_freq\x18\x01 \x01(\x01\x12\x1f\n\x17\x61nalog_data_path_status\x18\x02 \x01(\r\x12 \n\x18\x64igital_data_path_status\x18\x03 \x01(\r\x12\x1f\n\x17\x64\x61ta_path_clocks_status\x18\x04 \x01(\r\x12\x1d\n\x15is_fifo_flags_enabled\x18\x05 \x01(\r\x12\x11\n\tib_supply\x18\x06 \x01(\r\x12\x1e\n\x16is_fifo_flags_asserted\x18\x07 \x01(\r\"\xa4\x01\n\nTileStatus\x12\x12\n\nis_enabled\x18\x01 \x01(\r\x12\x12\n\ntile_state\x18\x02 \x01(\r\x12\x19\n\x11\x62lock_status_mask\x18\x03 \x01(\r\x12\x16\n\x0epower_up_state\x18\x04 \x01(\r\x12\x11\n\tpll_state\x18\x05 \x01(\r\x12(\n\x0c\x62lock_status\x18\x06 \x03(\x0b\x32\x12.xrfdc.BlockStatus\"q\n\x08IPStatus\x12*\n\x0f\x64\x61\x63_tile_status\x18\x01 \x03(\x0b\x32\x11.xrfdc.TileStatus\x12*\n\x0f\x61\x64\x63_tile_status\x18\x02 \x03(\x0b\x32\x11.xrfdc.TileStatus\x12\r\n\x05state\x18\x03 \x01(\r\"x\n\x1c\x44\x41\x43\x42lockAnalogDataPathConfig\x12\x17\n\x0f\x62lock_available\x18\x01 \x01(\r\x12\x17\n\x0finv_sync_enable\x18\x02 \x01(\r\x12\x10\n\x08mix_mode\x18\x03 \x01(\r\x12\x14\n\x0c\x64\x65\x63oder_mode\x18\x04 \x01(\r\"\xad\x01\n\x1d\x44\x41\x43\x42lockDigitalDataPathConfig\x12\x1d\n\x15mixer_input_data_type\x18\x01 \x01(\r\x12\x12\n\ndata_width\x18\x02 \x01(\r\x12\x1a\n\x12interpolation_mode\x18\x03 \x01(\r\x12\x13\n\x0b\x66ifo_enable\x18\x04 \x01(\r\x12\x14\n\x0c\x61\x64\x64\x65r_enable\x18\x05 \x01(\r\x12\x12\n\nmixer_type\x18\x06 \x01(\r\"I\n\x1c\x41\x44\x43\x42lockAnalogDataPathConfig\x12\x17\n\x0f\x62lock_available\x18\x01 \x01(\r\x12\x10\n\x08mix_mode\x18\x02 \x01(\r\"\x94\x01\n\x1d\x41\x44\x43\x42lockDigitalDataPathConfig\x12\x1d\n\x15mixer_input_data_type\x18\x01 \x01(\r\x12\x12\n\ndata_width\x18\x02 \x01(\r\x12\x17\n\x0f\x64\x65\x63imation_mode\x18\x03 \x01(\r\x12\x13\n\x0b\x66ifo_enable\x18\x04 \x01(\r\x12\x12\n\nmixer_type\x18\x05 \x01(\r\"\x8a\x03\n\rDACTileConfig\x12\x0e\n\x06\x65nable\x18\x01 \x01(\r\x12\x12\n\npll_enable\x18\x02 \x01(\r\x12\x15\n\rsampling_rate\x18\x03 \x01(\x01\x12\x14\n\x0cref_clk_freq\x18\x04 \x01(\x01\x12\x14\n\x0c\x66\x61\x62_clk_freq\x18\x05 \x01(\x01\x12\x14\n\x0c\x66\x65\x65\x64\x62\x61\x63k_div\x18\x06 \x01(\r\x12\x12\n\noutput_div\x18\x07 \x01(\r\x12\x13\n\x0bref_clk_div\x18\x08 \x01(\r\x12\x18\n\x10multiband_config\x18\t \x01(\r\x12\x17\n\x0fmax_sample_rate\x18\n \x01(\x01\x12\x12\n\nnum_slices\x18\x0b \x01(\r\x12\x44\n\x17\x64\x61\x63_block_analog_config\x18\x0c \x03(\x0b\x32#.xrfdc.DACBlockAnalogDataPathConfig\x12\x46\n\x18\x64\x61\x63_block_digital_config\x18\r \x03(\x0b\x32$.xrfdc.DACBlockDigitalDataPathConfig\"\x8a\x03\n\rADCTileConfig\x12\x0e\n\x06\x65nable\x18\x01 \x01(\r\x12\x12\n\npll_enable\x18\x02 \x01(\r\x12\x15\n\rsampling_rate\x18\x03 \x01(\x01\x12\x14\n\x0cref_clk_freq\x18\x04 \x01(\x01\x12\x14\n\x0c\x66\x61\x62_clk_freq\x18\x05 \x01(\x01\x12\x14\n\x0c\x66\x65\x65\x64\x62\x61\x63k_div\x18\x06 \x01(\r\x12\x12\n\noutput_div\x18\x07 \x01(\r\x12\x13\n\x0bref_clk_div\x18\x08 \x01(\r\x12\x18\n\x10multiband_config\x18\t \x01(\r\x12\x17\n\x0fmax_sample_rate\x18\n \x01(\x01\x12\x12\n\nnum_slices\x18\x0b \x01(\r\x12\x44\n\x17\x61\x64\x63_block_analog_config\x18\x0c \x03(\x0b\x32#.xrfdc.ADCBlockAnalogDataPathConfig\x12\x46\n\x18\x61\x64\x63_block_digital_config\x18\r \x03(\x0b\x32$.xrfdc.ADCBlockDigitalDataPathConfig\"\xb0\x02\n\nRFdcConfig\x12\x11\n\tdevice_id\x18\x01 \x01(\r\x12\x11\n\tbase_addr\x18\x02 \x01(\x04\x12\x10\n\x08\x61\x64\x63_type\x18\x03 \x01(\r\x12\x17\n\x0fmaster_adc_tile\x18\x04 \x01(\r\x12\x17\n\x0fmaster_dac_tile\x18\x05 \x01(\r\x12\x19\n\x11\x61\x64\x63_sysref_source\x18\x06 \x01(\r\x12\x19\n\x11\x64\x61\x63_sysref_source\x18\x07 \x01(\r\x12\x0f\n\x07ip_type\x18\x08 \x01(\r\x12\x13\n\x0bsi_revision\x18\t \x01(\r\x12-\n\x0f\x64\x61\x63_tile_config\x18\n \x03(\x0b\x32\x14.xrfdc.DACTileConfig\x12-\n\x0f\x61\x64\x63_tile_config\x18\x0b \x03(\x0b\x32\x14.xrfdc.ADCTileConfig\"G\n\x14\x43\x66gInitializeRequest\x12!\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x11.xrfdc.RFdcConfig\x12\x0c\n\x04size\x18\x02 \x01(\x04\"6\n\x15\x43\x66gInitializeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\"\x14\n\x12GetIPStatusRequest\"X\n\x13GetIPStatusResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\"\n\tip_status\x18\x02 \x01(\x0b\x32\x0f.xrfdc.IPStatus\"8\n\x12TileControlRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\"4\n\x13TileControlResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\"X\n\x10SetupFIFORequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x0e\n\x06\x65nable\x18\x03 \x01(\x08\x12\x10\n\x08\x62lock_id\x18\x04 \x01(\r\"v\n\x17\x44ynamicPLLConfigRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x0e\n\x06source\x18\x03 \x01(\r\x12\x14\n\x0cref_clk_freq\x18\x04 \x01(\x01\x12\x11\n\tsamp_rate\x18\x05 \x01(\x01\"D\n\x0c\x42lockRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\"1\n\x0bTileRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\"\xf1\x01\n\x16GetBlockStatusResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x15\n\rsampling_freq\x18\x02 \x01(\x01\x12\x1f\n\x17\x61nalog_data_path_status\x18\x03 \x01(\r\x12 \n\x18\x64igital_data_path_status\x18\x04 \x01(\r\x12\x1f\n\x17\x64\x61ta_path_clocks_status\x18\x05 \x01(\r\x12\x1d\n\x15is_fifo_flags_enabled\x18\x06 \x01(\r\x12\x1e\n\x16is_fifo_flags_asserted\x18\x07 \x01(\r\"F\n\x15GetFIFOStatusResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x0e\n\x06\x65nable\x18\x02 \x01(\x08\"N\n\x18GetPLLLockStatusResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x13\n\x0block_status\x18\x02 \x01(\r\"M\n\x16GetClockSourceResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x14\n\x0c\x63lock_source\x18\x02 \x01(\r\"Q\n\x16SetFabClkOutDivRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x13\n\x0b\x66\x61\x62_clk_div\x18\x03 \x01(\r\"M\n\x17GetFabClkOutDivResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x13\n\x0b\x66\x61\x62_clk_div\x18\x02 \x01(\r\"\xa4\x01\n\rMixerSettings\x12\x0c\n\x04\x66req\x18\x01 \x01(\x01\x12\x14\n\x0cphase_offset\x18\x02 \x01(\x01\x12\x14\n\x0c\x65vent_source\x18\x03 \x01(\r\x12\x17\n\x0f\x63oarse_mix_freq\x18\x04 \x01(\r\x12\x12\n\nmixer_mode\x18\x05 \x01(\r\x12\x18\n\x10\x66ine_mixer_scale\x18\x06 \x01(\r\x12\x12\n\nmixer_type\x18\x07 \x01(\r\"w\n\x17SetMixerSettingsRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\x12&\n\x08settings\x18\x04 \x01(\x0b\x32\x14.xrfdc.MixerSettings\"a\n\x18GetMixerSettingsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12&\n\x08settings\x18\x02 \x01(\x0b\x32\x14.xrfdc.MixerSettings\"L\n\x14ResetNCOPhaseRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\"c\n\x15SetNyquistZoneRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\x12\x14\n\x0cnyquist_zone\x18\x04 \x01(\r\"M\n\x16GetNyquistZoneResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x14\n\x0cnyquist_zone\x18\x02 \x01(\r\"Y\n\x1dSetInterpolationFactorRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x15\n\rinterp_factor\x18\x03 \x01(\r\"V\n\x1eGetInterpolationFactorResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x15\n\rinterp_factor\x18\x02 \x01(\r\"S\n\x1aSetDecimationFactorRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x12\n\ndec_factor\x18\x03 \x01(\r\"P\n\x1bGetDecimationFactorResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x12\n\ndec_factor\x18\x02 \x01(\r\"\xcd\x01\n\x0bQMCSettings\x12\x14\n\x0c\x65nable_phase\x18\x01 \x01(\x08\x12\x13\n\x0b\x65nable_gain\x18\x02 \x01(\x08\x12\x1a\n\x12\x65nable_offset_corr\x18\x03 \x01(\x08\x12\x1e\n\x16gain_correction_factor\x18\x04 \x01(\x01\x12\x1f\n\x17phase_correction_factor\x18\x05 \x01(\x01\x12 \n\x18offset_correction_factor\x18\x06 \x01(\x05\x12\x14\n\x0c\x65vent_source\x18\x07 \x01(\r\"s\n\x15SetQMCSettingsRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\x12$\n\x08settings\x18\x04 \x01(\x0b\x32\x12.xrfdc.QMCSettings\"]\n\x16GetQMCSettingsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12$\n\x08settings\x18\x02 \x01(\x0b\x32\x12.xrfdc.QMCSettings\"\x99\x01\n\x11ThresholdSettings\x12\x18\n\x10update_threshold\x18\x01 \x01(\r\x12\x16\n\x0ethreshold_mode\x18\x02 \x03(\r\x12\x19\n\x11threshold_avg_val\x18\x03 \x03(\r\x12\x1b\n\x13threshold_under_val\x18\x04 \x03(\r\x12\x1a\n\x12threshold_over_val\x18\x05 \x03(\r\"l\n\x1bSetThresholdSettingsRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12*\n\x08settings\x18\x03 \x01(\x0b\x32\x18.xrfdc.ThresholdSettings\"i\n\x1cGetThresholdSettingsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12*\n\x08settings\x18\x02 \x01(\x0b\x32\x18.xrfdc.ThresholdSettings\"A\n\x13\x43oarseDelaySettings\x12\x14\n\x0c\x63oarse_delay\x18\x01 \x01(\r\x12\x14\n\x0c\x65vent_source\x18\x02 \x01(\r\"n\n\x1aSetThresholdClrModeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x1b\n\x13threshold_to_update\x18\x03 \x01(\r\x12\x10\n\x08\x63lr_mode\x18\x04 \x01(\r\"<\n\x1bSetThresholdClrModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\"]\n\x1bThresholdStickyClearRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x1b\n\x13threshold_to_update\x18\x03 \x01(\r\"=\n\x1cThresholdStickyClearResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\"U\n\x1dGetCoarseDelaySettingsRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\"m\n\x1eGetCoarseDelaySettingsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12,\n\x08settings\x18\x02 \x01(\x0b\x32\x1a.xrfdc.CoarseDelaySettings\"\x83\x01\n\x1dSetCoarseDelaySettingsRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\x12,\n\x08settings\x18\x04 \x01(\x0b\x32\x1a.xrfdc.CoarseDelaySettings\"?\n\x1eSetCoarseDelaySettingsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\"?\n\x0fPwrModeSettings\x12\x1a\n\x12\x64isable_ip_control\x18\x01 \x01(\r\x12\x10\n\x08pwr_mode\x18\x02 \x01(\r\"]\n\x12GetPwrModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12(\n\x08settings\x18\x02 \x01(\x0b\x32\x16.xrfdc.PwrModeSettings\"s\n\x11SetPwrModeRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\x12(\n\x08settings\x18\x04 \x01(\x0b\x32\x16.xrfdc.PwrModeSettings\"Y\n\x12UpdateEventRequest\x12\x11\n\ttile_type\x18\x01 \x01(\r\x12\x0f\n\x07tile_id\x18\x02 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x03 \x01(\r\x12\r\n\x05\x65vent\x18\x04 \x01(\r\"H\n\x18GetConnectedDataResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\x05\"L\n\x1cGetEnabledInterruptsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"J\n\x1aGetCalibrationModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"M\n\x19SetCalibrationModeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"H\n\x18GetFabRdVldWordsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"K\n\x17SetFabRdVldWordsRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"H\n\x18GetFabWrVldWordsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"K\n\x17SetFabWrVldWordsRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"K\n\x1bGetFabRdVldWordsObsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"N\n\x1aSetFabRdVldWordsObsRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"K\n\x1bGetFabWrVldWordsObsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"D\n\x10SetDitherRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"A\n\x11GetDitherResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"I\n\x15SetDecoderModeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"F\n\x16GetDecoderModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"E\n\x15GetOutputCurrResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"E\n\x15GetInvSincFIRResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"H\n\x14SetInvSincFIRRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"G\n\x17GetDataPathModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"J\n\x16SetDataPathModeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"F\n\x16GetIMRPassModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"I\n\x15SetIMRPassModeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"F\n\x16GetDACCompModeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\r\n\x05value\x18\x02 \x01(\r\"I\n\x15SetDACCompModeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\r\n\x05value\x18\x03 \x01(\r\"_\n\x11\x43\x61lFreezeSettings\x12\x12\n\ncal_frozen\x18\x01 \x01(\r\x12\x1a\n\x12\x64isable_freeze_pin\x18\x02 \x01(\r\x12\x1a\n\x12\x66reeze_calibration\x18\x03 \x01(\r\"a\n\x14GetCalFreezeResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12*\n\x08settings\x18\x02 \x01(\x0b\x32\x18.xrfdc.CalFreezeSettings\"d\n\x13SetCalFreezeRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12*\n\x08settings\x18\x03 \x01(\x0b\x32\x18.xrfdc.CalFreezeSettings\"7\n\x0b\x44SASettings\x12\x13\n\x0b\x64isable_rts\x18\x01 \x01(\r\x12\x13\n\x0b\x61ttenuation\x18\x02 \x01(\x02\"U\n\x0eGetDSAResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12$\n\x08settings\x18\x02 \x01(\x0b\x32\x12.xrfdc.DSASettings\"X\n\rSetDSARequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12$\n\x08settings\x18\x03 \x01(\x0b\x32\x12.xrfdc.DSASettings\"b\n\"DisableCoefficientsOverrideRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x19\n\x11\x63\x61libration_block\x18\x03 \x01(\r\"\x99\x01\n\x17\x43\x61librationCoefficients\x12\x0e\n\x06\x63oeff0\x18\x01 \x01(\r\x12\x0e\n\x06\x63oeff1\x18\x02 \x01(\r\x12\x0e\n\x06\x63oeff2\x18\x03 \x01(\r\x12\x0e\n\x06\x63oeff3\x18\x04 \x01(\r\x12\x0e\n\x06\x63oeff4\x18\x05 \x01(\r\x12\x0e\n\x06\x63oeff5\x18\x06 \x01(\r\x12\x0e\n\x06\x63oeff6\x18\x07 \x01(\r\x12\x0e\n\x06\x63oeff7\x18\x08 \x01(\r\"\x89\x01\n\x19SetCalCoefficientsRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x19\n\x11\x63\x61libration_block\x18\x03 \x01(\r\x12.\n\x06\x63oeffs\x18\x04 \x01(\x0b\x32\x1e.xrfdc.CalibrationCoefficients\"Y\n\x19GetCalCoefficientsRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x19\n\x11\x63\x61libration_block\x18\x03 \x01(\r\"k\n\x1aGetCalCoefficientsResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12.\n\x06\x63oeffs\x18\x02 \x01(\x0b\x32\x1e.xrfdc.CalibrationCoefficients\"I\n\x10SetDACVOPRequest\x12\x0f\n\x07tile_id\x18\x01 \x01(\r\x12\x10\n\x08\x62lock_id\x18\x02 \x01(\r\x12\x12\n\nuA_current\x18\x03 \x01(\r\"\xdb\x01\n\x0bPLLSettings\x12\x0f\n\x07\x65nabled\x18\x01 \x01(\r\x12\x14\n\x0cref_clk_freq\x18\x02 \x01(\x01\x12\x13\n\x0bsample_rate\x18\x03 \x01(\x01\x12\x17\n\x0fref_clk_divider\x18\x04 \x01(\r\x12\x18\n\x10\x66\x65\x65\x64\x62\x61\x63k_divider\x18\x05 \x01(\r\x12\x16\n\x0eoutput_divider\x18\x06 \x01(\r\x12\x17\n\x0f\x66ractional_mode\x18\x07 \x01(\r\x12\x17\n\x0f\x66ractional_data\x18\x08 \x01(\x04\x12\x13\n\x0b\x66ract_width\x18\t \x01(\r\"[\n\x14GetPLLConfigResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12$\n\x08settings\x18\x02 \x01(\x0b\x32\x12.xrfdc.PLLSettings\"\x1b\n\x19GetClkDistributionRequest\"\x89\x01\n\x0c\x44istribution\x12\x0e\n\x06source\x18\x01 \x01(\r\x12\x13\n\x0bupper_bound\x18\x02 \x01(\r\x12\x13\n\x0blower_bound\x18\x03 \x01(\r\x12\x11\n\tmax_delay\x18\x04 \x01(\r\x12\x11\n\tmin_delay\x18\x05 \x01(\r\x12\x19\n\x11is_delay_balanced\x18\x06 \x01(\r\"\xbf\x01\n\x11TileClockSettings\x12\x13\n\x0bsource_type\x18\x01 \x01(\r\x12\x13\n\x0bsource_tile\x18\x02 \x01(\r\x12\x12\n\npll_enable\x18\x03 \x01(\r\x12\x14\n\x0cref_clk_freq\x18\x04 \x01(\x01\x12\x13\n\x0bsample_rate\x18\x05 \x01(\x01\x12\x17\n\x0f\x64ivision_factor\x18\x06 \x01(\r\x12\x19\n\x11\x64istributed_clock\x18\x07 \x01(\r\x12\r\n\x05\x64\x65lay\x18\x08 \x01(\r\"\x97\x01\n\x17\x43lkDistributionSettings\x12%\n\x03\x64\x61\x63\x18\x01 \x03(\x0b\x32\x18.xrfdc.TileClockSettings\x12%\n\x03\x61\x64\x63\x18\x02 \x03(\x0b\x32\x18.xrfdc.TileClockSettings\x12.\n\x11\x64istribution_info\x18\x03 \x01(\x0b\x32\x13.xrfdc.Distribution\"m\n\x1aGetClkDistributionResponse\x12\x1d\n\x06status\x18\x01 \x01(\x0b\x32\r.xrfdc.Status\x12\x30\n\x08settings\x18\x02 \x01(\x0b\x32\x1e.xrfdc.ClkDistributionSettings\"M\n\x19SetClkDistributionRequest\x12\x30\n\x08settings\x18\x01 \x01(\x0b\x32\x1e.xrfdc.ClkDistributionSettings2\xd8-\n\x05Xrfdc\x12J\n\rCfgInitialize\x12\x1b.xrfdc.CfgInitializeRequest\x1a\x1c.xrfdc.CfgInitializeResponse\x12\x44\n\x0bGetIPStatus\x12\x19.xrfdc.GetIPStatusRequest\x1a\x1a.xrfdc.GetIPStatusResponse\x12\x44\n\x0eGetBlockStatus\x12\x13.xrfdc.BlockRequest\x1a\x1d.xrfdc.GetBlockStatusResponse\x12\x41\n\rGetFIFOStatus\x12\x12.xrfdc.TileRequest\x1a\x1c.xrfdc.GetFIFOStatusResponse\x12G\n\x10GetPLLLockStatus\x12\x12.xrfdc.TileRequest\x1a\x1f.xrfdc.GetPLLLockStatusResponse\x12\x43\n\x0eGetClockSource\x12\x12.xrfdc.TileRequest\x1a\x1d.xrfdc.GetClockSourceResponse\x12@\n\x07StartUp\x12\x19.xrfdc.TileControlRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x41\n\x08Shutdown\x12\x19.xrfdc.TileControlRequest\x1a\x1a.xrfdc.TileControlResponse\x12>\n\x05Reset\x12\x19.xrfdc.TileControlRequest\x1a\x1a.xrfdc.TileControlResponse\x12@\n\tSetupFIFO\x12\x17.xrfdc.SetupFIFORequest\x1a\x1a.xrfdc.TileControlResponse\x12N\n\x10\x44ynamicPLLConfig\x12\x1e.xrfdc.DynamicPLLConfigRequest\x1a\x1a.xrfdc.TileControlResponse\x12L\n\x0fSetFabClkOutDiv\x12\x1d.xrfdc.SetFabClkOutDivRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x45\n\x0fGetFabClkOutDiv\x12\x12.xrfdc.TileRequest\x1a\x1e.xrfdc.GetFabClkOutDivResponse\x12N\n\x10SetMixerSettings\x12\x1e.xrfdc.SetMixerSettingsRequest\x1a\x1a.xrfdc.TileControlResponse\x12H\n\x10GetMixerSettings\x12\x13.xrfdc.BlockRequest\x1a\x1f.xrfdc.GetMixerSettingsResponse\x12@\n\rResetNCOPhase\x12\x13.xrfdc.BlockRequest\x1a\x1a.xrfdc.TileControlResponse\x12J\n\x0eSetNyquistZone\x12\x1c.xrfdc.SetNyquistZoneRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\x0eGetNyquistZone\x12\x13.xrfdc.BlockRequest\x1a\x1d.xrfdc.GetNyquistZoneResponse\x12Z\n\x16SetInterpolationFactor\x12$.xrfdc.SetInterpolationFactorRequest\x1a\x1a.xrfdc.TileControlResponse\x12T\n\x16GetInterpolationFactor\x12\x13.xrfdc.BlockRequest\x1a%.xrfdc.GetInterpolationFactorResponse\x12T\n\x13SetDecimationFactor\x12!.xrfdc.SetDecimationFactorRequest\x1a\x1a.xrfdc.TileControlResponse\x12N\n\x13GetDecimationFactor\x12\x13.xrfdc.BlockRequest\x1a\".xrfdc.GetDecimationFactorResponse\x12J\n\x0eSetQMCSettings\x12\x1c.xrfdc.SetQMCSettingsRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\x0eGetQMCSettings\x12\x13.xrfdc.BlockRequest\x1a\x1d.xrfdc.GetQMCSettingsResponse\x12V\n\x14SetThresholdSettings\x12\".xrfdc.SetThresholdSettingsRequest\x1a\x1a.xrfdc.TileControlResponse\x12P\n\x14GetThresholdSettings\x12\x13.xrfdc.BlockRequest\x1a#.xrfdc.GetThresholdSettingsResponse\x12\\\n\x13SetThresholdClrMode\x12!.xrfdc.SetThresholdClrModeRequest\x1a\".xrfdc.SetThresholdClrModeResponse\x12_\n\x14ThresholdStickyClear\x12\".xrfdc.ThresholdStickyClearRequest\x1a#.xrfdc.ThresholdStickyClearResponse\x12\x65\n\x16GetCoarseDelaySettings\x12$.xrfdc.GetCoarseDelaySettingsRequest\x1a%.xrfdc.GetCoarseDelaySettingsResponse\x12\x65\n\x16SetCoarseDelaySettings\x12$.xrfdc.SetCoarseDelaySettingsRequest\x1a%.xrfdc.SetCoarseDelaySettingsResponse\x12P\n\x14GetEnabledInterrupts\x12\x13.xrfdc.BlockRequest\x1a#.xrfdc.GetEnabledInterruptsResponse\x12<\n\nGetPwrMode\x12\x13.xrfdc.BlockRequest\x1a\x19.xrfdc.GetPwrModeResponse\x12\x42\n\nSetPwrMode\x12\x18.xrfdc.SetPwrModeRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\x0bUpdateEvent\x12\x19.xrfdc.UpdateEventRequest\x1a\x1a.xrfdc.TileControlResponse\x12I\n\x16ResetInternalFIFOWidth\x12\x13.xrfdc.BlockRequest\x1a\x1a.xrfdc.TileControlResponse\x12I\n\x11GetConnectedIData\x12\x13.xrfdc.BlockRequest\x1a\x1f.xrfdc.GetConnectedDataResponse\x12I\n\x11GetConnectedQData\x12\x13.xrfdc.BlockRequest\x1a\x1f.xrfdc.GetConnectedDataResponse\x12L\n\x12GetCalibrationMode\x12\x13.xrfdc.BlockRequest\x1a!.xrfdc.GetCalibrationModeResponse\x12R\n\x12SetCalibrationMode\x12 .xrfdc.SetCalibrationModeRequest\x1a\x1a.xrfdc.TileControlResponse\x12H\n\x10GetFabRdVldWords\x12\x13.xrfdc.BlockRequest\x1a\x1f.xrfdc.GetFabRdVldWordsResponse\x12N\n\x10SetFabRdVldWords\x12\x1e.xrfdc.SetFabRdVldWordsRequest\x1a\x1a.xrfdc.TileControlResponse\x12H\n\x10GetFabWrVldWords\x12\x13.xrfdc.BlockRequest\x1a\x1f.xrfdc.GetFabWrVldWordsResponse\x12N\n\x10SetFabWrVldWords\x12\x1e.xrfdc.SetFabWrVldWordsRequest\x1a\x1a.xrfdc.TileControlResponse\x12Q\n\x16GetDecimationFactorObs\x12\x13.xrfdc.BlockRequest\x1a\".xrfdc.GetDecimationFactorResponse\x12W\n\x16SetDecimationFactorObs\x12!.xrfdc.SetDecimationFactorRequest\x1a\x1a.xrfdc.TileControlResponse\x12N\n\x13GetFabRdVldWordsObs\x12\x13.xrfdc.BlockRequest\x1a\".xrfdc.GetFabRdVldWordsObsResponse\x12T\n\x13SetFabRdVldWordsObs\x12!.xrfdc.SetFabRdVldWordsObsRequest\x1a\x1a.xrfdc.TileControlResponse\x12N\n\x13GetFabWrVldWordsObs\x12\x13.xrfdc.BlockRequest\x1a\".xrfdc.GetFabWrVldWordsObsResponse\x12:\n\tGetDither\x12\x13.xrfdc.BlockRequest\x1a\x18.xrfdc.GetDitherResponse\x12@\n\tSetDither\x12\x17.xrfdc.SetDitherRequest\x1a\x1a.xrfdc.TileControlResponse\x12@\n\x0cGetCalFreeze\x12\x13.xrfdc.BlockRequest\x1a\x1b.xrfdc.GetCalFreezeResponse\x12\x46\n\x0cSetCalFreeze\x12\x1a.xrfdc.SetCalFreezeRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x34\n\x06GetDSA\x12\x13.xrfdc.BlockRequest\x1a\x15.xrfdc.GetDSAResponse\x12:\n\x06SetDSA\x12\x14.xrfdc.SetDSARequest\x1a\x1a.xrfdc.TileControlResponse\x12\x64\n\x1b\x44isableCoefficientsOverride\x12).xrfdc.DisableCoefficientsOverrideRequest\x1a\x1a.xrfdc.TileControlResponse\x12L\n\x19ResetInternalFIFOWidthObs\x12\x13.xrfdc.BlockRequest\x1a\x1a.xrfdc.TileControlResponse\x12R\n\x12SetCalCoefficients\x12 .xrfdc.SetCalCoefficientsRequest\x1a\x1a.xrfdc.TileControlResponse\x12Y\n\x12GetCalCoefficients\x12 .xrfdc.GetCalCoefficientsRequest\x1a!.xrfdc.GetCalCoefficientsResponse\x12\x44\n\x0eGetDecoderMode\x12\x13.xrfdc.BlockRequest\x1a\x1d.xrfdc.GetDecoderModeResponse\x12J\n\x0eSetDecoderMode\x12\x1c.xrfdc.SetDecoderModeRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x42\n\rGetOutputCurr\x12\x13.xrfdc.BlockRequest\x1a\x1c.xrfdc.GetOutputCurrResponse\x12\x42\n\rGetInvSincFIR\x12\x13.xrfdc.BlockRequest\x1a\x1c.xrfdc.GetInvSincFIRResponse\x12H\n\rSetInvSincFIR\x12\x1b.xrfdc.SetInvSincFIRRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x46\n\x0fGetDataPathMode\x12\x13.xrfdc.BlockRequest\x1a\x1e.xrfdc.GetDataPathModeResponse\x12L\n\x0fSetDataPathMode\x12\x1d.xrfdc.SetDataPathModeRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\x0eGetIMRPassMode\x12\x13.xrfdc.BlockRequest\x1a\x1d.xrfdc.GetIMRPassModeResponse\x12J\n\x0eSetIMRPassMode\x12\x1c.xrfdc.SetIMRPassModeRequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\x0eGetDACCompMode\x12\x13.xrfdc.BlockRequest\x1a\x1d.xrfdc.GetDACCompModeResponse\x12J\n\x0eSetDACCompMode\x12\x1c.xrfdc.SetDACCompModeRequest\x1a\x1a.xrfdc.TileControlResponse\x12@\n\tSetDACVOP\x12\x17.xrfdc.SetDACVOPRequest\x1a\x1a.xrfdc.TileControlResponse\x12:\n\x08\x44umpRegs\x12\x12.xrfdc.TileRequest\x1a\x1a.xrfdc.TileControlResponse\x12?\n\x0cGetPLLConfig\x12\x12.xrfdc.TileRequest\x1a\x1b.xrfdc.GetPLLConfigResponse\x12\x43\n\x0cSetupFIFOObs\x12\x17.xrfdc.SetupFIFORequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\rSetupFIFOBoth\x12\x17.xrfdc.SetupFIFORequest\x1a\x1a.xrfdc.TileControlResponse\x12\x44\n\x10GetFIFOStatusObs\x12\x12.xrfdc.TileRequest\x1a\x1c.xrfdc.GetFIFOStatusResponse\x12Y\n\x12GetClkDistribution\x12 .xrfdc.GetClkDistributionRequest\x1a!.xrfdc.GetClkDistributionResponse\x12R\n\x12SetClkDistribution\x12 .xrfdc.SetClkDistributionRequest\x1a\x1a.xrfdc.TileControlResponseb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'xrfdc_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + DESCRIPTOR._loaded_options = None + _globals['_STATUS']._serialized_start=22 + _globals['_STATUS']._serialized_end=145 + _globals['_BLOCKSTATUS']._serialized_start=148 + _globals['_BLOCKSTATUS']._serialized_end=366 + _globals['_TILESTATUS']._serialized_start=369 + _globals['_TILESTATUS']._serialized_end=533 + _globals['_IPSTATUS']._serialized_start=535 + _globals['_IPSTATUS']._serialized_end=648 + _globals['_DACBLOCKANALOGDATAPATHCONFIG']._serialized_start=650 + _globals['_DACBLOCKANALOGDATAPATHCONFIG']._serialized_end=770 + _globals['_DACBLOCKDIGITALDATAPATHCONFIG']._serialized_start=773 + _globals['_DACBLOCKDIGITALDATAPATHCONFIG']._serialized_end=946 + _globals['_ADCBLOCKANALOGDATAPATHCONFIG']._serialized_start=948 + _globals['_ADCBLOCKANALOGDATAPATHCONFIG']._serialized_end=1021 + _globals['_ADCBLOCKDIGITALDATAPATHCONFIG']._serialized_start=1024 + _globals['_ADCBLOCKDIGITALDATAPATHCONFIG']._serialized_end=1172 + _globals['_DACTILECONFIG']._serialized_start=1175 + _globals['_DACTILECONFIG']._serialized_end=1569 + _globals['_ADCTILECONFIG']._serialized_start=1572 + _globals['_ADCTILECONFIG']._serialized_end=1966 + _globals['_RFDCCONFIG']._serialized_start=1969 + _globals['_RFDCCONFIG']._serialized_end=2273 + _globals['_CFGINITIALIZEREQUEST']._serialized_start=2275 + _globals['_CFGINITIALIZEREQUEST']._serialized_end=2346 + _globals['_CFGINITIALIZERESPONSE']._serialized_start=2348 + _globals['_CFGINITIALIZERESPONSE']._serialized_end=2402 + _globals['_GETIPSTATUSREQUEST']._serialized_start=2404 + _globals['_GETIPSTATUSREQUEST']._serialized_end=2424 + _globals['_GETIPSTATUSRESPONSE']._serialized_start=2426 + _globals['_GETIPSTATUSRESPONSE']._serialized_end=2514 + _globals['_TILECONTROLREQUEST']._serialized_start=2516 + _globals['_TILECONTROLREQUEST']._serialized_end=2572 + _globals['_TILECONTROLRESPONSE']._serialized_start=2574 + _globals['_TILECONTROLRESPONSE']._serialized_end=2626 + _globals['_SETUPFIFOREQUEST']._serialized_start=2628 + _globals['_SETUPFIFOREQUEST']._serialized_end=2716 + _globals['_DYNAMICPLLCONFIGREQUEST']._serialized_start=2718 + _globals['_DYNAMICPLLCONFIGREQUEST']._serialized_end=2836 + _globals['_BLOCKREQUEST']._serialized_start=2838 + _globals['_BLOCKREQUEST']._serialized_end=2906 + _globals['_TILEREQUEST']._serialized_start=2908 + _globals['_TILEREQUEST']._serialized_end=2957 + _globals['_GETBLOCKSTATUSRESPONSE']._serialized_start=2960 + _globals['_GETBLOCKSTATUSRESPONSE']._serialized_end=3201 + _globals['_GETFIFOSTATUSRESPONSE']._serialized_start=3203 + _globals['_GETFIFOSTATUSRESPONSE']._serialized_end=3273 + _globals['_GETPLLLOCKSTATUSRESPONSE']._serialized_start=3275 + _globals['_GETPLLLOCKSTATUSRESPONSE']._serialized_end=3353 + _globals['_GETCLOCKSOURCERESPONSE']._serialized_start=3355 + _globals['_GETCLOCKSOURCERESPONSE']._serialized_end=3432 + _globals['_SETFABCLKOUTDIVREQUEST']._serialized_start=3434 + _globals['_SETFABCLKOUTDIVREQUEST']._serialized_end=3515 + _globals['_GETFABCLKOUTDIVRESPONSE']._serialized_start=3517 + _globals['_GETFABCLKOUTDIVRESPONSE']._serialized_end=3594 + _globals['_MIXERSETTINGS']._serialized_start=3597 + _globals['_MIXERSETTINGS']._serialized_end=3761 + _globals['_SETMIXERSETTINGSREQUEST']._serialized_start=3763 + _globals['_SETMIXERSETTINGSREQUEST']._serialized_end=3882 + _globals['_GETMIXERSETTINGSRESPONSE']._serialized_start=3884 + _globals['_GETMIXERSETTINGSRESPONSE']._serialized_end=3981 + _globals['_RESETNCOPHASEREQUEST']._serialized_start=3983 + _globals['_RESETNCOPHASEREQUEST']._serialized_end=4059 + _globals['_SETNYQUISTZONEREQUEST']._serialized_start=4061 + _globals['_SETNYQUISTZONEREQUEST']._serialized_end=4160 + _globals['_GETNYQUISTZONERESPONSE']._serialized_start=4162 + _globals['_GETNYQUISTZONERESPONSE']._serialized_end=4239 + _globals['_SETINTERPOLATIONFACTORREQUEST']._serialized_start=4241 + _globals['_SETINTERPOLATIONFACTORREQUEST']._serialized_end=4330 + _globals['_GETINTERPOLATIONFACTORRESPONSE']._serialized_start=4332 + _globals['_GETINTERPOLATIONFACTORRESPONSE']._serialized_end=4418 + _globals['_SETDECIMATIONFACTORREQUEST']._serialized_start=4420 + _globals['_SETDECIMATIONFACTORREQUEST']._serialized_end=4503 + _globals['_GETDECIMATIONFACTORRESPONSE']._serialized_start=4505 + _globals['_GETDECIMATIONFACTORRESPONSE']._serialized_end=4585 + _globals['_QMCSETTINGS']._serialized_start=4588 + _globals['_QMCSETTINGS']._serialized_end=4793 + _globals['_SETQMCSETTINGSREQUEST']._serialized_start=4795 + _globals['_SETQMCSETTINGSREQUEST']._serialized_end=4910 + _globals['_GETQMCSETTINGSRESPONSE']._serialized_start=4912 + _globals['_GETQMCSETTINGSRESPONSE']._serialized_end=5005 + _globals['_THRESHOLDSETTINGS']._serialized_start=5008 + _globals['_THRESHOLDSETTINGS']._serialized_end=5161 + _globals['_SETTHRESHOLDSETTINGSREQUEST']._serialized_start=5163 + _globals['_SETTHRESHOLDSETTINGSREQUEST']._serialized_end=5271 + _globals['_GETTHRESHOLDSETTINGSRESPONSE']._serialized_start=5273 + _globals['_GETTHRESHOLDSETTINGSRESPONSE']._serialized_end=5378 + _globals['_COARSEDELAYSETTINGS']._serialized_start=5380 + _globals['_COARSEDELAYSETTINGS']._serialized_end=5445 + _globals['_SETTHRESHOLDCLRMODEREQUEST']._serialized_start=5447 + _globals['_SETTHRESHOLDCLRMODEREQUEST']._serialized_end=5557 + _globals['_SETTHRESHOLDCLRMODERESPONSE']._serialized_start=5559 + _globals['_SETTHRESHOLDCLRMODERESPONSE']._serialized_end=5619 + _globals['_THRESHOLDSTICKYCLEARREQUEST']._serialized_start=5621 + _globals['_THRESHOLDSTICKYCLEARREQUEST']._serialized_end=5714 + _globals['_THRESHOLDSTICKYCLEARRESPONSE']._serialized_start=5716 + _globals['_THRESHOLDSTICKYCLEARRESPONSE']._serialized_end=5777 + _globals['_GETCOARSEDELAYSETTINGSREQUEST']._serialized_start=5779 + _globals['_GETCOARSEDELAYSETTINGSREQUEST']._serialized_end=5864 + _globals['_GETCOARSEDELAYSETTINGSRESPONSE']._serialized_start=5866 + _globals['_GETCOARSEDELAYSETTINGSRESPONSE']._serialized_end=5975 + _globals['_SETCOARSEDELAYSETTINGSREQUEST']._serialized_start=5978 + _globals['_SETCOARSEDELAYSETTINGSREQUEST']._serialized_end=6109 + _globals['_SETCOARSEDELAYSETTINGSRESPONSE']._serialized_start=6111 + _globals['_SETCOARSEDELAYSETTINGSRESPONSE']._serialized_end=6174 + _globals['_PWRMODESETTINGS']._serialized_start=6176 + _globals['_PWRMODESETTINGS']._serialized_end=6239 + _globals['_GETPWRMODERESPONSE']._serialized_start=6241 + _globals['_GETPWRMODERESPONSE']._serialized_end=6334 + _globals['_SETPWRMODEREQUEST']._serialized_start=6336 + _globals['_SETPWRMODEREQUEST']._serialized_end=6451 + _globals['_UPDATEEVENTREQUEST']._serialized_start=6453 + _globals['_UPDATEEVENTREQUEST']._serialized_end=6542 + _globals['_GETCONNECTEDDATARESPONSE']._serialized_start=6544 + _globals['_GETCONNECTEDDATARESPONSE']._serialized_end=6616 + _globals['_GETENABLEDINTERRUPTSRESPONSE']._serialized_start=6618 + _globals['_GETENABLEDINTERRUPTSRESPONSE']._serialized_end=6694 + _globals['_GETCALIBRATIONMODERESPONSE']._serialized_start=6696 + _globals['_GETCALIBRATIONMODERESPONSE']._serialized_end=6770 + _globals['_SETCALIBRATIONMODEREQUEST']._serialized_start=6772 + _globals['_SETCALIBRATIONMODEREQUEST']._serialized_end=6849 + _globals['_GETFABRDVLDWORDSRESPONSE']._serialized_start=6851 + _globals['_GETFABRDVLDWORDSRESPONSE']._serialized_end=6923 + _globals['_SETFABRDVLDWORDSREQUEST']._serialized_start=6925 + _globals['_SETFABRDVLDWORDSREQUEST']._serialized_end=7000 + _globals['_GETFABWRVLDWORDSRESPONSE']._serialized_start=7002 + _globals['_GETFABWRVLDWORDSRESPONSE']._serialized_end=7074 + _globals['_SETFABWRVLDWORDSREQUEST']._serialized_start=7076 + _globals['_SETFABWRVLDWORDSREQUEST']._serialized_end=7151 + _globals['_GETFABRDVLDWORDSOBSRESPONSE']._serialized_start=7153 + _globals['_GETFABRDVLDWORDSOBSRESPONSE']._serialized_end=7228 + _globals['_SETFABRDVLDWORDSOBSREQUEST']._serialized_start=7230 + _globals['_SETFABRDVLDWORDSOBSREQUEST']._serialized_end=7308 + _globals['_GETFABWRVLDWORDSOBSRESPONSE']._serialized_start=7310 + _globals['_GETFABWRVLDWORDSOBSRESPONSE']._serialized_end=7385 + _globals['_SETDITHERREQUEST']._serialized_start=7387 + _globals['_SETDITHERREQUEST']._serialized_end=7455 + _globals['_GETDITHERRESPONSE']._serialized_start=7457 + _globals['_GETDITHERRESPONSE']._serialized_end=7522 + _globals['_SETDECODERMODEREQUEST']._serialized_start=7524 + _globals['_SETDECODERMODEREQUEST']._serialized_end=7597 + _globals['_GETDECODERMODERESPONSE']._serialized_start=7599 + _globals['_GETDECODERMODERESPONSE']._serialized_end=7669 + _globals['_GETOUTPUTCURRRESPONSE']._serialized_start=7671 + _globals['_GETOUTPUTCURRRESPONSE']._serialized_end=7740 + _globals['_GETINVSINCFIRRESPONSE']._serialized_start=7742 + _globals['_GETINVSINCFIRRESPONSE']._serialized_end=7811 + _globals['_SETINVSINCFIRREQUEST']._serialized_start=7813 + _globals['_SETINVSINCFIRREQUEST']._serialized_end=7885 + _globals['_GETDATAPATHMODERESPONSE']._serialized_start=7887 + _globals['_GETDATAPATHMODERESPONSE']._serialized_end=7958 + _globals['_SETDATAPATHMODEREQUEST']._serialized_start=7960 + _globals['_SETDATAPATHMODEREQUEST']._serialized_end=8034 + _globals['_GETIMRPASSMODERESPONSE']._serialized_start=8036 + _globals['_GETIMRPASSMODERESPONSE']._serialized_end=8106 + _globals['_SETIMRPASSMODEREQUEST']._serialized_start=8108 + _globals['_SETIMRPASSMODEREQUEST']._serialized_end=8181 + _globals['_GETDACCOMPMODERESPONSE']._serialized_start=8183 + _globals['_GETDACCOMPMODERESPONSE']._serialized_end=8253 + _globals['_SETDACCOMPMODEREQUEST']._serialized_start=8255 + _globals['_SETDACCOMPMODEREQUEST']._serialized_end=8328 + _globals['_CALFREEZESETTINGS']._serialized_start=8330 + _globals['_CALFREEZESETTINGS']._serialized_end=8425 + _globals['_GETCALFREEZERESPONSE']._serialized_start=8427 + _globals['_GETCALFREEZERESPONSE']._serialized_end=8524 + _globals['_SETCALFREEZEREQUEST']._serialized_start=8526 + _globals['_SETCALFREEZEREQUEST']._serialized_end=8626 + _globals['_DSASETTINGS']._serialized_start=8628 + _globals['_DSASETTINGS']._serialized_end=8683 + _globals['_GETDSARESPONSE']._serialized_start=8685 + _globals['_GETDSARESPONSE']._serialized_end=8770 + _globals['_SETDSAREQUEST']._serialized_start=8772 + _globals['_SETDSAREQUEST']._serialized_end=8860 + _globals['_DISABLECOEFFICIENTSOVERRIDEREQUEST']._serialized_start=8862 + _globals['_DISABLECOEFFICIENTSOVERRIDEREQUEST']._serialized_end=8960 + _globals['_CALIBRATIONCOEFFICIENTS']._serialized_start=8963 + _globals['_CALIBRATIONCOEFFICIENTS']._serialized_end=9116 + _globals['_SETCALCOEFFICIENTSREQUEST']._serialized_start=9119 + _globals['_SETCALCOEFFICIENTSREQUEST']._serialized_end=9256 + _globals['_GETCALCOEFFICIENTSREQUEST']._serialized_start=9258 + _globals['_GETCALCOEFFICIENTSREQUEST']._serialized_end=9347 + _globals['_GETCALCOEFFICIENTSRESPONSE']._serialized_start=9349 + _globals['_GETCALCOEFFICIENTSRESPONSE']._serialized_end=9456 + _globals['_SETDACVOPREQUEST']._serialized_start=9458 + _globals['_SETDACVOPREQUEST']._serialized_end=9531 + _globals['_PLLSETTINGS']._serialized_start=9534 + _globals['_PLLSETTINGS']._serialized_end=9753 + _globals['_GETPLLCONFIGRESPONSE']._serialized_start=9755 + _globals['_GETPLLCONFIGRESPONSE']._serialized_end=9846 + _globals['_GETCLKDISTRIBUTIONREQUEST']._serialized_start=9848 + _globals['_GETCLKDISTRIBUTIONREQUEST']._serialized_end=9875 + _globals['_DISTRIBUTION']._serialized_start=9878 + _globals['_DISTRIBUTION']._serialized_end=10015 + _globals['_TILECLOCKSETTINGS']._serialized_start=10018 + _globals['_TILECLOCKSETTINGS']._serialized_end=10209 + _globals['_CLKDISTRIBUTIONSETTINGS']._serialized_start=10212 + _globals['_CLKDISTRIBUTIONSETTINGS']._serialized_end=10363 + _globals['_GETCLKDISTRIBUTIONRESPONSE']._serialized_start=10365 + _globals['_GETCLKDISTRIBUTIONRESPONSE']._serialized_end=10474 + _globals['_SETCLKDISTRIBUTIONREQUEST']._serialized_start=10476 + _globals['_SETCLKDISTRIBUTIONREQUEST']._serialized_end=10553 + _globals['_XRFDC']._serialized_start=10556 + _globals['_XRFDC']._serialized_end=16404 +# @@protoc_insertion_point(module_scope) diff --git a/pynq/remote/xrfdc_pb2.pyi b/pynq/remote/xrfdc_pb2.pyi new file mode 100644 index 000000000..c1e032a3a --- /dev/null +++ b/pynq/remote/xrfdc_pb2.pyi @@ -0,0 +1,1069 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from collections.abc import Iterable as _Iterable, Mapping as _Mapping +from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Status(_message.Message): + __slots__ = ("code", "message", "operation", "tile_type_name", "tile_id", "block_id") + CODE_FIELD_NUMBER: _ClassVar[int] + MESSAGE_FIELD_NUMBER: _ClassVar[int] + OPERATION_FIELD_NUMBER: _ClassVar[int] + TILE_TYPE_NAME_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + code: int + message: str + operation: str + tile_type_name: str + tile_id: int + block_id: int + def __init__(self, code: _Optional[int] = ..., message: _Optional[str] = ..., operation: _Optional[str] = ..., tile_type_name: _Optional[str] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ...) -> None: ... + +class BlockStatus(_message.Message): + __slots__ = ("sampling_freq", "analog_data_path_status", "digital_data_path_status", "data_path_clocks_status", "is_fifo_flags_enabled", "ib_supply", "is_fifo_flags_asserted") + SAMPLING_FREQ_FIELD_NUMBER: _ClassVar[int] + ANALOG_DATA_PATH_STATUS_FIELD_NUMBER: _ClassVar[int] + DIGITAL_DATA_PATH_STATUS_FIELD_NUMBER: _ClassVar[int] + DATA_PATH_CLOCKS_STATUS_FIELD_NUMBER: _ClassVar[int] + IS_FIFO_FLAGS_ENABLED_FIELD_NUMBER: _ClassVar[int] + IB_SUPPLY_FIELD_NUMBER: _ClassVar[int] + IS_FIFO_FLAGS_ASSERTED_FIELD_NUMBER: _ClassVar[int] + sampling_freq: float + analog_data_path_status: int + digital_data_path_status: int + data_path_clocks_status: int + is_fifo_flags_enabled: int + ib_supply: int + is_fifo_flags_asserted: int + def __init__(self, sampling_freq: _Optional[float] = ..., analog_data_path_status: _Optional[int] = ..., digital_data_path_status: _Optional[int] = ..., data_path_clocks_status: _Optional[int] = ..., is_fifo_flags_enabled: _Optional[int] = ..., ib_supply: _Optional[int] = ..., is_fifo_flags_asserted: _Optional[int] = ...) -> None: ... + +class TileStatus(_message.Message): + __slots__ = ("is_enabled", "tile_state", "block_status_mask", "power_up_state", "pll_state", "block_status") + IS_ENABLED_FIELD_NUMBER: _ClassVar[int] + TILE_STATE_FIELD_NUMBER: _ClassVar[int] + BLOCK_STATUS_MASK_FIELD_NUMBER: _ClassVar[int] + POWER_UP_STATE_FIELD_NUMBER: _ClassVar[int] + PLL_STATE_FIELD_NUMBER: _ClassVar[int] + BLOCK_STATUS_FIELD_NUMBER: _ClassVar[int] + is_enabled: int + tile_state: int + block_status_mask: int + power_up_state: int + pll_state: int + block_status: _containers.RepeatedCompositeFieldContainer[BlockStatus] + def __init__(self, is_enabled: _Optional[int] = ..., tile_state: _Optional[int] = ..., block_status_mask: _Optional[int] = ..., power_up_state: _Optional[int] = ..., pll_state: _Optional[int] = ..., block_status: _Optional[_Iterable[_Union[BlockStatus, _Mapping]]] = ...) -> None: ... + +class IPStatus(_message.Message): + __slots__ = ("dac_tile_status", "adc_tile_status", "state") + DAC_TILE_STATUS_FIELD_NUMBER: _ClassVar[int] + ADC_TILE_STATUS_FIELD_NUMBER: _ClassVar[int] + STATE_FIELD_NUMBER: _ClassVar[int] + dac_tile_status: _containers.RepeatedCompositeFieldContainer[TileStatus] + adc_tile_status: _containers.RepeatedCompositeFieldContainer[TileStatus] + state: int + def __init__(self, dac_tile_status: _Optional[_Iterable[_Union[TileStatus, _Mapping]]] = ..., adc_tile_status: _Optional[_Iterable[_Union[TileStatus, _Mapping]]] = ..., state: _Optional[int] = ...) -> None: ... + +class DACBlockAnalogDataPathConfig(_message.Message): + __slots__ = ("block_available", "inv_sync_enable", "mix_mode", "decoder_mode") + BLOCK_AVAILABLE_FIELD_NUMBER: _ClassVar[int] + INV_SYNC_ENABLE_FIELD_NUMBER: _ClassVar[int] + MIX_MODE_FIELD_NUMBER: _ClassVar[int] + DECODER_MODE_FIELD_NUMBER: _ClassVar[int] + block_available: int + inv_sync_enable: int + mix_mode: int + decoder_mode: int + def __init__(self, block_available: _Optional[int] = ..., inv_sync_enable: _Optional[int] = ..., mix_mode: _Optional[int] = ..., decoder_mode: _Optional[int] = ...) -> None: ... + +class DACBlockDigitalDataPathConfig(_message.Message): + __slots__ = ("mixer_input_data_type", "data_width", "interpolation_mode", "fifo_enable", "adder_enable", "mixer_type") + MIXER_INPUT_DATA_TYPE_FIELD_NUMBER: _ClassVar[int] + DATA_WIDTH_FIELD_NUMBER: _ClassVar[int] + INTERPOLATION_MODE_FIELD_NUMBER: _ClassVar[int] + FIFO_ENABLE_FIELD_NUMBER: _ClassVar[int] + ADDER_ENABLE_FIELD_NUMBER: _ClassVar[int] + MIXER_TYPE_FIELD_NUMBER: _ClassVar[int] + mixer_input_data_type: int + data_width: int + interpolation_mode: int + fifo_enable: int + adder_enable: int + mixer_type: int + def __init__(self, mixer_input_data_type: _Optional[int] = ..., data_width: _Optional[int] = ..., interpolation_mode: _Optional[int] = ..., fifo_enable: _Optional[int] = ..., adder_enable: _Optional[int] = ..., mixer_type: _Optional[int] = ...) -> None: ... + +class ADCBlockAnalogDataPathConfig(_message.Message): + __slots__ = ("block_available", "mix_mode") + BLOCK_AVAILABLE_FIELD_NUMBER: _ClassVar[int] + MIX_MODE_FIELD_NUMBER: _ClassVar[int] + block_available: int + mix_mode: int + def __init__(self, block_available: _Optional[int] = ..., mix_mode: _Optional[int] = ...) -> None: ... + +class ADCBlockDigitalDataPathConfig(_message.Message): + __slots__ = ("mixer_input_data_type", "data_width", "decimation_mode", "fifo_enable", "mixer_type") + MIXER_INPUT_DATA_TYPE_FIELD_NUMBER: _ClassVar[int] + DATA_WIDTH_FIELD_NUMBER: _ClassVar[int] + DECIMATION_MODE_FIELD_NUMBER: _ClassVar[int] + FIFO_ENABLE_FIELD_NUMBER: _ClassVar[int] + MIXER_TYPE_FIELD_NUMBER: _ClassVar[int] + mixer_input_data_type: int + data_width: int + decimation_mode: int + fifo_enable: int + mixer_type: int + def __init__(self, mixer_input_data_type: _Optional[int] = ..., data_width: _Optional[int] = ..., decimation_mode: _Optional[int] = ..., fifo_enable: _Optional[int] = ..., mixer_type: _Optional[int] = ...) -> None: ... + +class DACTileConfig(_message.Message): + __slots__ = ("enable", "pll_enable", "sampling_rate", "ref_clk_freq", "fab_clk_freq", "feedback_div", "output_div", "ref_clk_div", "multiband_config", "max_sample_rate", "num_slices", "dac_block_analog_config", "dac_block_digital_config") + ENABLE_FIELD_NUMBER: _ClassVar[int] + PLL_ENABLE_FIELD_NUMBER: _ClassVar[int] + SAMPLING_RATE_FIELD_NUMBER: _ClassVar[int] + REF_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + FAB_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + FEEDBACK_DIV_FIELD_NUMBER: _ClassVar[int] + OUTPUT_DIV_FIELD_NUMBER: _ClassVar[int] + REF_CLK_DIV_FIELD_NUMBER: _ClassVar[int] + MULTIBAND_CONFIG_FIELD_NUMBER: _ClassVar[int] + MAX_SAMPLE_RATE_FIELD_NUMBER: _ClassVar[int] + NUM_SLICES_FIELD_NUMBER: _ClassVar[int] + DAC_BLOCK_ANALOG_CONFIG_FIELD_NUMBER: _ClassVar[int] + DAC_BLOCK_DIGITAL_CONFIG_FIELD_NUMBER: _ClassVar[int] + enable: int + pll_enable: int + sampling_rate: float + ref_clk_freq: float + fab_clk_freq: float + feedback_div: int + output_div: int + ref_clk_div: int + multiband_config: int + max_sample_rate: float + num_slices: int + dac_block_analog_config: _containers.RepeatedCompositeFieldContainer[DACBlockAnalogDataPathConfig] + dac_block_digital_config: _containers.RepeatedCompositeFieldContainer[DACBlockDigitalDataPathConfig] + def __init__(self, enable: _Optional[int] = ..., pll_enable: _Optional[int] = ..., sampling_rate: _Optional[float] = ..., ref_clk_freq: _Optional[float] = ..., fab_clk_freq: _Optional[float] = ..., feedback_div: _Optional[int] = ..., output_div: _Optional[int] = ..., ref_clk_div: _Optional[int] = ..., multiband_config: _Optional[int] = ..., max_sample_rate: _Optional[float] = ..., num_slices: _Optional[int] = ..., dac_block_analog_config: _Optional[_Iterable[_Union[DACBlockAnalogDataPathConfig, _Mapping]]] = ..., dac_block_digital_config: _Optional[_Iterable[_Union[DACBlockDigitalDataPathConfig, _Mapping]]] = ...) -> None: ... + +class ADCTileConfig(_message.Message): + __slots__ = ("enable", "pll_enable", "sampling_rate", "ref_clk_freq", "fab_clk_freq", "feedback_div", "output_div", "ref_clk_div", "multiband_config", "max_sample_rate", "num_slices", "adc_block_analog_config", "adc_block_digital_config") + ENABLE_FIELD_NUMBER: _ClassVar[int] + PLL_ENABLE_FIELD_NUMBER: _ClassVar[int] + SAMPLING_RATE_FIELD_NUMBER: _ClassVar[int] + REF_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + FAB_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + FEEDBACK_DIV_FIELD_NUMBER: _ClassVar[int] + OUTPUT_DIV_FIELD_NUMBER: _ClassVar[int] + REF_CLK_DIV_FIELD_NUMBER: _ClassVar[int] + MULTIBAND_CONFIG_FIELD_NUMBER: _ClassVar[int] + MAX_SAMPLE_RATE_FIELD_NUMBER: _ClassVar[int] + NUM_SLICES_FIELD_NUMBER: _ClassVar[int] + ADC_BLOCK_ANALOG_CONFIG_FIELD_NUMBER: _ClassVar[int] + ADC_BLOCK_DIGITAL_CONFIG_FIELD_NUMBER: _ClassVar[int] + enable: int + pll_enable: int + sampling_rate: float + ref_clk_freq: float + fab_clk_freq: float + feedback_div: int + output_div: int + ref_clk_div: int + multiband_config: int + max_sample_rate: float + num_slices: int + adc_block_analog_config: _containers.RepeatedCompositeFieldContainer[ADCBlockAnalogDataPathConfig] + adc_block_digital_config: _containers.RepeatedCompositeFieldContainer[ADCBlockDigitalDataPathConfig] + def __init__(self, enable: _Optional[int] = ..., pll_enable: _Optional[int] = ..., sampling_rate: _Optional[float] = ..., ref_clk_freq: _Optional[float] = ..., fab_clk_freq: _Optional[float] = ..., feedback_div: _Optional[int] = ..., output_div: _Optional[int] = ..., ref_clk_div: _Optional[int] = ..., multiband_config: _Optional[int] = ..., max_sample_rate: _Optional[float] = ..., num_slices: _Optional[int] = ..., adc_block_analog_config: _Optional[_Iterable[_Union[ADCBlockAnalogDataPathConfig, _Mapping]]] = ..., adc_block_digital_config: _Optional[_Iterable[_Union[ADCBlockDigitalDataPathConfig, _Mapping]]] = ...) -> None: ... + +class RFdcConfig(_message.Message): + __slots__ = ("device_id", "base_addr", "adc_type", "master_adc_tile", "master_dac_tile", "adc_sysref_source", "dac_sysref_source", "ip_type", "si_revision", "dac_tile_config", "adc_tile_config") + DEVICE_ID_FIELD_NUMBER: _ClassVar[int] + BASE_ADDR_FIELD_NUMBER: _ClassVar[int] + ADC_TYPE_FIELD_NUMBER: _ClassVar[int] + MASTER_ADC_TILE_FIELD_NUMBER: _ClassVar[int] + MASTER_DAC_TILE_FIELD_NUMBER: _ClassVar[int] + ADC_SYSREF_SOURCE_FIELD_NUMBER: _ClassVar[int] + DAC_SYSREF_SOURCE_FIELD_NUMBER: _ClassVar[int] + IP_TYPE_FIELD_NUMBER: _ClassVar[int] + SI_REVISION_FIELD_NUMBER: _ClassVar[int] + DAC_TILE_CONFIG_FIELD_NUMBER: _ClassVar[int] + ADC_TILE_CONFIG_FIELD_NUMBER: _ClassVar[int] + device_id: int + base_addr: int + adc_type: int + master_adc_tile: int + master_dac_tile: int + adc_sysref_source: int + dac_sysref_source: int + ip_type: int + si_revision: int + dac_tile_config: _containers.RepeatedCompositeFieldContainer[DACTileConfig] + adc_tile_config: _containers.RepeatedCompositeFieldContainer[ADCTileConfig] + def __init__(self, device_id: _Optional[int] = ..., base_addr: _Optional[int] = ..., adc_type: _Optional[int] = ..., master_adc_tile: _Optional[int] = ..., master_dac_tile: _Optional[int] = ..., adc_sysref_source: _Optional[int] = ..., dac_sysref_source: _Optional[int] = ..., ip_type: _Optional[int] = ..., si_revision: _Optional[int] = ..., dac_tile_config: _Optional[_Iterable[_Union[DACTileConfig, _Mapping]]] = ..., adc_tile_config: _Optional[_Iterable[_Union[ADCTileConfig, _Mapping]]] = ...) -> None: ... + +class CfgInitializeRequest(_message.Message): + __slots__ = ("config", "size") + CONFIG_FIELD_NUMBER: _ClassVar[int] + SIZE_FIELD_NUMBER: _ClassVar[int] + config: RFdcConfig + size: int + def __init__(self, config: _Optional[_Union[RFdcConfig, _Mapping]] = ..., size: _Optional[int] = ...) -> None: ... + +class CfgInitializeResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ...) -> None: ... + +class GetIPStatusRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class GetIPStatusResponse(_message.Message): + __slots__ = ("status", "ip_status") + STATUS_FIELD_NUMBER: _ClassVar[int] + IP_STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + ip_status: IPStatus + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., ip_status: _Optional[_Union[IPStatus, _Mapping]] = ...) -> None: ... + +class TileControlRequest(_message.Message): + __slots__ = ("tile_type", "tile_id") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ...) -> None: ... + +class TileControlResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ...) -> None: ... + +class SetupFIFORequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "enable", "block_id") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + ENABLE_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + enable: bool + block_id: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., enable: bool = ..., block_id: _Optional[int] = ...) -> None: ... + +class DynamicPLLConfigRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "source", "ref_clk_freq", "samp_rate") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + SOURCE_FIELD_NUMBER: _ClassVar[int] + REF_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + SAMP_RATE_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + source: int + ref_clk_freq: float + samp_rate: float + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., source: _Optional[int] = ..., ref_clk_freq: _Optional[float] = ..., samp_rate: _Optional[float] = ...) -> None: ... + +class BlockRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ...) -> None: ... + +class TileRequest(_message.Message): + __slots__ = ("tile_type", "tile_id") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ...) -> None: ... + +class GetBlockStatusResponse(_message.Message): + __slots__ = ("status", "sampling_freq", "analog_data_path_status", "digital_data_path_status", "data_path_clocks_status", "is_fifo_flags_enabled", "is_fifo_flags_asserted") + STATUS_FIELD_NUMBER: _ClassVar[int] + SAMPLING_FREQ_FIELD_NUMBER: _ClassVar[int] + ANALOG_DATA_PATH_STATUS_FIELD_NUMBER: _ClassVar[int] + DIGITAL_DATA_PATH_STATUS_FIELD_NUMBER: _ClassVar[int] + DATA_PATH_CLOCKS_STATUS_FIELD_NUMBER: _ClassVar[int] + IS_FIFO_FLAGS_ENABLED_FIELD_NUMBER: _ClassVar[int] + IS_FIFO_FLAGS_ASSERTED_FIELD_NUMBER: _ClassVar[int] + status: Status + sampling_freq: float + analog_data_path_status: int + digital_data_path_status: int + data_path_clocks_status: int + is_fifo_flags_enabled: int + is_fifo_flags_asserted: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., sampling_freq: _Optional[float] = ..., analog_data_path_status: _Optional[int] = ..., digital_data_path_status: _Optional[int] = ..., data_path_clocks_status: _Optional[int] = ..., is_fifo_flags_enabled: _Optional[int] = ..., is_fifo_flags_asserted: _Optional[int] = ...) -> None: ... + +class GetFIFOStatusResponse(_message.Message): + __slots__ = ("status", "enable") + STATUS_FIELD_NUMBER: _ClassVar[int] + ENABLE_FIELD_NUMBER: _ClassVar[int] + status: Status + enable: bool + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., enable: bool = ...) -> None: ... + +class GetPLLLockStatusResponse(_message.Message): + __slots__ = ("status", "lock_status") + STATUS_FIELD_NUMBER: _ClassVar[int] + LOCK_STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + lock_status: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., lock_status: _Optional[int] = ...) -> None: ... + +class GetClockSourceResponse(_message.Message): + __slots__ = ("status", "clock_source") + STATUS_FIELD_NUMBER: _ClassVar[int] + CLOCK_SOURCE_FIELD_NUMBER: _ClassVar[int] + status: Status + clock_source: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., clock_source: _Optional[int] = ...) -> None: ... + +class SetFabClkOutDivRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "fab_clk_div") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + FAB_CLK_DIV_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + fab_clk_div: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., fab_clk_div: _Optional[int] = ...) -> None: ... + +class GetFabClkOutDivResponse(_message.Message): + __slots__ = ("status", "fab_clk_div") + STATUS_FIELD_NUMBER: _ClassVar[int] + FAB_CLK_DIV_FIELD_NUMBER: _ClassVar[int] + status: Status + fab_clk_div: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., fab_clk_div: _Optional[int] = ...) -> None: ... + +class MixerSettings(_message.Message): + __slots__ = ("freq", "phase_offset", "event_source", "coarse_mix_freq", "mixer_mode", "fine_mixer_scale", "mixer_type") + FREQ_FIELD_NUMBER: _ClassVar[int] + PHASE_OFFSET_FIELD_NUMBER: _ClassVar[int] + EVENT_SOURCE_FIELD_NUMBER: _ClassVar[int] + COARSE_MIX_FREQ_FIELD_NUMBER: _ClassVar[int] + MIXER_MODE_FIELD_NUMBER: _ClassVar[int] + FINE_MIXER_SCALE_FIELD_NUMBER: _ClassVar[int] + MIXER_TYPE_FIELD_NUMBER: _ClassVar[int] + freq: float + phase_offset: float + event_source: int + coarse_mix_freq: int + mixer_mode: int + fine_mixer_scale: int + mixer_type: int + def __init__(self, freq: _Optional[float] = ..., phase_offset: _Optional[float] = ..., event_source: _Optional[int] = ..., coarse_mix_freq: _Optional[int] = ..., mixer_mode: _Optional[int] = ..., fine_mixer_scale: _Optional[int] = ..., mixer_type: _Optional[int] = ...) -> None: ... + +class SetMixerSettingsRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id", "settings") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + settings: MixerSettings + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[MixerSettings, _Mapping]] = ...) -> None: ... + +class GetMixerSettingsResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: MixerSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[MixerSettings, _Mapping]] = ...) -> None: ... + +class ResetNCOPhaseRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ...) -> None: ... + +class SetNyquistZoneRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id", "nyquist_zone") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + NYQUIST_ZONE_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + nyquist_zone: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., nyquist_zone: _Optional[int] = ...) -> None: ... + +class GetNyquistZoneResponse(_message.Message): + __slots__ = ("status", "nyquist_zone") + STATUS_FIELD_NUMBER: _ClassVar[int] + NYQUIST_ZONE_FIELD_NUMBER: _ClassVar[int] + status: Status + nyquist_zone: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., nyquist_zone: _Optional[int] = ...) -> None: ... + +class SetInterpolationFactorRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "interp_factor") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + INTERP_FACTOR_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + interp_factor: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., interp_factor: _Optional[int] = ...) -> None: ... + +class GetInterpolationFactorResponse(_message.Message): + __slots__ = ("status", "interp_factor") + STATUS_FIELD_NUMBER: _ClassVar[int] + INTERP_FACTOR_FIELD_NUMBER: _ClassVar[int] + status: Status + interp_factor: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., interp_factor: _Optional[int] = ...) -> None: ... + +class SetDecimationFactorRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "dec_factor") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + DEC_FACTOR_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + dec_factor: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., dec_factor: _Optional[int] = ...) -> None: ... + +class GetDecimationFactorResponse(_message.Message): + __slots__ = ("status", "dec_factor") + STATUS_FIELD_NUMBER: _ClassVar[int] + DEC_FACTOR_FIELD_NUMBER: _ClassVar[int] + status: Status + dec_factor: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., dec_factor: _Optional[int] = ...) -> None: ... + +class QMCSettings(_message.Message): + __slots__ = ("enable_phase", "enable_gain", "enable_offset_corr", "gain_correction_factor", "phase_correction_factor", "offset_correction_factor", "event_source") + ENABLE_PHASE_FIELD_NUMBER: _ClassVar[int] + ENABLE_GAIN_FIELD_NUMBER: _ClassVar[int] + ENABLE_OFFSET_CORR_FIELD_NUMBER: _ClassVar[int] + GAIN_CORRECTION_FACTOR_FIELD_NUMBER: _ClassVar[int] + PHASE_CORRECTION_FACTOR_FIELD_NUMBER: _ClassVar[int] + OFFSET_CORRECTION_FACTOR_FIELD_NUMBER: _ClassVar[int] + EVENT_SOURCE_FIELD_NUMBER: _ClassVar[int] + enable_phase: bool + enable_gain: bool + enable_offset_corr: bool + gain_correction_factor: float + phase_correction_factor: float + offset_correction_factor: int + event_source: int + def __init__(self, enable_phase: bool = ..., enable_gain: bool = ..., enable_offset_corr: bool = ..., gain_correction_factor: _Optional[float] = ..., phase_correction_factor: _Optional[float] = ..., offset_correction_factor: _Optional[int] = ..., event_source: _Optional[int] = ...) -> None: ... + +class SetQMCSettingsRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id", "settings") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + settings: QMCSettings + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[QMCSettings, _Mapping]] = ...) -> None: ... + +class GetQMCSettingsResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: QMCSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[QMCSettings, _Mapping]] = ...) -> None: ... + +class ThresholdSettings(_message.Message): + __slots__ = ("update_threshold", "threshold_mode", "threshold_avg_val", "threshold_under_val", "threshold_over_val") + UPDATE_THRESHOLD_FIELD_NUMBER: _ClassVar[int] + THRESHOLD_MODE_FIELD_NUMBER: _ClassVar[int] + THRESHOLD_AVG_VAL_FIELD_NUMBER: _ClassVar[int] + THRESHOLD_UNDER_VAL_FIELD_NUMBER: _ClassVar[int] + THRESHOLD_OVER_VAL_FIELD_NUMBER: _ClassVar[int] + update_threshold: int + threshold_mode: _containers.RepeatedScalarFieldContainer[int] + threshold_avg_val: _containers.RepeatedScalarFieldContainer[int] + threshold_under_val: _containers.RepeatedScalarFieldContainer[int] + threshold_over_val: _containers.RepeatedScalarFieldContainer[int] + def __init__(self, update_threshold: _Optional[int] = ..., threshold_mode: _Optional[_Iterable[int]] = ..., threshold_avg_val: _Optional[_Iterable[int]] = ..., threshold_under_val: _Optional[_Iterable[int]] = ..., threshold_over_val: _Optional[_Iterable[int]] = ...) -> None: ... + +class SetThresholdSettingsRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "settings") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + settings: ThresholdSettings + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[ThresholdSettings, _Mapping]] = ...) -> None: ... + +class GetThresholdSettingsResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: ThresholdSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[ThresholdSettings, _Mapping]] = ...) -> None: ... + +class CoarseDelaySettings(_message.Message): + __slots__ = ("coarse_delay", "event_source") + COARSE_DELAY_FIELD_NUMBER: _ClassVar[int] + EVENT_SOURCE_FIELD_NUMBER: _ClassVar[int] + coarse_delay: int + event_source: int + def __init__(self, coarse_delay: _Optional[int] = ..., event_source: _Optional[int] = ...) -> None: ... + +class SetThresholdClrModeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "threshold_to_update", "clr_mode") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + THRESHOLD_TO_UPDATE_FIELD_NUMBER: _ClassVar[int] + CLR_MODE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + threshold_to_update: int + clr_mode: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., threshold_to_update: _Optional[int] = ..., clr_mode: _Optional[int] = ...) -> None: ... + +class SetThresholdClrModeResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ...) -> None: ... + +class ThresholdStickyClearRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "threshold_to_update") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + THRESHOLD_TO_UPDATE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + threshold_to_update: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., threshold_to_update: _Optional[int] = ...) -> None: ... + +class ThresholdStickyClearResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ...) -> None: ... + +class GetCoarseDelaySettingsRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ...) -> None: ... + +class GetCoarseDelaySettingsResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: CoarseDelaySettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[CoarseDelaySettings, _Mapping]] = ...) -> None: ... + +class SetCoarseDelaySettingsRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id", "settings") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + settings: CoarseDelaySettings + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[CoarseDelaySettings, _Mapping]] = ...) -> None: ... + +class SetCoarseDelaySettingsResponse(_message.Message): + __slots__ = ("status",) + STATUS_FIELD_NUMBER: _ClassVar[int] + status: Status + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ...) -> None: ... + +class PwrModeSettings(_message.Message): + __slots__ = ("disable_ip_control", "pwr_mode") + DISABLE_IP_CONTROL_FIELD_NUMBER: _ClassVar[int] + PWR_MODE_FIELD_NUMBER: _ClassVar[int] + disable_ip_control: int + pwr_mode: int + def __init__(self, disable_ip_control: _Optional[int] = ..., pwr_mode: _Optional[int] = ...) -> None: ... + +class GetPwrModeResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: PwrModeSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[PwrModeSettings, _Mapping]] = ...) -> None: ... + +class SetPwrModeRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id", "settings") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + settings: PwrModeSettings + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[PwrModeSettings, _Mapping]] = ...) -> None: ... + +class UpdateEventRequest(_message.Message): + __slots__ = ("tile_type", "tile_id", "block_id", "event") + TILE_TYPE_FIELD_NUMBER: _ClassVar[int] + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + EVENT_FIELD_NUMBER: _ClassVar[int] + tile_type: int + tile_id: int + block_id: int + event: int + def __init__(self, tile_type: _Optional[int] = ..., tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., event: _Optional[int] = ...) -> None: ... + +class GetConnectedDataResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class GetEnabledInterruptsResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class GetCalibrationModeResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetCalibrationModeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetFabRdVldWordsResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetFabRdVldWordsRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetFabWrVldWordsResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetFabWrVldWordsRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetFabRdVldWordsObsResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetFabRdVldWordsObsRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetFabWrVldWordsObsResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetDitherRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetDitherResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetDecoderModeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetDecoderModeResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class GetOutputCurrResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class GetInvSincFIRResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetInvSincFIRRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetDataPathModeResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetDataPathModeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetIMRPassModeResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetIMRPassModeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class GetDACCompModeResponse(_message.Message): + __slots__ = ("status", "value") + STATUS_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + status: Status + value: int + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., value: _Optional[int] = ...) -> None: ... + +class SetDACCompModeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "value") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + VALUE_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + value: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., value: _Optional[int] = ...) -> None: ... + +class CalFreezeSettings(_message.Message): + __slots__ = ("cal_frozen", "disable_freeze_pin", "freeze_calibration") + CAL_FROZEN_FIELD_NUMBER: _ClassVar[int] + DISABLE_FREEZE_PIN_FIELD_NUMBER: _ClassVar[int] + FREEZE_CALIBRATION_FIELD_NUMBER: _ClassVar[int] + cal_frozen: int + disable_freeze_pin: int + freeze_calibration: int + def __init__(self, cal_frozen: _Optional[int] = ..., disable_freeze_pin: _Optional[int] = ..., freeze_calibration: _Optional[int] = ...) -> None: ... + +class GetCalFreezeResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: CalFreezeSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[CalFreezeSettings, _Mapping]] = ...) -> None: ... + +class SetCalFreezeRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "settings") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + settings: CalFreezeSettings + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[CalFreezeSettings, _Mapping]] = ...) -> None: ... + +class DSASettings(_message.Message): + __slots__ = ("disable_rts", "attenuation") + DISABLE_RTS_FIELD_NUMBER: _ClassVar[int] + ATTENUATION_FIELD_NUMBER: _ClassVar[int] + disable_rts: int + attenuation: float + def __init__(self, disable_rts: _Optional[int] = ..., attenuation: _Optional[float] = ...) -> None: ... + +class GetDSAResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: DSASettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[DSASettings, _Mapping]] = ...) -> None: ... + +class SetDSARequest(_message.Message): + __slots__ = ("tile_id", "block_id", "settings") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + settings: DSASettings + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., settings: _Optional[_Union[DSASettings, _Mapping]] = ...) -> None: ... + +class DisableCoefficientsOverrideRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "calibration_block") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + CALIBRATION_BLOCK_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + calibration_block: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., calibration_block: _Optional[int] = ...) -> None: ... + +class CalibrationCoefficients(_message.Message): + __slots__ = ("coeff0", "coeff1", "coeff2", "coeff3", "coeff4", "coeff5", "coeff6", "coeff7") + COEFF0_FIELD_NUMBER: _ClassVar[int] + COEFF1_FIELD_NUMBER: _ClassVar[int] + COEFF2_FIELD_NUMBER: _ClassVar[int] + COEFF3_FIELD_NUMBER: _ClassVar[int] + COEFF4_FIELD_NUMBER: _ClassVar[int] + COEFF5_FIELD_NUMBER: _ClassVar[int] + COEFF6_FIELD_NUMBER: _ClassVar[int] + COEFF7_FIELD_NUMBER: _ClassVar[int] + coeff0: int + coeff1: int + coeff2: int + coeff3: int + coeff4: int + coeff5: int + coeff6: int + coeff7: int + def __init__(self, coeff0: _Optional[int] = ..., coeff1: _Optional[int] = ..., coeff2: _Optional[int] = ..., coeff3: _Optional[int] = ..., coeff4: _Optional[int] = ..., coeff5: _Optional[int] = ..., coeff6: _Optional[int] = ..., coeff7: _Optional[int] = ...) -> None: ... + +class SetCalCoefficientsRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "calibration_block", "coeffs") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + CALIBRATION_BLOCK_FIELD_NUMBER: _ClassVar[int] + COEFFS_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + calibration_block: int + coeffs: CalibrationCoefficients + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., calibration_block: _Optional[int] = ..., coeffs: _Optional[_Union[CalibrationCoefficients, _Mapping]] = ...) -> None: ... + +class GetCalCoefficientsRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "calibration_block") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + CALIBRATION_BLOCK_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + calibration_block: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., calibration_block: _Optional[int] = ...) -> None: ... + +class GetCalCoefficientsResponse(_message.Message): + __slots__ = ("status", "coeffs") + STATUS_FIELD_NUMBER: _ClassVar[int] + COEFFS_FIELD_NUMBER: _ClassVar[int] + status: Status + coeffs: CalibrationCoefficients + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., coeffs: _Optional[_Union[CalibrationCoefficients, _Mapping]] = ...) -> None: ... + +class SetDACVOPRequest(_message.Message): + __slots__ = ("tile_id", "block_id", "uA_current") + TILE_ID_FIELD_NUMBER: _ClassVar[int] + BLOCK_ID_FIELD_NUMBER: _ClassVar[int] + UA_CURRENT_FIELD_NUMBER: _ClassVar[int] + tile_id: int + block_id: int + uA_current: int + def __init__(self, tile_id: _Optional[int] = ..., block_id: _Optional[int] = ..., uA_current: _Optional[int] = ...) -> None: ... + +class PLLSettings(_message.Message): + __slots__ = ("enabled", "ref_clk_freq", "sample_rate", "ref_clk_divider", "feedback_divider", "output_divider", "fractional_mode", "fractional_data", "fract_width") + ENABLED_FIELD_NUMBER: _ClassVar[int] + REF_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + SAMPLE_RATE_FIELD_NUMBER: _ClassVar[int] + REF_CLK_DIVIDER_FIELD_NUMBER: _ClassVar[int] + FEEDBACK_DIVIDER_FIELD_NUMBER: _ClassVar[int] + OUTPUT_DIVIDER_FIELD_NUMBER: _ClassVar[int] + FRACTIONAL_MODE_FIELD_NUMBER: _ClassVar[int] + FRACTIONAL_DATA_FIELD_NUMBER: _ClassVar[int] + FRACT_WIDTH_FIELD_NUMBER: _ClassVar[int] + enabled: int + ref_clk_freq: float + sample_rate: float + ref_clk_divider: int + feedback_divider: int + output_divider: int + fractional_mode: int + fractional_data: int + fract_width: int + def __init__(self, enabled: _Optional[int] = ..., ref_clk_freq: _Optional[float] = ..., sample_rate: _Optional[float] = ..., ref_clk_divider: _Optional[int] = ..., feedback_divider: _Optional[int] = ..., output_divider: _Optional[int] = ..., fractional_mode: _Optional[int] = ..., fractional_data: _Optional[int] = ..., fract_width: _Optional[int] = ...) -> None: ... + +class GetPLLConfigResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: PLLSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[PLLSettings, _Mapping]] = ...) -> None: ... + +class GetClkDistributionRequest(_message.Message): + __slots__ = () + def __init__(self) -> None: ... + +class Distribution(_message.Message): + __slots__ = ("source", "upper_bound", "lower_bound", "max_delay", "min_delay", "is_delay_balanced") + SOURCE_FIELD_NUMBER: _ClassVar[int] + UPPER_BOUND_FIELD_NUMBER: _ClassVar[int] + LOWER_BOUND_FIELD_NUMBER: _ClassVar[int] + MAX_DELAY_FIELD_NUMBER: _ClassVar[int] + MIN_DELAY_FIELD_NUMBER: _ClassVar[int] + IS_DELAY_BALANCED_FIELD_NUMBER: _ClassVar[int] + source: int + upper_bound: int + lower_bound: int + max_delay: int + min_delay: int + is_delay_balanced: int + def __init__(self, source: _Optional[int] = ..., upper_bound: _Optional[int] = ..., lower_bound: _Optional[int] = ..., max_delay: _Optional[int] = ..., min_delay: _Optional[int] = ..., is_delay_balanced: _Optional[int] = ...) -> None: ... + +class TileClockSettings(_message.Message): + __slots__ = ("source_type", "source_tile", "pll_enable", "ref_clk_freq", "sample_rate", "division_factor", "distributed_clock", "delay") + SOURCE_TYPE_FIELD_NUMBER: _ClassVar[int] + SOURCE_TILE_FIELD_NUMBER: _ClassVar[int] + PLL_ENABLE_FIELD_NUMBER: _ClassVar[int] + REF_CLK_FREQ_FIELD_NUMBER: _ClassVar[int] + SAMPLE_RATE_FIELD_NUMBER: _ClassVar[int] + DIVISION_FACTOR_FIELD_NUMBER: _ClassVar[int] + DISTRIBUTED_CLOCK_FIELD_NUMBER: _ClassVar[int] + DELAY_FIELD_NUMBER: _ClassVar[int] + source_type: int + source_tile: int + pll_enable: int + ref_clk_freq: float + sample_rate: float + division_factor: int + distributed_clock: int + delay: int + def __init__(self, source_type: _Optional[int] = ..., source_tile: _Optional[int] = ..., pll_enable: _Optional[int] = ..., ref_clk_freq: _Optional[float] = ..., sample_rate: _Optional[float] = ..., division_factor: _Optional[int] = ..., distributed_clock: _Optional[int] = ..., delay: _Optional[int] = ...) -> None: ... + +class ClkDistributionSettings(_message.Message): + __slots__ = ("dac", "adc", "distribution_info") + DAC_FIELD_NUMBER: _ClassVar[int] + ADC_FIELD_NUMBER: _ClassVar[int] + DISTRIBUTION_INFO_FIELD_NUMBER: _ClassVar[int] + dac: _containers.RepeatedCompositeFieldContainer[TileClockSettings] + adc: _containers.RepeatedCompositeFieldContainer[TileClockSettings] + distribution_info: Distribution + def __init__(self, dac: _Optional[_Iterable[_Union[TileClockSettings, _Mapping]]] = ..., adc: _Optional[_Iterable[_Union[TileClockSettings, _Mapping]]] = ..., distribution_info: _Optional[_Union[Distribution, _Mapping]] = ...) -> None: ... + +class GetClkDistributionResponse(_message.Message): + __slots__ = ("status", "settings") + STATUS_FIELD_NUMBER: _ClassVar[int] + SETTINGS_FIELD_NUMBER: _ClassVar[int] + status: Status + settings: ClkDistributionSettings + def __init__(self, status: _Optional[_Union[Status, _Mapping]] = ..., settings: _Optional[_Union[ClkDistributionSettings, _Mapping]] = ...) -> None: ... + +class SetClkDistributionRequest(_message.Message): + __slots__ = ("settings",) + SETTINGS_FIELD_NUMBER: _ClassVar[int] + settings: ClkDistributionSettings + def __init__(self, settings: _Optional[_Union[ClkDistributionSettings, _Mapping]] = ...) -> None: ... diff --git a/pynq/remote/xrfdc_pb2_grpc.py b/pynq/remote/xrfdc_pb2_grpc.py new file mode 100644 index 000000000..d5c9a9e06 --- /dev/null +++ b/pynq/remote/xrfdc_pb2_grpc.py @@ -0,0 +1,3370 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import grpc +import warnings + +from pynq.remote import xrfdc_pb2 as xrfdc__pb2 + +GRPC_GENERATED_VERSION = '1.64.0' +GRPC_VERSION = grpc.__version__ +EXPECTED_ERROR_RELEASE = '1.65.0' +SCHEDULED_RELEASE_DATE = 'June 25, 2024' +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + warnings.warn( + f'The grpc package installed is at version {GRPC_VERSION},' + + f' but the generated code in xrfdc_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},' + + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.', + RuntimeWarning + ) + + +class XrfdcStub(object): + """Missing associated documentation comment in .proto file.""" + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.CfgInitialize = channel.unary_unary( + '/xrfdc.Xrfdc/CfgInitialize', + request_serializer=xrfdc__pb2.CfgInitializeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.CfgInitializeResponse.FromString, + _registered_method=True) + self.GetIPStatus = channel.unary_unary( + '/xrfdc.Xrfdc/GetIPStatus', + request_serializer=xrfdc__pb2.GetIPStatusRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetIPStatusResponse.FromString, + _registered_method=True) + self.GetBlockStatus = channel.unary_unary( + '/xrfdc.Xrfdc/GetBlockStatus', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetBlockStatusResponse.FromString, + _registered_method=True) + self.GetFIFOStatus = channel.unary_unary( + '/xrfdc.Xrfdc/GetFIFOStatus', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFIFOStatusResponse.FromString, + _registered_method=True) + self.GetPLLLockStatus = channel.unary_unary( + '/xrfdc.Xrfdc/GetPLLLockStatus', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetPLLLockStatusResponse.FromString, + _registered_method=True) + self.GetClockSource = channel.unary_unary( + '/xrfdc.Xrfdc/GetClockSource', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetClockSourceResponse.FromString, + _registered_method=True) + self.StartUp = channel.unary_unary( + '/xrfdc.Xrfdc/StartUp', + request_serializer=xrfdc__pb2.TileControlRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.Shutdown = channel.unary_unary( + '/xrfdc.Xrfdc/Shutdown', + request_serializer=xrfdc__pb2.TileControlRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.Reset = channel.unary_unary( + '/xrfdc.Xrfdc/Reset', + request_serializer=xrfdc__pb2.TileControlRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.SetupFIFO = channel.unary_unary( + '/xrfdc.Xrfdc/SetupFIFO', + request_serializer=xrfdc__pb2.SetupFIFORequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.DynamicPLLConfig = channel.unary_unary( + '/xrfdc.Xrfdc/DynamicPLLConfig', + request_serializer=xrfdc__pb2.DynamicPLLConfigRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.SetFabClkOutDiv = channel.unary_unary( + '/xrfdc.Xrfdc/SetFabClkOutDiv', + request_serializer=xrfdc__pb2.SetFabClkOutDivRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetFabClkOutDiv = channel.unary_unary( + '/xrfdc.Xrfdc/GetFabClkOutDiv', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFabClkOutDivResponse.FromString, + _registered_method=True) + self.SetMixerSettings = channel.unary_unary( + '/xrfdc.Xrfdc/SetMixerSettings', + request_serializer=xrfdc__pb2.SetMixerSettingsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetMixerSettings = channel.unary_unary( + '/xrfdc.Xrfdc/GetMixerSettings', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetMixerSettingsResponse.FromString, + _registered_method=True) + self.ResetNCOPhase = channel.unary_unary( + '/xrfdc.Xrfdc/ResetNCOPhase', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.SetNyquistZone = channel.unary_unary( + '/xrfdc.Xrfdc/SetNyquistZone', + request_serializer=xrfdc__pb2.SetNyquistZoneRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetNyquistZone = channel.unary_unary( + '/xrfdc.Xrfdc/GetNyquistZone', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetNyquistZoneResponse.FromString, + _registered_method=True) + self.SetInterpolationFactor = channel.unary_unary( + '/xrfdc.Xrfdc/SetInterpolationFactor', + request_serializer=xrfdc__pb2.SetInterpolationFactorRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetInterpolationFactor = channel.unary_unary( + '/xrfdc.Xrfdc/GetInterpolationFactor', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetInterpolationFactorResponse.FromString, + _registered_method=True) + self.SetDecimationFactor = channel.unary_unary( + '/xrfdc.Xrfdc/SetDecimationFactor', + request_serializer=xrfdc__pb2.SetDecimationFactorRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetDecimationFactor = channel.unary_unary( + '/xrfdc.Xrfdc/GetDecimationFactor', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDecimationFactorResponse.FromString, + _registered_method=True) + self.SetQMCSettings = channel.unary_unary( + '/xrfdc.Xrfdc/SetQMCSettings', + request_serializer=xrfdc__pb2.SetQMCSettingsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetQMCSettings = channel.unary_unary( + '/xrfdc.Xrfdc/GetQMCSettings', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetQMCSettingsResponse.FromString, + _registered_method=True) + self.SetThresholdSettings = channel.unary_unary( + '/xrfdc.Xrfdc/SetThresholdSettings', + request_serializer=xrfdc__pb2.SetThresholdSettingsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetThresholdSettings = channel.unary_unary( + '/xrfdc.Xrfdc/GetThresholdSettings', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetThresholdSettingsResponse.FromString, + _registered_method=True) + self.SetThresholdClrMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetThresholdClrMode', + request_serializer=xrfdc__pb2.SetThresholdClrModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.SetThresholdClrModeResponse.FromString, + _registered_method=True) + self.ThresholdStickyClear = channel.unary_unary( + '/xrfdc.Xrfdc/ThresholdStickyClear', + request_serializer=xrfdc__pb2.ThresholdStickyClearRequest.SerializeToString, + response_deserializer=xrfdc__pb2.ThresholdStickyClearResponse.FromString, + _registered_method=True) + self.GetCoarseDelaySettings = channel.unary_unary( + '/xrfdc.Xrfdc/GetCoarseDelaySettings', + request_serializer=xrfdc__pb2.GetCoarseDelaySettingsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetCoarseDelaySettingsResponse.FromString, + _registered_method=True) + self.SetCoarseDelaySettings = channel.unary_unary( + '/xrfdc.Xrfdc/SetCoarseDelaySettings', + request_serializer=xrfdc__pb2.SetCoarseDelaySettingsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.SetCoarseDelaySettingsResponse.FromString, + _registered_method=True) + self.GetEnabledInterrupts = channel.unary_unary( + '/xrfdc.Xrfdc/GetEnabledInterrupts', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetEnabledInterruptsResponse.FromString, + _registered_method=True) + self.GetPwrMode = channel.unary_unary( + '/xrfdc.Xrfdc/GetPwrMode', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetPwrModeResponse.FromString, + _registered_method=True) + self.SetPwrMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetPwrMode', + request_serializer=xrfdc__pb2.SetPwrModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.UpdateEvent = channel.unary_unary( + '/xrfdc.Xrfdc/UpdateEvent', + request_serializer=xrfdc__pb2.UpdateEventRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.ResetInternalFIFOWidth = channel.unary_unary( + '/xrfdc.Xrfdc/ResetInternalFIFOWidth', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetConnectedIData = channel.unary_unary( + '/xrfdc.Xrfdc/GetConnectedIData', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetConnectedDataResponse.FromString, + _registered_method=True) + self.GetConnectedQData = channel.unary_unary( + '/xrfdc.Xrfdc/GetConnectedQData', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetConnectedDataResponse.FromString, + _registered_method=True) + self.GetCalibrationMode = channel.unary_unary( + '/xrfdc.Xrfdc/GetCalibrationMode', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetCalibrationModeResponse.FromString, + _registered_method=True) + self.SetCalibrationMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetCalibrationMode', + request_serializer=xrfdc__pb2.SetCalibrationModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetFabRdVldWords = channel.unary_unary( + '/xrfdc.Xrfdc/GetFabRdVldWords', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFabRdVldWordsResponse.FromString, + _registered_method=True) + self.SetFabRdVldWords = channel.unary_unary( + '/xrfdc.Xrfdc/SetFabRdVldWords', + request_serializer=xrfdc__pb2.SetFabRdVldWordsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetFabWrVldWords = channel.unary_unary( + '/xrfdc.Xrfdc/GetFabWrVldWords', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFabWrVldWordsResponse.FromString, + _registered_method=True) + self.SetFabWrVldWords = channel.unary_unary( + '/xrfdc.Xrfdc/SetFabWrVldWords', + request_serializer=xrfdc__pb2.SetFabWrVldWordsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetDecimationFactorObs = channel.unary_unary( + '/xrfdc.Xrfdc/GetDecimationFactorObs', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDecimationFactorResponse.FromString, + _registered_method=True) + self.SetDecimationFactorObs = channel.unary_unary( + '/xrfdc.Xrfdc/SetDecimationFactorObs', + request_serializer=xrfdc__pb2.SetDecimationFactorRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetFabRdVldWordsObs = channel.unary_unary( + '/xrfdc.Xrfdc/GetFabRdVldWordsObs', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFabRdVldWordsObsResponse.FromString, + _registered_method=True) + self.SetFabRdVldWordsObs = channel.unary_unary( + '/xrfdc.Xrfdc/SetFabRdVldWordsObs', + request_serializer=xrfdc__pb2.SetFabRdVldWordsObsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetFabWrVldWordsObs = channel.unary_unary( + '/xrfdc.Xrfdc/GetFabWrVldWordsObs', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFabWrVldWordsObsResponse.FromString, + _registered_method=True) + self.GetDither = channel.unary_unary( + '/xrfdc.Xrfdc/GetDither', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDitherResponse.FromString, + _registered_method=True) + self.SetDither = channel.unary_unary( + '/xrfdc.Xrfdc/SetDither', + request_serializer=xrfdc__pb2.SetDitherRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetCalFreeze = channel.unary_unary( + '/xrfdc.Xrfdc/GetCalFreeze', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetCalFreezeResponse.FromString, + _registered_method=True) + self.SetCalFreeze = channel.unary_unary( + '/xrfdc.Xrfdc/SetCalFreeze', + request_serializer=xrfdc__pb2.SetCalFreezeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetDSA = channel.unary_unary( + '/xrfdc.Xrfdc/GetDSA', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDSAResponse.FromString, + _registered_method=True) + self.SetDSA = channel.unary_unary( + '/xrfdc.Xrfdc/SetDSA', + request_serializer=xrfdc__pb2.SetDSARequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.DisableCoefficientsOverride = channel.unary_unary( + '/xrfdc.Xrfdc/DisableCoefficientsOverride', + request_serializer=xrfdc__pb2.DisableCoefficientsOverrideRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.ResetInternalFIFOWidthObs = channel.unary_unary( + '/xrfdc.Xrfdc/ResetInternalFIFOWidthObs', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.SetCalCoefficients = channel.unary_unary( + '/xrfdc.Xrfdc/SetCalCoefficients', + request_serializer=xrfdc__pb2.SetCalCoefficientsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetCalCoefficients = channel.unary_unary( + '/xrfdc.Xrfdc/GetCalCoefficients', + request_serializer=xrfdc__pb2.GetCalCoefficientsRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetCalCoefficientsResponse.FromString, + _registered_method=True) + self.GetDecoderMode = channel.unary_unary( + '/xrfdc.Xrfdc/GetDecoderMode', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDecoderModeResponse.FromString, + _registered_method=True) + self.SetDecoderMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetDecoderMode', + request_serializer=xrfdc__pb2.SetDecoderModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetOutputCurr = channel.unary_unary( + '/xrfdc.Xrfdc/GetOutputCurr', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetOutputCurrResponse.FromString, + _registered_method=True) + self.GetInvSincFIR = channel.unary_unary( + '/xrfdc.Xrfdc/GetInvSincFIR', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetInvSincFIRResponse.FromString, + _registered_method=True) + self.SetInvSincFIR = channel.unary_unary( + '/xrfdc.Xrfdc/SetInvSincFIR', + request_serializer=xrfdc__pb2.SetInvSincFIRRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetDataPathMode = channel.unary_unary( + '/xrfdc.Xrfdc/GetDataPathMode', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDataPathModeResponse.FromString, + _registered_method=True) + self.SetDataPathMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetDataPathMode', + request_serializer=xrfdc__pb2.SetDataPathModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetIMRPassMode = channel.unary_unary( + '/xrfdc.Xrfdc/GetIMRPassMode', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetIMRPassModeResponse.FromString, + _registered_method=True) + self.SetIMRPassMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetIMRPassMode', + request_serializer=xrfdc__pb2.SetIMRPassModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetDACCompMode = channel.unary_unary( + '/xrfdc.Xrfdc/GetDACCompMode', + request_serializer=xrfdc__pb2.BlockRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetDACCompModeResponse.FromString, + _registered_method=True) + self.SetDACCompMode = channel.unary_unary( + '/xrfdc.Xrfdc/SetDACCompMode', + request_serializer=xrfdc__pb2.SetDACCompModeRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.SetDACVOP = channel.unary_unary( + '/xrfdc.Xrfdc/SetDACVOP', + request_serializer=xrfdc__pb2.SetDACVOPRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.DumpRegs = channel.unary_unary( + '/xrfdc.Xrfdc/DumpRegs', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetPLLConfig = channel.unary_unary( + '/xrfdc.Xrfdc/GetPLLConfig', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetPLLConfigResponse.FromString, + _registered_method=True) + self.SetupFIFOObs = channel.unary_unary( + '/xrfdc.Xrfdc/SetupFIFOObs', + request_serializer=xrfdc__pb2.SetupFIFORequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.SetupFIFOBoth = channel.unary_unary( + '/xrfdc.Xrfdc/SetupFIFOBoth', + request_serializer=xrfdc__pb2.SetupFIFORequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + self.GetFIFOStatusObs = channel.unary_unary( + '/xrfdc.Xrfdc/GetFIFOStatusObs', + request_serializer=xrfdc__pb2.TileRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetFIFOStatusResponse.FromString, + _registered_method=True) + self.GetClkDistribution = channel.unary_unary( + '/xrfdc.Xrfdc/GetClkDistribution', + request_serializer=xrfdc__pb2.GetClkDistributionRequest.SerializeToString, + response_deserializer=xrfdc__pb2.GetClkDistributionResponse.FromString, + _registered_method=True) + self.SetClkDistribution = channel.unary_unary( + '/xrfdc.Xrfdc/SetClkDistribution', + request_serializer=xrfdc__pb2.SetClkDistributionRequest.SerializeToString, + response_deserializer=xrfdc__pb2.TileControlResponse.FromString, + _registered_method=True) + + +class XrfdcServicer(object): + """Missing associated documentation comment in .proto file.""" + + def CfgInitialize(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIPStatus(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetBlockStatus(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFIFOStatus(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPLLLockStatus(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetClockSource(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def StartUp(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Shutdown(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def Reset(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetupFIFO(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DynamicPLLConfig(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetFabClkOutDiv(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFabClkOutDiv(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetMixerSettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMixerSettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ResetNCOPhase(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetNyquistZone(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetNyquistZone(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetInterpolationFactor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetInterpolationFactor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDecimationFactor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDecimationFactor(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetQMCSettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetQMCSettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetThresholdSettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetThresholdSettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetThresholdClrMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ThresholdStickyClear(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCoarseDelaySettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetCoarseDelaySettings(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetEnabledInterrupts(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPwrMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetPwrMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateEvent(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ResetInternalFIFOWidth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetConnectedIData(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetConnectedQData(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCalibrationMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetCalibrationMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFabRdVldWords(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetFabRdVldWords(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFabWrVldWords(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetFabWrVldWords(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDecimationFactorObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDecimationFactorObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFabRdVldWordsObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetFabRdVldWordsObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFabWrVldWordsObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDither(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDither(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCalFreeze(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetCalFreeze(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDSA(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDSA(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DisableCoefficientsOverride(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ResetInternalFIFOWidthObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetCalCoefficients(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetCalCoefficients(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDecoderMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDecoderMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetOutputCurr(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetInvSincFIR(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetInvSincFIR(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDataPathMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDataPathMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIMRPassMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetIMRPassMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDACCompMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDACCompMode(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetDACVOP(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DumpRegs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetPLLConfig(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetupFIFOObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetupFIFOBoth(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetFIFOStatusObs(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetClkDistribution(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetClkDistribution(self, request, context): + """Missing associated documentation comment in .proto file.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_XrfdcServicer_to_server(servicer, server): + rpc_method_handlers = { + 'CfgInitialize': grpc.unary_unary_rpc_method_handler( + servicer.CfgInitialize, + request_deserializer=xrfdc__pb2.CfgInitializeRequest.FromString, + response_serializer=xrfdc__pb2.CfgInitializeResponse.SerializeToString, + ), + 'GetIPStatus': grpc.unary_unary_rpc_method_handler( + servicer.GetIPStatus, + request_deserializer=xrfdc__pb2.GetIPStatusRequest.FromString, + response_serializer=xrfdc__pb2.GetIPStatusResponse.SerializeToString, + ), + 'GetBlockStatus': grpc.unary_unary_rpc_method_handler( + servicer.GetBlockStatus, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetBlockStatusResponse.SerializeToString, + ), + 'GetFIFOStatus': grpc.unary_unary_rpc_method_handler( + servicer.GetFIFOStatus, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.GetFIFOStatusResponse.SerializeToString, + ), + 'GetPLLLockStatus': grpc.unary_unary_rpc_method_handler( + servicer.GetPLLLockStatus, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.GetPLLLockStatusResponse.SerializeToString, + ), + 'GetClockSource': grpc.unary_unary_rpc_method_handler( + servicer.GetClockSource, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.GetClockSourceResponse.SerializeToString, + ), + 'StartUp': grpc.unary_unary_rpc_method_handler( + servicer.StartUp, + request_deserializer=xrfdc__pb2.TileControlRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'Shutdown': grpc.unary_unary_rpc_method_handler( + servicer.Shutdown, + request_deserializer=xrfdc__pb2.TileControlRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'Reset': grpc.unary_unary_rpc_method_handler( + servicer.Reset, + request_deserializer=xrfdc__pb2.TileControlRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'SetupFIFO': grpc.unary_unary_rpc_method_handler( + servicer.SetupFIFO, + request_deserializer=xrfdc__pb2.SetupFIFORequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'DynamicPLLConfig': grpc.unary_unary_rpc_method_handler( + servicer.DynamicPLLConfig, + request_deserializer=xrfdc__pb2.DynamicPLLConfigRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'SetFabClkOutDiv': grpc.unary_unary_rpc_method_handler( + servicer.SetFabClkOutDiv, + request_deserializer=xrfdc__pb2.SetFabClkOutDivRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetFabClkOutDiv': grpc.unary_unary_rpc_method_handler( + servicer.GetFabClkOutDiv, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.GetFabClkOutDivResponse.SerializeToString, + ), + 'SetMixerSettings': grpc.unary_unary_rpc_method_handler( + servicer.SetMixerSettings, + request_deserializer=xrfdc__pb2.SetMixerSettingsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetMixerSettings': grpc.unary_unary_rpc_method_handler( + servicer.GetMixerSettings, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetMixerSettingsResponse.SerializeToString, + ), + 'ResetNCOPhase': grpc.unary_unary_rpc_method_handler( + servicer.ResetNCOPhase, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'SetNyquistZone': grpc.unary_unary_rpc_method_handler( + servicer.SetNyquistZone, + request_deserializer=xrfdc__pb2.SetNyquistZoneRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetNyquistZone': grpc.unary_unary_rpc_method_handler( + servicer.GetNyquistZone, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetNyquistZoneResponse.SerializeToString, + ), + 'SetInterpolationFactor': grpc.unary_unary_rpc_method_handler( + servicer.SetInterpolationFactor, + request_deserializer=xrfdc__pb2.SetInterpolationFactorRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetInterpolationFactor': grpc.unary_unary_rpc_method_handler( + servicer.GetInterpolationFactor, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetInterpolationFactorResponse.SerializeToString, + ), + 'SetDecimationFactor': grpc.unary_unary_rpc_method_handler( + servicer.SetDecimationFactor, + request_deserializer=xrfdc__pb2.SetDecimationFactorRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetDecimationFactor': grpc.unary_unary_rpc_method_handler( + servicer.GetDecimationFactor, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDecimationFactorResponse.SerializeToString, + ), + 'SetQMCSettings': grpc.unary_unary_rpc_method_handler( + servicer.SetQMCSettings, + request_deserializer=xrfdc__pb2.SetQMCSettingsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetQMCSettings': grpc.unary_unary_rpc_method_handler( + servicer.GetQMCSettings, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetQMCSettingsResponse.SerializeToString, + ), + 'SetThresholdSettings': grpc.unary_unary_rpc_method_handler( + servicer.SetThresholdSettings, + request_deserializer=xrfdc__pb2.SetThresholdSettingsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetThresholdSettings': grpc.unary_unary_rpc_method_handler( + servicer.GetThresholdSettings, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetThresholdSettingsResponse.SerializeToString, + ), + 'SetThresholdClrMode': grpc.unary_unary_rpc_method_handler( + servicer.SetThresholdClrMode, + request_deserializer=xrfdc__pb2.SetThresholdClrModeRequest.FromString, + response_serializer=xrfdc__pb2.SetThresholdClrModeResponse.SerializeToString, + ), + 'ThresholdStickyClear': grpc.unary_unary_rpc_method_handler( + servicer.ThresholdStickyClear, + request_deserializer=xrfdc__pb2.ThresholdStickyClearRequest.FromString, + response_serializer=xrfdc__pb2.ThresholdStickyClearResponse.SerializeToString, + ), + 'GetCoarseDelaySettings': grpc.unary_unary_rpc_method_handler( + servicer.GetCoarseDelaySettings, + request_deserializer=xrfdc__pb2.GetCoarseDelaySettingsRequest.FromString, + response_serializer=xrfdc__pb2.GetCoarseDelaySettingsResponse.SerializeToString, + ), + 'SetCoarseDelaySettings': grpc.unary_unary_rpc_method_handler( + servicer.SetCoarseDelaySettings, + request_deserializer=xrfdc__pb2.SetCoarseDelaySettingsRequest.FromString, + response_serializer=xrfdc__pb2.SetCoarseDelaySettingsResponse.SerializeToString, + ), + 'GetEnabledInterrupts': grpc.unary_unary_rpc_method_handler( + servicer.GetEnabledInterrupts, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetEnabledInterruptsResponse.SerializeToString, + ), + 'GetPwrMode': grpc.unary_unary_rpc_method_handler( + servicer.GetPwrMode, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetPwrModeResponse.SerializeToString, + ), + 'SetPwrMode': grpc.unary_unary_rpc_method_handler( + servicer.SetPwrMode, + request_deserializer=xrfdc__pb2.SetPwrModeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'UpdateEvent': grpc.unary_unary_rpc_method_handler( + servicer.UpdateEvent, + request_deserializer=xrfdc__pb2.UpdateEventRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'ResetInternalFIFOWidth': grpc.unary_unary_rpc_method_handler( + servicer.ResetInternalFIFOWidth, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetConnectedIData': grpc.unary_unary_rpc_method_handler( + servicer.GetConnectedIData, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetConnectedDataResponse.SerializeToString, + ), + 'GetConnectedQData': grpc.unary_unary_rpc_method_handler( + servicer.GetConnectedQData, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetConnectedDataResponse.SerializeToString, + ), + 'GetCalibrationMode': grpc.unary_unary_rpc_method_handler( + servicer.GetCalibrationMode, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetCalibrationModeResponse.SerializeToString, + ), + 'SetCalibrationMode': grpc.unary_unary_rpc_method_handler( + servicer.SetCalibrationMode, + request_deserializer=xrfdc__pb2.SetCalibrationModeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetFabRdVldWords': grpc.unary_unary_rpc_method_handler( + servicer.GetFabRdVldWords, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetFabRdVldWordsResponse.SerializeToString, + ), + 'SetFabRdVldWords': grpc.unary_unary_rpc_method_handler( + servicer.SetFabRdVldWords, + request_deserializer=xrfdc__pb2.SetFabRdVldWordsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetFabWrVldWords': grpc.unary_unary_rpc_method_handler( + servicer.GetFabWrVldWords, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetFabWrVldWordsResponse.SerializeToString, + ), + 'SetFabWrVldWords': grpc.unary_unary_rpc_method_handler( + servicer.SetFabWrVldWords, + request_deserializer=xrfdc__pb2.SetFabWrVldWordsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetDecimationFactorObs': grpc.unary_unary_rpc_method_handler( + servicer.GetDecimationFactorObs, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDecimationFactorResponse.SerializeToString, + ), + 'SetDecimationFactorObs': grpc.unary_unary_rpc_method_handler( + servicer.SetDecimationFactorObs, + request_deserializer=xrfdc__pb2.SetDecimationFactorRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetFabRdVldWordsObs': grpc.unary_unary_rpc_method_handler( + servicer.GetFabRdVldWordsObs, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetFabRdVldWordsObsResponse.SerializeToString, + ), + 'SetFabRdVldWordsObs': grpc.unary_unary_rpc_method_handler( + servicer.SetFabRdVldWordsObs, + request_deserializer=xrfdc__pb2.SetFabRdVldWordsObsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetFabWrVldWordsObs': grpc.unary_unary_rpc_method_handler( + servicer.GetFabWrVldWordsObs, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetFabWrVldWordsObsResponse.SerializeToString, + ), + 'GetDither': grpc.unary_unary_rpc_method_handler( + servicer.GetDither, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDitherResponse.SerializeToString, + ), + 'SetDither': grpc.unary_unary_rpc_method_handler( + servicer.SetDither, + request_deserializer=xrfdc__pb2.SetDitherRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetCalFreeze': grpc.unary_unary_rpc_method_handler( + servicer.GetCalFreeze, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetCalFreezeResponse.SerializeToString, + ), + 'SetCalFreeze': grpc.unary_unary_rpc_method_handler( + servicer.SetCalFreeze, + request_deserializer=xrfdc__pb2.SetCalFreezeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetDSA': grpc.unary_unary_rpc_method_handler( + servicer.GetDSA, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDSAResponse.SerializeToString, + ), + 'SetDSA': grpc.unary_unary_rpc_method_handler( + servicer.SetDSA, + request_deserializer=xrfdc__pb2.SetDSARequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'DisableCoefficientsOverride': grpc.unary_unary_rpc_method_handler( + servicer.DisableCoefficientsOverride, + request_deserializer=xrfdc__pb2.DisableCoefficientsOverrideRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'ResetInternalFIFOWidthObs': grpc.unary_unary_rpc_method_handler( + servicer.ResetInternalFIFOWidthObs, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'SetCalCoefficients': grpc.unary_unary_rpc_method_handler( + servicer.SetCalCoefficients, + request_deserializer=xrfdc__pb2.SetCalCoefficientsRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetCalCoefficients': grpc.unary_unary_rpc_method_handler( + servicer.GetCalCoefficients, + request_deserializer=xrfdc__pb2.GetCalCoefficientsRequest.FromString, + response_serializer=xrfdc__pb2.GetCalCoefficientsResponse.SerializeToString, + ), + 'GetDecoderMode': grpc.unary_unary_rpc_method_handler( + servicer.GetDecoderMode, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDecoderModeResponse.SerializeToString, + ), + 'SetDecoderMode': grpc.unary_unary_rpc_method_handler( + servicer.SetDecoderMode, + request_deserializer=xrfdc__pb2.SetDecoderModeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetOutputCurr': grpc.unary_unary_rpc_method_handler( + servicer.GetOutputCurr, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetOutputCurrResponse.SerializeToString, + ), + 'GetInvSincFIR': grpc.unary_unary_rpc_method_handler( + servicer.GetInvSincFIR, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetInvSincFIRResponse.SerializeToString, + ), + 'SetInvSincFIR': grpc.unary_unary_rpc_method_handler( + servicer.SetInvSincFIR, + request_deserializer=xrfdc__pb2.SetInvSincFIRRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetDataPathMode': grpc.unary_unary_rpc_method_handler( + servicer.GetDataPathMode, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDataPathModeResponse.SerializeToString, + ), + 'SetDataPathMode': grpc.unary_unary_rpc_method_handler( + servicer.SetDataPathMode, + request_deserializer=xrfdc__pb2.SetDataPathModeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetIMRPassMode': grpc.unary_unary_rpc_method_handler( + servicer.GetIMRPassMode, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetIMRPassModeResponse.SerializeToString, + ), + 'SetIMRPassMode': grpc.unary_unary_rpc_method_handler( + servicer.SetIMRPassMode, + request_deserializer=xrfdc__pb2.SetIMRPassModeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetDACCompMode': grpc.unary_unary_rpc_method_handler( + servicer.GetDACCompMode, + request_deserializer=xrfdc__pb2.BlockRequest.FromString, + response_serializer=xrfdc__pb2.GetDACCompModeResponse.SerializeToString, + ), + 'SetDACCompMode': grpc.unary_unary_rpc_method_handler( + servicer.SetDACCompMode, + request_deserializer=xrfdc__pb2.SetDACCompModeRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'SetDACVOP': grpc.unary_unary_rpc_method_handler( + servicer.SetDACVOP, + request_deserializer=xrfdc__pb2.SetDACVOPRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'DumpRegs': grpc.unary_unary_rpc_method_handler( + servicer.DumpRegs, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetPLLConfig': grpc.unary_unary_rpc_method_handler( + servicer.GetPLLConfig, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.GetPLLConfigResponse.SerializeToString, + ), + 'SetupFIFOObs': grpc.unary_unary_rpc_method_handler( + servicer.SetupFIFOObs, + request_deserializer=xrfdc__pb2.SetupFIFORequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'SetupFIFOBoth': grpc.unary_unary_rpc_method_handler( + servicer.SetupFIFOBoth, + request_deserializer=xrfdc__pb2.SetupFIFORequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + 'GetFIFOStatusObs': grpc.unary_unary_rpc_method_handler( + servicer.GetFIFOStatusObs, + request_deserializer=xrfdc__pb2.TileRequest.FromString, + response_serializer=xrfdc__pb2.GetFIFOStatusResponse.SerializeToString, + ), + 'GetClkDistribution': grpc.unary_unary_rpc_method_handler( + servicer.GetClkDistribution, + request_deserializer=xrfdc__pb2.GetClkDistributionRequest.FromString, + response_serializer=xrfdc__pb2.GetClkDistributionResponse.SerializeToString, + ), + 'SetClkDistribution': grpc.unary_unary_rpc_method_handler( + servicer.SetClkDistribution, + request_deserializer=xrfdc__pb2.SetClkDistributionRequest.FromString, + response_serializer=xrfdc__pb2.TileControlResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'xrfdc.Xrfdc', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + server.add_registered_method_handlers('xrfdc.Xrfdc', rpc_method_handlers) + + + # This class is part of an EXPERIMENTAL API. +class Xrfdc(object): + """Missing associated documentation comment in .proto file.""" + + @staticmethod + def CfgInitialize(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/CfgInitialize', + xrfdc__pb2.CfgInitializeRequest.SerializeToString, + xrfdc__pb2.CfgInitializeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetIPStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetIPStatus', + xrfdc__pb2.GetIPStatusRequest.SerializeToString, + xrfdc__pb2.GetIPStatusResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetBlockStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetBlockStatus', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetBlockStatusResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFIFOStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFIFOStatus', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.GetFIFOStatusResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetPLLLockStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetPLLLockStatus', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.GetPLLLockStatusResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetClockSource(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetClockSource', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.GetClockSourceResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def StartUp(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/StartUp', + xrfdc__pb2.TileControlRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def Shutdown(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/Shutdown', + xrfdc__pb2.TileControlRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def Reset(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/Reset', + xrfdc__pb2.TileControlRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetupFIFO(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetupFIFO', + xrfdc__pb2.SetupFIFORequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DynamicPLLConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/DynamicPLLConfig', + xrfdc__pb2.DynamicPLLConfigRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetFabClkOutDiv(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetFabClkOutDiv', + xrfdc__pb2.SetFabClkOutDivRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFabClkOutDiv(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFabClkOutDiv', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.GetFabClkOutDivResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetMixerSettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetMixerSettings', + xrfdc__pb2.SetMixerSettingsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetMixerSettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetMixerSettings', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetMixerSettingsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ResetNCOPhase(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/ResetNCOPhase', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetNyquistZone(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetNyquistZone', + xrfdc__pb2.SetNyquistZoneRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetNyquistZone(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetNyquistZone', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetNyquistZoneResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetInterpolationFactor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetInterpolationFactor', + xrfdc__pb2.SetInterpolationFactorRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetInterpolationFactor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetInterpolationFactor', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetInterpolationFactorResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDecimationFactor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDecimationFactor', + xrfdc__pb2.SetDecimationFactorRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDecimationFactor(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDecimationFactor', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDecimationFactorResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetQMCSettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetQMCSettings', + xrfdc__pb2.SetQMCSettingsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetQMCSettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetQMCSettings', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetQMCSettingsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetThresholdSettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetThresholdSettings', + xrfdc__pb2.SetThresholdSettingsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetThresholdSettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetThresholdSettings', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetThresholdSettingsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetThresholdClrMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetThresholdClrMode', + xrfdc__pb2.SetThresholdClrModeRequest.SerializeToString, + xrfdc__pb2.SetThresholdClrModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ThresholdStickyClear(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/ThresholdStickyClear', + xrfdc__pb2.ThresholdStickyClearRequest.SerializeToString, + xrfdc__pb2.ThresholdStickyClearResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetCoarseDelaySettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetCoarseDelaySettings', + xrfdc__pb2.GetCoarseDelaySettingsRequest.SerializeToString, + xrfdc__pb2.GetCoarseDelaySettingsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetCoarseDelaySettings(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetCoarseDelaySettings', + xrfdc__pb2.SetCoarseDelaySettingsRequest.SerializeToString, + xrfdc__pb2.SetCoarseDelaySettingsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetEnabledInterrupts(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetEnabledInterrupts', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetEnabledInterruptsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetPwrMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetPwrMode', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetPwrModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetPwrMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetPwrMode', + xrfdc__pb2.SetPwrModeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def UpdateEvent(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/UpdateEvent', + xrfdc__pb2.UpdateEventRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ResetInternalFIFOWidth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/ResetInternalFIFOWidth', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetConnectedIData(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetConnectedIData', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetConnectedDataResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetConnectedQData(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetConnectedQData', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetConnectedDataResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetCalibrationMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetCalibrationMode', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetCalibrationModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetCalibrationMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetCalibrationMode', + xrfdc__pb2.SetCalibrationModeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFabRdVldWords(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFabRdVldWords', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetFabRdVldWordsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetFabRdVldWords(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetFabRdVldWords', + xrfdc__pb2.SetFabRdVldWordsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFabWrVldWords(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFabWrVldWords', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetFabWrVldWordsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetFabWrVldWords(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetFabWrVldWords', + xrfdc__pb2.SetFabWrVldWordsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDecimationFactorObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDecimationFactorObs', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDecimationFactorResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDecimationFactorObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDecimationFactorObs', + xrfdc__pb2.SetDecimationFactorRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFabRdVldWordsObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFabRdVldWordsObs', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetFabRdVldWordsObsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetFabRdVldWordsObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetFabRdVldWordsObs', + xrfdc__pb2.SetFabRdVldWordsObsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFabWrVldWordsObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFabWrVldWordsObs', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetFabWrVldWordsObsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDither(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDither', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDitherResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDither(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDither', + xrfdc__pb2.SetDitherRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetCalFreeze(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetCalFreeze', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetCalFreezeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetCalFreeze(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetCalFreeze', + xrfdc__pb2.SetCalFreezeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDSA(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDSA', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDSAResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDSA(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDSA', + xrfdc__pb2.SetDSARequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DisableCoefficientsOverride(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/DisableCoefficientsOverride', + xrfdc__pb2.DisableCoefficientsOverrideRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ResetInternalFIFOWidthObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/ResetInternalFIFOWidthObs', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetCalCoefficients(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetCalCoefficients', + xrfdc__pb2.SetCalCoefficientsRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetCalCoefficients(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetCalCoefficients', + xrfdc__pb2.GetCalCoefficientsRequest.SerializeToString, + xrfdc__pb2.GetCalCoefficientsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDecoderMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDecoderMode', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDecoderModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDecoderMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDecoderMode', + xrfdc__pb2.SetDecoderModeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetOutputCurr(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetOutputCurr', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetOutputCurrResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetInvSincFIR(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetInvSincFIR', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetInvSincFIRResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetInvSincFIR(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetInvSincFIR', + xrfdc__pb2.SetInvSincFIRRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDataPathMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDataPathMode', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDataPathModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDataPathMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDataPathMode', + xrfdc__pb2.SetDataPathModeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetIMRPassMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetIMRPassMode', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetIMRPassModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetIMRPassMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetIMRPassMode', + xrfdc__pb2.SetIMRPassModeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDACCompMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetDACCompMode', + xrfdc__pb2.BlockRequest.SerializeToString, + xrfdc__pb2.GetDACCompModeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDACCompMode(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDACCompMode', + xrfdc__pb2.SetDACCompModeRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetDACVOP(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetDACVOP', + xrfdc__pb2.SetDACVOPRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DumpRegs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/DumpRegs', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetPLLConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetPLLConfig', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.GetPLLConfigResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetupFIFOObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetupFIFOObs', + xrfdc__pb2.SetupFIFORequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetupFIFOBoth(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetupFIFOBoth', + xrfdc__pb2.SetupFIFORequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetFIFOStatusObs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetFIFOStatusObs', + xrfdc__pb2.TileRequest.SerializeToString, + xrfdc__pb2.GetFIFOStatusResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetClkDistribution(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/GetClkDistribution', + xrfdc__pb2.GetClkDistributionRequest.SerializeToString, + xrfdc__pb2.GetClkDistributionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetClkDistribution(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/xrfdc.Xrfdc/SetClkDistribution', + xrfdc__pb2.SetClkDistributionRequest.SerializeToString, + xrfdc__pb2.TileControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) diff --git a/sdbuild/Makefile b/sdbuild/Makefile index bc7768cb3..44b7bf1b5 100644 --- a/sdbuild/Makefile +++ b/sdbuild/Makefile @@ -5,6 +5,10 @@ ifneq (,$(filter pynqremote,$(MAKECMDGOALS))) override PYNQREMOTE = 1 endif +# Packages enabled in every PYNQ.remote (PetaLinux) rootfs. Boards add +# board-specific remote packages via REMOTE_PACKAGES_ in their .spec file. +REMOTE_PACKAGES ?= grpc pynq-cpp + DEFAULT_BOARDDIR := $(CURDIR)/../boards BOARDDIR ?= $(DEFAULT_BOARDDIR) @@ -96,6 +100,11 @@ ifeq ($$(FPGA_MANAGER_$1),) FPGA_MANAGER_$1 := 1 endif +# If the board .spec file has rfdc as a remote package we infer it's an RFSoC board +ifeq ($$(RFSoC_$1),) + RFSoC_$1 := $$(if $$(filter rfdc,$$(REMOTE_PACKAGES_$1)),1,0) +endif + # New API - SDIST and RootFS by default should be provided to the Makefile # >v2.7 can be overriden to old behavior by setting REBUILD_PYNQ_ROOTFS # and REBUILD_PYNQ_SDIST @@ -197,18 +206,24 @@ $$(PL_PROJ_$1): $$(BSP_TARGET_$1) echo 'CONFIG_opencl-clhpp-dev=y' >> $$(PL_ROOTFS_CONFIG_$1) ;\ fi - # PYNQ.remote packages + # PYNQ.remote packages: general defaults (REMOTE_PACKAGES) + board-specific + # additions (REMOTE_PACKAGES_ from the board .spec) if [ $(PYNQREMOTE) = 1 ]; then \ - echo 'CONFIG_grpc' >> $$(PL_USER_ROOTFS_CONFIG_$1) ;\ - echo 'CONFIG_pynq-cpp' >> $$(PL_USER_ROOTFS_CONFIG_$1) ;\ - echo 'CONFIG_grpc=y' >> $$(PL_ROOTFS_CONFIG_$1) ;\ - echo 'CONFIG_pynq-cpp=y' >> $$(PL_ROOTFS_CONFIG_$1) ;\ + for pkg in $(REMOTE_PACKAGES) $$(REMOTE_PACKAGES_$1); do \ + echo "CONFIG_$$$$pkg" >> $$(PL_USER_ROOTFS_CONFIG_$1) ;\ + echo "CONFIG_$$$$pkg=y" >> $$(PL_ROOTFS_CONFIG_$1) ;\ + done ;\ echo 'CONFIG_nfs-utils=n' >> $$(PL_ROOTFS_CONFIG_$1) ;\ echo 'CONFIG_tcf-agent=n' >> $$(PL_ROOTFS_CONFIG_$1) ;\ echo 'CONFIG_imagefeature-ssh-server-openssh=n' >> $$(PL_ROOTFS_CONFIG_$1) ;\ echo 'CONFIG_imagefeature-ssh-server-dropbear=y' >> $$(PL_ROOTFS_CONFIG_$1) ;\ + if [ $$(RFSoC_$1) = 1 ]; then \ + mkdir -p $$(PL_PROJ_$1)/project-spec/meta-user/recipes-apps/pynq-cpp ;\ + echo 'PACKAGECONFIG:append = " rfsoc"' \ + > $$(PL_PROJ_$1)/project-spec/meta-user/recipes-apps/pynq-cpp/pynq-cpp.bbappend ;\ + fi ;\ petalinux-config -c rootfs --silentconfig -p $$(PL_PROJ_$1) ;\ - fi + fi $$(BOOT_ROOT_$1)/BOOT.BIN : $$(BOOT_DEPENDS_$1) $$(BOOT_BITSTREAM_$1) | $$(BOOT_ROOT_$1) cd $$(BOOT_ROOT_$1) && petalinux-package --boot --fpga $$(BITSTREAM_ABS_$1) --u-boot -p $$(PL_PROJ_$1) --force diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/CMakeLists.txt b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/CMakeLists.txt index 9094522b2..259a62b6b 100644 --- a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/CMakeLists.txt +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/CMakeLists.txt @@ -5,6 +5,12 @@ project(PYNQ_Remote C CXX) include(../cmake/common.cmake) set (CMAKE_CXX_STANDARD 17) #For filesystem checks & unique_ptr +# RFSoC services (xrfdc, xrfclk) are RFSoC-board-only. The PYNQ Makefile +# sets PACKAGECONFIG to "rfsoc" via a per-project bbappend when RFSoC_=1, +# which adds -DRFSOC=ON to EXTRA_OECMAKE. +option(RFSOC "Build RFSoC services (xrfdc, xrfclk)" OFF) +message(STATUS "RFSOC = ${RFSOC}") + # Proto file get_filename_component(remote_device_proto "../protos/remote_device.proto" ABSOLUTE) get_filename_component(remote_device_proto_path "${remote_device_proto}" PATH) @@ -55,6 +61,37 @@ add_custom_command( "${gpio_proto}" DEPENDS "${remote_device_proto}" "${mmio_proto}" "${buffer_proto}" "${gpio_proto}") +# RFSoC-only proto generation +if(RFSOC) + get_filename_component(xrfclk_proto "../protos/xrfclk.proto" ABSOLUTE) + get_filename_component(xrfclk_proto_path "${xrfclk_proto}" PATH) + + get_filename_component(xrfdc_proto "../protos/xrfdc.proto" ABSOLUTE) + get_filename_component(xrfdc_proto_path "${xrfdc_proto}" PATH) + + set(xrfclk_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/xrfclk.pb.cc") + set(xrfclk_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/xrfclk.pb.h") + set(xrfclk_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/xrfclk.grpc.pb.cc") + set(xrfclk_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/xrfclk.grpc.pb.h") + + set(xrfdc_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/xrfdc.pb.cc") + set(xrfdc_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/xrfdc.pb.h") + set(xrfdc_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/xrfdc.grpc.pb.cc") + set(xrfdc_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/xrfdc.grpc.pb.h") + + add_custom_command( + OUTPUT "${xrfclk_proto_srcs}" "${xrfclk_proto_hdrs}" "${xrfclk_grpc_srcs}" "${xrfclk_grpc_hdrs}" + "${xrfdc_proto_srcs}" "${xrfdc_proto_hdrs}" "${xrfdc_grpc_srcs}" "${xrfdc_grpc_hdrs}" + COMMAND ${_PROTOBUF_PROTOC} + ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}" + --cpp_out "${CMAKE_CURRENT_BINARY_DIR}" + -I "${xrfclk_proto_path}" + --plugin=protoc-gen-grpc="${_GRPC_CPP_PLUGIN_EXECUTABLE}" + "${xrfclk_proto}" + "${xrfdc_proto}" + DEPENDS "${xrfclk_proto}" "${xrfdc_proto}") +endif() + message(STATUS "CMAKE CURRENT DIR = ${CMAKE_CURRENT_SOURCE_DIR}") # Change to whatever the Petalinux project path - will need to change this at some point @@ -69,6 +106,32 @@ get_filename_component(BASE_DIR "${BASE_DIR}" DIRECTORY) message(STATUS "BASE_DIR (Project Path) = ${BASE_DIR}") +# Build libmetal — only required by rfdc (RFSoC services) +if(RFSOC) + find_path(RFDC_INCLUDE_DIR + NAMES xrfdc.h + PATHS "${CMAKE_SYSROOT}/usr/include" "${CMAKE_SYSROOT}/include" + NO_DEFAULT_PATH) + find_path(METAL_INCLUDE_DIR + NAMES metal/io.h + PATHS "${CMAKE_SYSROOT}/usr/include" "${CMAKE_SYSROOT}/include" + NO_DEFAULT_PATH) + find_library(METAL_LIBRARY + NAMES metal + PATHS "${CMAKE_SYSROOT}/usr/lib" "${CMAKE_SYSROOT}/lib" + NO_DEFAULT_PATH) + + if(NOT RFDC_INCLUDE_DIR) + message(FATAL_ERROR "Could not find xrfdc.h in the Yocto sysroot. Enable the rfdc recipe for RFSoC builds.") + endif() + if(NOT METAL_INCLUDE_DIR OR NOT METAL_LIBRARY) + message(FATAL_ERROR "Could not find libmetal headers/library in the Yocto sysroot. Enable the libmetal recipe for RFSoC builds.") + endif() + + message(STATUS "Found rfdc include dir: ${RFDC_INCLUDE_DIR}") + message(STATUS "Found libmetal: ${METAL_LIBRARY}") +endif() + # Define an option for using custom XRT paths option(USE_LOCAL_XRT "Use custom XRT include and library paths" OFF) @@ -130,17 +193,67 @@ add_library(gpio_grpc_proto ${gpio_proto_srcs} ${gpio_proto_hdrs}) +# RFSoC-only proto libraries, source list, and link/deps lists. +# These variables are empty on non-RFSoC boards so the splat below produces +# vanilla MMIO/GPIO/Buffer-only build. +set(RFSOC_SOURCES "") +set(RFSOC_DEPS "") +set(RFSOC_LINKS "") +set(RFSOC_INCLUDE_DIRS "") +set(RFSOC_SYSTEM_LINKS "") +if(RFSOC) + add_compile_definitions(RFSOC) + + add_library(xrfclk_grpc_proto + ${xrfclk_grpc_srcs} + ${xrfclk_grpc_hdrs} + ${xrfclk_proto_srcs} + ${xrfclk_proto_hdrs}) + + add_library(xrfdc_grpc_proto + ${xrfdc_grpc_srcs} + ${xrfdc_grpc_hdrs} + ${xrfdc_proto_srcs} + ${xrfdc_proto_hdrs}) + + list(APPEND RFSOC_SOURCES xrfclk.cc xrfdc.cc) + list(APPEND RFSOC_DEPS xrfclk_grpc_proto xrfdc_grpc_proto) + list(APPEND RFSOC_LINKS xrfclk_grpc_proto xrfdc_grpc_proto) + list(APPEND RFSOC_INCLUDE_DIRS ${RFDC_INCLUDE_DIR} ${METAL_INCLUDE_DIR}) + list(APPEND RFSOC_SYSTEM_LINKS ${METAL_LIBRARY} ${CMAKE_DL_LIBS}) +endif() + +# Main pynq library add_library(pynq buffer.cc mmio.cc device.cc gpio.cc + ${RFSOC_SOURCES} ) +# Ensure proto headers are generated before compiling pynq sources +add_dependencies(pynq + buffer_grpc_proto + mmio_grpc_proto + remote_device_grpc_proto + gpio_grpc_proto + ${RFSOC_DEPS} +) + +target_link_libraries(pynq + ${XRT_LIBRARIES} + ${XRT_ADDITIONAL_LIBRARIES} + ${RFSOC_SYSTEM_LINKS}) + +target_include_directories(pynq PRIVATE + ${RFSOC_INCLUDE_DIRS}) + target_link_libraries(remote_device_grpc_proto mmio_grpc_proto buffer_grpc_proto gpio_grpc_proto + ${RFSOC_LINKS} ${_REFLECTION} ${_GRPC_GRPCPP} ${_PROTOBUF_LIBPROTOBUF}) @@ -155,6 +268,7 @@ foreach(_target mmio_grpc_proto buffer_grpc_proto gpio_grpc_proto + ${RFSOC_LINKS} ${_REFLECTION} ${_GRPC_GRPCPP} ${_PROTOBUF_LIBPROTOBUF} diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/pynq-remote.cc b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/pynq-remote.cc index 6b1a2d8fb..1d2e8e1c8 100644 --- a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/pynq-remote.cc +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/pynq-remote.cc @@ -26,11 +26,19 @@ #include #include #include +#ifdef RFSOC +#include +#include +#endif #include "buffer.cc" #include "mmio.h" #include "device.h" #include "gpio.h" +#ifdef RFSOC +#include "xrfclk.h" +#include "xrfdc.h" +#endif #include #include @@ -98,6 +106,32 @@ using gpio::GetGpioBasePathResponse; using gpio::GetGpioNPinsRequest; using gpio::GetGpioNPinsResponse; using gpio::Gpio; +#ifdef RFSOC +using xrfclk::FindDevicesRequest; +using xrfclk::FindDevicesResponse; +using xrfclk::WriteLmkRegsRequest; +using xrfclk::WriteLmkRegsResponse; +using xrfclk::WriteLmxRegsRequest; +using xrfclk::WriteLmxRegsResponse; +using xrfclk::Xrfclk; +using xrfdc::CfgInitializeRequest; +using xrfdc::CfgInitializeResponse; +using xrfdc::GetIPStatusRequest; +using xrfdc::GetIPStatusResponse; +using xrfdc::TileControlRequest; +using xrfdc::TileControlResponse; +using xrfdc::SetupFIFORequest; +using xrfdc::DynamicPLLConfigRequest; +using xrfdc::GetFabRdVldWordsResponse; +using xrfdc::GetFabWrVldWordsResponse; +using xrfdc::GetDitherResponse; +using xrfdc::GetDecoderModeResponse; +using xrfdc::GetOutputCurrResponse; +using xrfdc::GetInvSincFIRResponse; +using xrfdc::GetDataPathModeResponse; +using xrfdc::GetIMRPassModeResponse; +using xrfdc::GetDACCompModeResponse; +#endif #define DEBUG @@ -863,6 +897,10 @@ class RemoteDeviceImpl final : public RemoteDevice::Service private: const std::string FIRMWARE = "/lib/firmware/"; ///< Directory for bitstream files Device remote_device_; +#ifdef RFSOC + XrfdcImpl* xrfdc_service_ = nullptr; ///< Notified on bitstream download so it can drop its stale RFDC mapping. + XrfclkImpl* xrfclk_service_ = nullptr; ///< Notified on bitstream download so it can drop its cached clock-device state. +#endif public: std::string device_name = ""; @@ -879,6 +917,19 @@ class RemoteDeviceImpl final : public RemoteDevice::Service } } +#ifdef RFSOC + /** + * @brief Register the xrfdc/xrfclk service impls so download() can invalidate + * their cached state after the PL is reprogrammed. Both pointers are non-owning; + * the services outlive this object (they live in RunServer's stack frame). + */ + void set_rfsoc_services(XrfdcImpl* xrfdc, XrfclkImpl* xrfclk) + { + xrfdc_service_ = xrfdc; + xrfclk_service_ = xrfclk; + } +#endif + /** * @brief Handles the SetBitstreamAttrs gRPC request. * Sets attributes for the bitstream file based on the request parameters. @@ -914,6 +965,19 @@ class RemoteDeviceImpl final : public RemoteDevice::Service file.close(); remote_device_.download(remote_device_.get_bitstream_attrs().first); +#ifdef RFSOC + // The PL has been reprogrammed, so any cached RFDC/clock state on the + // server now points at the old overlay. Tell the dependent services to + // drop it; the client is expected to re-run xrfdc.CfgInitialize and + // xrfclk programming against the new bitstream. + if (xrfdc_service_) { + xrfdc_service_->invalidate(); + } + if (xrfclk_service_) { + xrfclk_service_->invalidate(); + } +#endif + return grpc::Status::OK; } /** @@ -1018,6 +1082,11 @@ void RunServer(uint16_t port) MMIOImpl mmio_service; // Create MMIO rpc handler BufferImpl buffer_service; // Create Buffer rpc handler GPIOImpl gpio_service; // Create Gpio rpc handler +#ifdef RFSOC + XrfclkImpl xrfclk_service; // Create Xrfclk rpc handler + XrfdcImpl xrfdc_service; // Create Xrfdc rpc handler + remote_device_service.set_rfsoc_services(&xrfdc_service, &xrfclk_service); +#endif remote_device_service.device_name = buffer_service.device_name; grpc::EnableDefaultHealthCheckService(true); @@ -1028,6 +1097,10 @@ void RunServer(uint16_t port) builder.RegisterService(&mmio_service); builder.RegisterService(&buffer_service); builder.RegisterService(&gpio_service); +#ifdef RFSOC + builder.RegisterService(&xrfclk_service); + builder.RegisterService(&xrfdc_service); +#endif std::unique_ptr server(builder.BuildAndStart()); std::cout << "Server listening on " << server_address << std::endl; diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.cc b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.cc new file mode 100644 index 000000000..53dcc2c51 --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.cc @@ -0,0 +1,622 @@ +#include "xrfclk.h" +#include +#include +#include +#include +#include +#include +#include + +#ifdef DEBUG +#include +#endif + +namespace fs = std::filesystem; + +// Constructor +XRFCLK::XRFCLK() : devices_initialized_(false), tics_dir_("/usr/share/xrfclk") { + // Discover devices on construction + findDevices(); +} + +// Destructor +XRFCLK::~XRFCLK() { + // No cleanup needed - RAII handles all resource management +} + +// Helper function: Read file content as string +std::string XRFCLK::readFile(const fs::path& filepath) { + std::ifstream file(filepath); + if (!file) { + throw std::runtime_error("Failed to open file: " + filepath.string()); + } + + std::string content; + std::getline(file, content, '\0'); // Read until null terminator + return content; +} + +// Helper function: Read binary file +std::vector XRFCLK::readBinaryFile(const fs::path& filepath) { + std::ifstream file(filepath, std::ios::binary); + if (!file) { + throw std::runtime_error("Failed to open file: " + filepath.string()); + } + + return std::vector( + (std::istreambuf_iterator(file)), + std::istreambuf_iterator() + ); +} + +// Helper function: Get SPI device path +std::string XRFCLK::getSpidevPath(const fs::path& dev) { + fs::path spidev_dir = dev / "spidev"; + + if (!fs::exists(spidev_dir)) { + throw std::runtime_error("spidev directory not found for device: " + dev.string()); + } + + // Get first entry in spidev directory + for (const auto& entry : fs::directory_iterator(spidev_dir)) { + return "/dev/" + entry.path().filename().string(); + } + + throw std::runtime_error("No spidev entry found in: " + spidev_dir.string()); +} + +// Helper function: Bind SPI device to spidev driver +void XRFCLK::spidevBind(const fs::path& dev) { + std::string dev_name = dev.filename().string(); + + // Write 'spidev' to driver_override + fs::path driver_override = dev / "driver_override"; + std::ofstream override_file(driver_override); + if (!override_file) { + throw std::runtime_error("Failed to open driver_override: " + driver_override.string()); + } + override_file << "spidev"; + override_file.close(); + + // Bind to spidev driver + fs::path bind_path = "/sys/bus/spi/drivers/spidev/bind"; + std::ofstream bind_file(bind_path); + if (!bind_file) { + throw std::runtime_error("Failed to open bind file: " + bind_path.string()); + } + bind_file << dev_name; + bind_file.close(); +} + +// Main device discovery function +void XRFCLK::findDevices() { + if (devices_initialized_) { + return; + } + + lmk_devices_.clear(); + lmx_devices_.clear(); + + fs::path spi_devices_path = "/sys/bus/spi/devices"; + + if (!fs::exists(spi_devices_path)) { + throw std::runtime_error("SPI devices path not found: " + spi_devices_path.string()); + } + + // Loop through each SPI device + for (const auto& dev_entry : fs::directory_iterator(spi_devices_path)) { + fs::path dev = dev_entry.path(); + fs::path compatible_path = dev / "of_node" / "compatible"; + + // Skip if compatible file doesn't exist + if (!fs::exists(compatible_path)) { + continue; + } + + // Read compatible string (e.g., "ti,lmx2594") + std::string compatible_full = readFile(compatible_path); + + // Strip company name (first 3 chars + comma) to get chip name + // e.g., "ti,lmx2594" -> "lmx2594" + if (compatible_full.length() < 4) { + continue; + } + std::string compatible = compatible_full.substr(3); + + // Remove trailing null/newline characters + compatible.erase(std::remove(compatible.begin(), compatible.end(), '\0'), compatible.end()); + compatible.erase(std::remove(compatible.begin(), compatible.end(), '\n'), compatible.end()); + + // Check if it's LMK or LMX device + if (compatible.substr(0, 3) != "lmk" && compatible.substr(0, 3) != "lmx") { + continue; + } + +#ifdef DEBUG + std::cout << "Found device: " << compatible << " at " << dev.string() << std::endl; +#endif + + // Unbind from current driver if necessary + fs::path driver_path = dev / "driver"; + if (fs::exists(driver_path)) { + fs::path unbind_path = driver_path / "unbind"; + std::ofstream unbind_file(unbind_path); + if (unbind_file) { + unbind_file << dev.filename().string(); + unbind_file.close(); + } + } + + // Bind to spidev driver + spidevBind(dev); + + // Add to appropriate device list + if (compatible.substr(0, 3) == "lmk") { + LmkDevice lmk_dev; + lmk_dev.spi_device = getSpidevPath(dev); + lmk_dev.compatible = compatible; + + // Read num_bytes from device tree + fs::path num_bytes_path = dev / "of_node" / "num_bytes"; + if (!fs::exists(num_bytes_path)) { + throw std::runtime_error("Device tree property 'num_bytes' not found for LMK device: " + + compatible + " at " + dev.string() + + ". Check BSP configuration."); + } + + std::vector num_bytes_data = readBinaryFile(num_bytes_path); + if (num_bytes_data.size() < 4) { + throw std::runtime_error("Device tree property 'num_bytes' is corrupted (size=" + + std::to_string(num_bytes_data.size()) + + ") for LMK device: " + compatible + + ". Expected 4 bytes."); + } + + // Unpack as big-endian uint32 + lmk_dev.num_bytes = (static_cast(num_bytes_data[0]) << 24) | + (static_cast(num_bytes_data[1]) << 16) | + (static_cast(num_bytes_data[2]) << 8) | + static_cast(num_bytes_data[3]); + + // Validate the value is sensible (3 or 4) + if (lmk_dev.num_bytes != 3 && lmk_dev.num_bytes != 4) { + throw std::runtime_error("Invalid num_bytes value (" + + std::to_string(lmk_dev.num_bytes) + + ") for LMK device: " + compatible + + ". Expected 3 or 4."); + } + +#ifdef DEBUG + std::cout << "LMK device: " << lmk_dev.spi_device + << ", compatible: " << lmk_dev.compatible + << ", num_bytes: " << lmk_dev.num_bytes << std::endl; +#endif + + lmk_devices_.push_back(lmk_dev); + + } else { // lmx + LmxDevice lmx_dev; + lmx_dev.spi_device = getSpidevPath(dev); + lmx_dev.compatible = compatible; + +#ifdef DEBUG + std::cout << "LMX device: " << lmx_dev.spi_device + << ", compatible: " << lmx_dev.compatible << std::endl; +#endif + + lmx_devices_.push_back(lmx_dev); + } + } + + // Validate that devices were found + if (lmk_devices_.empty()) { + throw std::runtime_error("SPI path not set. LMK not found on device tree. Issue with BSP."); + } + if (lmx_devices_.empty()) { + throw std::runtime_error("SPI path not set. LMX not found on device tree. Issue with BSP."); + } + + devices_initialized_ = true; +} + +// Get device names for client validation +std::pair XRFCLK::getDeviceNames() { + if (!devices_initialized_) { + findDevices(); + } + + // Return first LMK and LMX device names (assuming all LMX devices are same type) + std::string lmk_name = lmk_devices_.empty() ? "" : lmk_devices_[0].compatible; + std::string lmx_name = lmx_devices_.empty() ? "" : lmx_devices_[0].compatible; + + return std::make_pair(lmk_name, lmx_name); +} + +void XRFCLK::writeLmkRegs(const std::vector& reg_vals) { + if (!devices_initialized_) { + findDevices(); + } + + if (lmk_devices_.empty()) { + throw std::runtime_error("No LMK devices found"); + } + + // Use the first LMK device (assuming single device) + const LmkDevice& lmk = lmk_devices_[0]; + +#ifdef DEBUG + std::cout << "Writing " << reg_vals.size() << " registers to LMK device: " + << lmk.spi_device << " with " << lmk.num_bytes << " bytes per register" << std::endl; + std::cout << "First 5 register values: "; + for (size_t i = 0; i < std::min(size_t(5), reg_vals.size()); i++) { + std::cout << "0x" << std::hex << reg_vals[i] << std::dec << " "; + } + std::cout << std::endl; +#endif + + // Open SPI device using file descriptor (unbuffered, like Python's buffering=0) + int fd = open(lmk.spi_device.c_str(), O_WRONLY); + if (fd < 0) { + throw std::runtime_error("Failed to open SPI device: " + lmk.spi_device + + " (error: " + std::string(strerror(errno)) + ")"); + } + + // Write each register value + for (uint32_t val : reg_vals) { + // Pack as big-endian 32-bit value (matches Python's struct.pack('>I', v)) + uint8_t data[4]; + data[0] = (val >> 24) & 0xFF; + data[1] = (val >> 16) & 0xFF; + data[2] = (val >> 8) & 0xFF; + data[3] = val & 0xFF; + + // Write appropriate number of bytes based on device tree + ssize_t bytes_written; + if (lmk.num_bytes == 3) { + // Write last 3 bytes (matches Python's data[1:]) + bytes_written = write(fd, &data[1], 3); + if (bytes_written != 3) { + close(fd); + throw std::runtime_error("Failed to write to SPI device (expected 3 bytes, wrote " + + std::to_string(bytes_written) + ")"); + } + } else { + // Write all 4 bytes + bytes_written = write(fd, data, 4); + if (bytes_written != 4) { + close(fd); + throw std::runtime_error("Failed to write to SPI device (expected 4 bytes, wrote " + + std::to_string(bytes_written) + ")"); + } + } + } + + close(fd); + +#ifdef DEBUG + std::cout << "Successfully wrote LMK registers" << std::endl; +#endif +} + +// Write LMX registers +void XRFCLK::writeLmxRegs(const std::vector& reg_vals) { + if (!devices_initialized_) { + findDevices(); + } + + if (lmx_devices_.empty()) { + throw std::runtime_error("No LMX devices found"); + } + + // Write to all LMX devices (typically ADC and DAC clocks) + for (const LmxDevice& lmx : lmx_devices_) { + +#ifdef DEBUG + std::cout << "Writing " << reg_vals.size() << " registers to LMX device: " + << lmx.spi_device << std::endl; + std::cout << "First 5 register values: "; + for (size_t i = 0; i < std::min(size_t(5), reg_vals.size()); i++) { + std::cout << "0x" << std::hex << reg_vals[i] << std::dec << " "; + } + std::cout << std::endl; +#endif + + // Open SPI device using file descriptor (unbuffered, like Python's buffering=0) + int fd = open(lmx.spi_device.c_str(), O_WRONLY); + if (fd < 0) { + throw std::runtime_error("Failed to open SPI device: " + lmx.spi_device + + " (error: " + std::string(strerror(errno)) + ")"); + } + + // Program RESET = 1 to reset registers (matches Python's reset = struct.pack('>I', 0x020000)) + uint8_t reset[3] = {0x02, 0x00, 0x00}; + if (write(fd, reset, 3) != 3) { + close(fd); + throw std::runtime_error("Failed to write reset command"); + } + + // Program RESET = 0 to remove reset (matches Python's remove_reset = struct.pack('>I', 0)) + uint8_t remove_reset[3] = {0x00, 0x00, 0x00}; + if (write(fd, remove_reset, 3) != 3) { + close(fd); + throw std::runtime_error("Failed to write reset removal command"); + } + + // Write each register value (skip first byte, write last 3 bytes) + for (uint32_t val : reg_vals) { + // Pack as big-endian 32-bit value (matches Python's struct.pack('>I', v)) + uint8_t data[4]; + data[0] = (val >> 24) & 0xFF; + data[1] = (val >> 16) & 0xFF; + data[2] = (val >> 8) & 0xFF; + data[3] = val & 0xFF; + + // Write last 3 bytes (matches Python's data[1:]) + if (write(fd, &data[1], 3) != 3) { + close(fd); + throw std::runtime_error("Failed to write register to SPI device"); + } + } + + // Program register R0 one additional time with FCAL_EN = 1 + // R0 is at index 112 (last element in 113-element array) + if (reg_vals.size() > 112) { + uint32_t r0_val = reg_vals[112]; + uint8_t stable[4]; + stable[0] = (r0_val >> 24) & 0xFF; + stable[1] = (r0_val >> 16) & 0xFF; + stable[2] = (r0_val >> 8) & 0xFF; + stable[3] = r0_val & 0xFF; + + // Write last 3 bytes (matches Python's stable[1:]) + if (write(fd, &stable[1], 3) != 3) { + close(fd); + throw std::runtime_error("Failed to write final R0 register"); + } + } + + close(fd); + +#ifdef DEBUG + std::cout << "Successfully wrote LMX registers to " << lmx.spi_device << std::endl; +#endif + } +} + +// Find /_.txt whose chip matches `compatible` +// (case-insensitive) and whose frequency equals `freq`. Returns "" if none. +std::string XRFCLK::findTicsFile(const std::string& compatible, double freq) { + if (!fs::exists(tics_dir_) || !fs::is_directory(tics_dir_)) { + return ""; + } + + for (const auto& entry : fs::directory_iterator(tics_dir_)) { + if (!entry.is_regular_file()) { + continue; + } + + std::string fname = entry.path().filename().string(); + // Expect CHIP_FREQ.txt (e.g. LMK04828_245.76.txt) + if (fname.size() < 5 || fname.substr(fname.size() - 4) != ".txt") { + continue; + } + std::string stem = fname.substr(0, fname.size() - 4); // CHIP_FREQ + + std::size_t us = stem.find('_'); + if (us == std::string::npos) { + continue; + } + std::string chip = stem.substr(0, us); + std::string freq_str = stem.substr(us + 1); + + // Compare chip case-insensitively against the device compatible (lowercase). + std::transform(chip.begin(), chip.end(), chip.begin(), + [](unsigned char c) { return std::tolower(c); }); + if (chip != compatible) { + continue; + } + + double file_freq; + try { + file_freq = std::stod(freq_str); + } catch (...) { + continue; + } + if (std::fabs(file_freq - freq) < 1e-6) { + return entry.path().string(); + } + } + + return ""; +} + +// Parse hex register values from a TICS file: the first 0x... token on each line +// (matches the host-side parser). +std::vector XRFCLK::parseRegFile(const fs::path& filepath) { + std::ifstream file(filepath); + if (!file) { + throw std::runtime_error("Failed to open TICS file: " + filepath.string()); + } + + std::vector regs; + std::string line; + while (std::getline(file, line)) { + std::size_t pos = line.find("0x"); + if (pos == std::string::npos) { + pos = line.find("0X"); + } + if (pos == std::string::npos) { + continue; + } + try { + regs.push_back(static_cast(std::stoul(line.substr(pos), nullptr, 16))); + } catch (...) { + continue; + } + } + + if (regs.empty()) { + throw std::runtime_error("No register values found in TICS file: " + filepath.string()); + } + return regs; +} + +void XRFCLK::programLmk(double freq) { + if (!devices_initialized_) { + findDevices(); + } + if (lmk_devices_.empty()) { + throw std::runtime_error("No LMK devices found"); + } + + const std::string& compatible = lmk_devices_[0].compatible; + std::string path = findTicsFile(compatible, freq); + if (path.empty()) { + throw TicsNotFound("No on-target TICS file for " + compatible + " at " + + std::to_string(freq) + " MHz in " + tics_dir_); + } + + writeLmkRegs(parseRegFile(path)); +} + +void XRFCLK::programLmx(double freq) { + if (!devices_initialized_) { + findDevices(); + } + if (lmx_devices_.empty()) { + throw std::runtime_error("No LMX devices found"); + } + + const std::string& compatible = lmx_devices_[0].compatible; + std::string path = findTicsFile(compatible, freq); + if (path.empty()) { + throw TicsNotFound("No on-target TICS file for " + compatible + " at " + + std::to_string(freq) + " MHz in " + tics_dir_); + } + + writeLmxRegs(parseRegFile(path)); +} + +void XRFCLK::reset() { + lmk_devices_.clear(); + lmx_devices_.clear(); + devices_initialized_ = false; +} + +void XrfclkImpl::invalidate() { + std::lock_guard lk(mu_); + xrfclk_instance_.reset(); +} + +grpc::Status XrfclkImpl::find_devices(grpc::ServerContext *context, const xrfclk::FindDevicesRequest *request, xrfclk::FindDevicesResponse *response) +{ + std::lock_guard lk(mu_); + #ifdef DEBUG + std::cout << "Function: find_devices" << std::endl; + #endif + + try { + auto device_names = xrfclk_instance_.getDeviceNames(); + response->set_lmk_device(device_names.first); + response->set_lmx_device(device_names.second); + + #ifdef DEBUG + std::cout << "Found LMK device: " << device_names.first << std::endl; + std::cout << "Found LMX device: " << device_names.second << std::endl; + #endif + } + catch (const std::exception &e) { + std::cerr << "Error finding devices: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + + return grpc::Status::OK; +} + +grpc::Status XrfclkImpl::write_lmk_regs(grpc::ServerContext *context, const xrfclk::WriteLmkRegsRequest *request, xrfclk::WriteLmkRegsResponse *response) +{ + std::lock_guard lk(mu_); + #ifdef DEBUG + std::cout << "Function: write_lmk_regs, " + << "num_regs=" << request->reg_vals_size() + << std::endl; + #endif + + try { + std::vector reg_vals(request->reg_vals().begin(), request->reg_vals().end()); + + xrfclk_instance_.writeLmkRegs(reg_vals); + } + catch (const std::exception &e) { + std::cerr << "Error writing LMK registers: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + + return grpc::Status::OK; +} + +grpc::Status XrfclkImpl::write_lmx_regs(grpc::ServerContext *context, const xrfclk::WriteLmxRegsRequest *request, xrfclk::WriteLmxRegsResponse *response) +{ + std::lock_guard lk(mu_); + #ifdef DEBUG + std::cout << "Function: write_lmx_regs, " + << "num_regs=" << request->reg_vals_size() + << std::endl; + #endif + + try { + std::vector reg_vals(request->reg_vals().begin(), request->reg_vals().end()); + + xrfclk_instance_.writeLmxRegs(reg_vals); + } + catch (const std::exception &e) { + std::cerr << "Error writing LMX registers: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + + return grpc::Status::OK; +} + +grpc::Status XrfclkImpl::program_lmk(grpc::ServerContext *context, const xrfclk::ProgramLmkRequest *request, xrfclk::ProgramLmkResponse *response) +{ + std::lock_guard lk(mu_); + #ifdef DEBUG + std::cout << "Function: program_lmk, freq=" << request->freq() << std::endl; + #endif + + try { + xrfclk_instance_.programLmk(request->freq()); + } + catch (const TicsNotFound &e) { + std::cerr << "LMK TICS not found: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::NOT_FOUND, e.what()); + } + catch (const std::exception &e) { + std::cerr << "Error programming LMK: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + + return grpc::Status::OK; +} + +grpc::Status XrfclkImpl::program_lmx(grpc::ServerContext *context, const xrfclk::ProgramLmxRequest *request, xrfclk::ProgramLmxResponse *response) +{ + std::lock_guard lk(mu_); + #ifdef DEBUG + std::cout << "Function: program_lmx, freq=" << request->freq() << std::endl; + #endif + + try { + xrfclk_instance_.programLmx(request->freq()); + } + catch (const TicsNotFound &e) { + std::cerr << "LMX TICS not found: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::NOT_FOUND, e.what()); + } + catch (const std::exception &e) { + std::cerr << "Error programming LMX: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + + return grpc::Status::OK; +} \ No newline at end of file diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.h b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.h new file mode 100644 index 000000000..639f2183b --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfclk.h @@ -0,0 +1,116 @@ +#ifndef XRFCLK_H +#define XRFCLK_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Raised when no on-target TICS file matches the requested chip/frequency, so the +// service can map it to a gRPC NOT_FOUND (the host then reports "frequency not valid"). +class TicsNotFound : public std::runtime_error { +public: + explicit TicsNotFound(const std::string& msg) : std::runtime_error(msg) {} +}; + +class XRFCLK +{ +private: + // Device structures + struct LmkDevice { + std::string spi_device; + std::string compatible; + uint32_t num_bytes; + }; + + struct LmxDevice { + std::string spi_device; + std::string compatible; + }; + + // Member variables + std::vector lmk_devices_; + std::vector lmx_devices_; + bool devices_initialized_; + std::string tics_dir_; + + // Private helper methods + std::string getSpidevPath(const std::filesystem::path& dev); + void spidevBind(const std::filesystem::path& dev); + std::string readFile(const std::filesystem::path& filepath); + std::vector readBinaryFile(const std::filesystem::path& filepath); + void findDevices(); + + // On-target TICS lookup/parse: find /_.txt for the given + // device compatible (case-insensitive) and frequency, and parse its hex registers. + std::string findTicsFile(const std::string& compatible, double freq); + std::vector parseRegFile(const std::filesystem::path& filepath); + +public: + XRFCLK(); + ~XRFCLK(); + + // Get device names for client validation + std::pair getDeviceNames(); + + void writeLmkRegs(const std::vector& reg_vals); + void writeLmxRegs(const std::vector& reg_vals); + + // Program from the on-target TICS files by frequency (throws TicsNotFound if absent). + void programLmk(double freq); + void programLmx(double freq); + + /** + * @brief Drop the cached device-discovery state. + * + * Clears the LMK/LMX device tables and the devices_initialized_ flag so + * the next call re-walks /sys/bus/spi/devices. The class does not hold + * any persistent file descriptors (each writeLm*Regs() opens and closes + * the spidev fd within one call), so no fds need closing here. + */ + void reset(); +}; + +class XrfclkImpl final : public xrfclk::Xrfclk::Service +{ +private: + XRFCLK xrfclk_instance_; + std::mutex mu_; + +public: + XrfclkImpl() : xrfclk_instance_() { + #ifdef DEBUG + std::cout << "XrfclkImpl initialized - devices discovered" << std::endl; + #endif + } + + /** + * @brief Invalidate the cached clock-device state after a bitstream reload. + * + * The PL itself does not own the LMK/LMX SPI devices, but downstream + * users typically reprogram the clocks after every overlay swap; resetting + * the cache forces the next call to re-discover the spidev nodes (and + * re-bind drivers if userspace tore them down between downloads). + */ + void invalidate(); + + grpc::Status find_devices(grpc::ServerContext *context, const xrfclk::FindDevicesRequest *request, xrfclk::FindDevicesResponse *response) override; + grpc::Status write_lmk_regs(grpc::ServerContext *context, const xrfclk::WriteLmkRegsRequest *request, xrfclk::WriteLmkRegsResponse *response) override; + grpc::Status write_lmx_regs(grpc::ServerContext *context, const xrfclk::WriteLmxRegsRequest *request, xrfclk::WriteLmxRegsResponse *response) override; + grpc::Status program_lmk(grpc::ServerContext *context, const xrfclk::ProgramLmkRequest *request, xrfclk::ProgramLmkResponse *response) override; + grpc::Status program_lmx(grpc::ServerContext *context, const xrfclk::ProgramLmxRequest *request, xrfclk::ProgramLmxResponse *response) override; +}; + +#endif // XRFCLK_H \ No newline at end of file diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.cc b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.cc new file mode 100644 index 000000000..70719b614 --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.cc @@ -0,0 +1,4469 @@ +#include "xrfdc.h" + +// ============================================================================ +// libxrfdcManager Implementation +// ============================================================================ + +libxrfdcManager::libxrfdcManager() : handle_(nullptr) { + XRFdc_LookupConfig = nullptr; + XRFdc_CfgInitialize = nullptr; + XRFdc_GetIPStatus = nullptr; + XRFdc_GetBlockStatus = nullptr; + XRFdc_StartUp = nullptr; + XRFdc_Shutdown = nullptr; + XRFdc_Reset = nullptr; + XRFdc_SetupFIFO = nullptr; + XRFdc_DynamicPLLConfig = nullptr; + XRFdc_GetFIFOStatus = nullptr; + XRFdc_GetPLLLockStatus = nullptr; + XRFdc_GetClockSource = nullptr; + XRFdc_SetFabClkOutDiv = nullptr; + XRFdc_GetFabClkOutDiv = nullptr; + XRFdc_SetMixerSettings = nullptr; + XRFdc_GetMixerSettings = nullptr; + XRFdc_ResetNCOPhase = nullptr; + XRFdc_SetNyquistZone = nullptr; + XRFdc_GetNyquistZone = nullptr; + XRFdc_SetInterpolationFactor = nullptr; + XRFdc_GetInterpolationFactor = nullptr; + XRFdc_SetDecimationFactor = nullptr; + XRFdc_GetDecimationFactor = nullptr; + XRFdc_SetQMCSettings = nullptr; + XRFdc_GetQMCSettings = nullptr; + XRFdc_SetThresholdSettings = nullptr; + XRFdc_GetThresholdSettings = nullptr; + + // Initialize additional function pointers + XRFdc_SetThresholdClrMode = nullptr; + XRFdc_ThresholdStickyClear = nullptr; + XRFdc_GetCoarseDelaySettings = nullptr; + XRFdc_SetCoarseDelaySettings = nullptr; + XRFdc_GetEnabledInterrupts = nullptr; + XRFdc_GetPwrMode = nullptr; + XRFdc_SetPwrMode = nullptr; + XRFdc_UpdateEvent = nullptr; + XRFdc_ResetInternalFIFOWidth = nullptr; + XRFdc_GetConnectedIData = nullptr; + XRFdc_GetConnectedQData = nullptr; + XRFdc_GetCalibrationMode = nullptr; + XRFdc_SetCalibrationMode = nullptr; + XRFdc_GetFabRdVldWords = nullptr; + XRFdc_SetFabRdVldWords = nullptr; + XRFdc_GetFabWrVldWords = nullptr; + XRFdc_SetFabWrVldWords = nullptr; + XRFdc_GetDecimationFactorObs = nullptr; + XRFdc_SetDecimationFactorObs = nullptr; + XRFdc_GetFabRdVldWordsObs = nullptr; + XRFdc_SetFabRdVldWordsObs = nullptr; + XRFdc_GetFabWrVldWordsObs = nullptr; + XRFdc_GetDither = nullptr; + XRFdc_SetDither = nullptr; + XRFdc_GetCalFreeze = nullptr; + XRFdc_SetCalFreeze = nullptr; + XRFdc_GetDSA = nullptr; + XRFdc_SetDSA = nullptr; + XRFdc_DisableCoefficientsOverride = nullptr; + XRFdc_ResetInternalFIFOWidthObs = nullptr; + XRFdc_SetCalCoefficients = nullptr; + XRFdc_GetCalCoefficients = nullptr; + XRFdc_GetDecoderMode = nullptr; + XRFdc_SetDecoderMode = nullptr; + XRFdc_GetOutputCurr = nullptr; + XRFdc_GetInvSincFIR = nullptr; + XRFdc_SetInvSincFIR = nullptr; + XRFdc_GetDataPathMode = nullptr; + XRFdc_SetDataPathMode = nullptr; + XRFdc_GetIMRPassMode = nullptr; + XRFdc_SetIMRPassMode = nullptr; + XRFdc_GetDACCompMode = nullptr; + XRFdc_SetDACCompMode = nullptr; + XRFdc_SetDACVOP = nullptr; + XRFdc_DumpRegs = nullptr; + XRFdc_GetPLLConfig = nullptr; + XRFdc_SetupFIFOObs = nullptr; + XRFdc_SetupFIFOBoth = nullptr; + XRFdc_GetFIFOStatusObs = nullptr; + XRFdc_GetClkDistribution = nullptr; + XRFdc_SetClkDistribution = nullptr; +} + +libxrfdcManager::~libxrfdcManager() { + unloadLibrary(); +} + +void libxrfdcManager::loadLibrary() { +#ifdef DEBUG + std::cout << "Loading librfdc.so..." << std::endl; +#endif + + handle_ = dlopen("librfdc.so.3", RTLD_LAZY); + if (!handle_) { + handle_ = dlopen("librfdc.so", RTLD_LAZY); + if (!handle_) { + throw std::runtime_error(std::string("Failed to load librfdc.so: ") + dlerror()); + } + } + + // Load function pointers + XRFdc_LookupConfig = (XRFdc_LookupConfig_t)dlsym(handle_, "XRFdc_LookupConfig"); + XRFdc_CfgInitialize = (XRFdc_CfgInitialize_t)dlsym(handle_, "XRFdc_CfgInitialize"); + XRFdc_GetIPStatus = (XRFdc_GetIPStatus_t)dlsym(handle_, "XRFdc_GetIPStatus"); + XRFdc_GetBlockStatus = (XRFdc_GetBlockStatus_t)dlsym(handle_, "XRFdc_GetBlockStatus"); + XRFdc_StartUp = (XRFdc_StartUp_t)dlsym(handle_, "XRFdc_StartUp"); + XRFdc_Shutdown = (XRFdc_Shutdown_t)dlsym(handle_, "XRFdc_Shutdown"); + XRFdc_Reset = (XRFdc_Reset_t)dlsym(handle_, "XRFdc_Reset"); + XRFdc_SetupFIFO = (XRFdc_SetupFIFO_t)dlsym(handle_, "XRFdc_SetupFIFO"); + XRFdc_DynamicPLLConfig = (XRFdc_DynamicPLLConfig_t)dlsym(handle_, "XRFdc_DynamicPLLConfig"); + XRFdc_GetFIFOStatus = (XRFdc_GetFIFOStatus_t)dlsym(handle_, "XRFdc_GetFIFOStatus"); + XRFdc_GetPLLLockStatus = (XRFdc_GetPLLLockStatus_t)dlsym(handle_, "XRFdc_GetPLLLockStatus"); + XRFdc_GetClockSource = (XRFdc_GetClockSource_t)dlsym(handle_, "XRFdc_GetClockSource"); + XRFdc_SetFabClkOutDiv = (XRFdc_SetFabClkOutDiv_t)dlsym(handle_, "XRFdc_SetFabClkOutDiv"); + XRFdc_GetFabClkOutDiv = (XRFdc_GetFabClkOutDiv_t)dlsym(handle_, "XRFdc_GetFabClkOutDiv"); + XRFdc_SetMixerSettings = (XRFdc_SetMixerSettings_t)dlsym(handle_, "XRFdc_SetMixerSettings"); + XRFdc_GetMixerSettings = (XRFdc_GetMixerSettings_t)dlsym(handle_, "XRFdc_GetMixerSettings"); + XRFdc_ResetNCOPhase = (XRFdc_ResetNCOPhase_t)dlsym(handle_, "XRFdc_ResetNCOPhase"); + XRFdc_SetNyquistZone = (XRFdc_SetNyquistZone_t)dlsym(handle_, "XRFdc_SetNyquistZone"); + XRFdc_GetNyquistZone = (XRFdc_GetNyquistZone_t)dlsym(handle_, "XRFdc_GetNyquistZone"); + XRFdc_SetInterpolationFactor = (XRFdc_SetInterpolationFactor_t)dlsym(handle_, "XRFdc_SetInterpolationFactor"); + XRFdc_GetInterpolationFactor = (XRFdc_GetInterpolationFactor_t)dlsym(handle_, "XRFdc_GetInterpolationFactor"); + XRFdc_SetDecimationFactor = (XRFdc_SetDecimationFactor_t)dlsym(handle_, "XRFdc_SetDecimationFactor"); + XRFdc_GetDecimationFactor = (XRFdc_GetDecimationFactor_t)dlsym(handle_, "XRFdc_GetDecimationFactor"); + XRFdc_SetQMCSettings = (XRFdc_SetQMCSettings_t)dlsym(handle_, "XRFdc_SetQMCSettings"); + XRFdc_GetQMCSettings = (XRFdc_GetQMCSettings_t)dlsym(handle_, "XRFdc_GetQMCSettings"); + XRFdc_SetThresholdSettings = (XRFdc_SetThresholdSettings_t)dlsym(handle_, "XRFdc_SetThresholdSettings"); + XRFdc_GetThresholdSettings = (XRFdc_GetThresholdSettings_t)dlsym(handle_, "XRFdc_GetThresholdSettings"); + + // Load additional function pointers (these may not all exist in older library versions) + XRFdc_SetThresholdClrMode = (XRFdc_SetThresholdClrMode_t)dlsym(handle_, "XRFdc_SetThresholdClrMode"); + XRFdc_ThresholdStickyClear = (XRFdc_ThresholdStickyClear_t)dlsym(handle_, "XRFdc_ThresholdStickyClear"); + XRFdc_GetCoarseDelaySettings = (XRFdc_GetCoarseDelaySettings_t)dlsym(handle_, "XRFdc_GetCoarseDelaySettings"); + XRFdc_SetCoarseDelaySettings = (XRFdc_SetCoarseDelaySettings_t)dlsym(handle_, "XRFdc_SetCoarseDelaySettings"); + XRFdc_GetEnabledInterrupts = (XRFdc_GetEnabledInterrupts_t)dlsym(handle_, "XRFdc_GetEnabledInterrupts"); + XRFdc_GetPwrMode = (XRFdc_GetPwrMode_t)dlsym(handle_, "XRFdc_GetPwrMode"); + XRFdc_SetPwrMode = (XRFdc_SetPwrMode_t)dlsym(handle_, "XRFdc_SetPwrMode"); + XRFdc_UpdateEvent = (XRFdc_UpdateEvent_t)dlsym(handle_, "XRFdc_UpdateEvent"); + XRFdc_ResetInternalFIFOWidth = (XRFdc_ResetInternalFIFOWidth_t)dlsym(handle_, "XRFdc_ResetInternalFIFOWidth"); + XRFdc_GetConnectedIData = (XRFdc_GetConnectedIData_t)dlsym(handle_, "XRFdc_GetConnectedIData"); + XRFdc_GetConnectedQData = (XRFdc_GetConnectedQData_t)dlsym(handle_, "XRFdc_GetConnectedQData"); + XRFdc_GetCalibrationMode = (XRFdc_GetCalibrationMode_t)dlsym(handle_, "XRFdc_GetCalibrationMode"); + XRFdc_SetCalibrationMode = (XRFdc_SetCalibrationMode_t)dlsym(handle_, "XRFdc_SetCalibrationMode"); + XRFdc_GetFabRdVldWords = (XRFdc_GetFabRdVldWords_t)dlsym(handle_, "XRFdc_GetFabRdVldWords"); + XRFdc_SetFabRdVldWords = (XRFdc_SetFabRdVldWords_t)dlsym(handle_, "XRFdc_SetFabRdVldWords"); + XRFdc_GetFabWrVldWords = (XRFdc_GetFabWrVldWords_t)dlsym(handle_, "XRFdc_GetFabWrVldWords"); + XRFdc_SetFabWrVldWords = (XRFdc_SetFabWrVldWords_t)dlsym(handle_, "XRFdc_SetFabWrVldWords"); + XRFdc_GetDecimationFactorObs = (XRFdc_GetDecimationFactorObs_t)dlsym(handle_, "XRFdc_GetDecimationFactorObs"); + XRFdc_SetDecimationFactorObs = (XRFdc_SetDecimationFactorObs_t)dlsym(handle_, "XRFdc_SetDecimationFactorObs"); + XRFdc_GetFabRdVldWordsObs = (XRFdc_GetFabRdVldWordsObs_t)dlsym(handle_, "XRFdc_GetFabRdVldWordsObs"); + XRFdc_SetFabRdVldWordsObs = (XRFdc_SetFabRdVldWordsObs_t)dlsym(handle_, "XRFdc_SetFabRdVldWordsObs"); + XRFdc_GetFabWrVldWordsObs = (XRFdc_GetFabWrVldWordsObs_t)dlsym(handle_, "XRFdc_GetFabWrVldWordsObs"); + XRFdc_GetDither = (XRFdc_GetDither_t)dlsym(handle_, "XRFdc_GetDither"); + XRFdc_SetDither = (XRFdc_SetDither_t)dlsym(handle_, "XRFdc_SetDither"); + XRFdc_GetCalFreeze = (XRFdc_GetCalFreeze_t)dlsym(handle_, "XRFdc_GetCalFreeze"); + XRFdc_SetCalFreeze = (XRFdc_SetCalFreeze_t)dlsym(handle_, "XRFdc_SetCalFreeze"); + XRFdc_GetDSA = (XRFdc_GetDSA_t)dlsym(handle_, "XRFdc_GetDSA"); + XRFdc_SetDSA = (XRFdc_SetDSA_t)dlsym(handle_, "XRFdc_SetDSA"); + XRFdc_DisableCoefficientsOverride = (XRFdc_DisableCoefficientsOverride_t)dlsym(handle_, "XRFdc_DisableCoefficientsOverride"); + XRFdc_ResetInternalFIFOWidthObs = (XRFdc_ResetInternalFIFOWidthObs_t)dlsym(handle_, "XRFdc_ResetInternalFIFOWidthObs"); + XRFdc_SetCalCoefficients = (XRFdc_SetCalCoefficients_t)dlsym(handle_, "XRFdc_SetCalCoefficients"); + XRFdc_GetCalCoefficients = (XRFdc_GetCalCoefficients_t)dlsym(handle_, "XRFdc_GetCalCoefficients"); + XRFdc_GetDecoderMode = (XRFdc_GetDecoderMode_t)dlsym(handle_, "XRFdc_GetDecoderMode"); + XRFdc_SetDecoderMode = (XRFdc_SetDecoderMode_t)dlsym(handle_, "XRFdc_SetDecoderMode"); + XRFdc_GetOutputCurr = (XRFdc_GetOutputCurr_t)dlsym(handle_, "XRFdc_GetOutputCurr"); + XRFdc_GetInvSincFIR = (XRFdc_GetInvSincFIR_t)dlsym(handle_, "XRFdc_GetInvSincFIR"); + XRFdc_SetInvSincFIR = (XRFdc_SetInvSincFIR_t)dlsym(handle_, "XRFdc_SetInvSincFIR"); + XRFdc_GetDataPathMode = (XRFdc_GetDataPathMode_t)dlsym(handle_, "XRFdc_GetDataPathMode"); + XRFdc_SetDataPathMode = (XRFdc_SetDataPathMode_t)dlsym(handle_, "XRFdc_SetDataPathMode"); + XRFdc_GetIMRPassMode = (XRFdc_GetIMRPassMode_t)dlsym(handle_, "XRFdc_GetIMRPassMode"); + XRFdc_SetIMRPassMode = (XRFdc_SetIMRPassMode_t)dlsym(handle_, "XRFdc_SetIMRPassMode"); + XRFdc_GetDACCompMode = (XRFdc_GetDACCompMode_t)dlsym(handle_, "XRFdc_GetDACCompMode"); + XRFdc_SetDACCompMode = (XRFdc_SetDACCompMode_t)dlsym(handle_, "XRFdc_SetDACCompMode"); + XRFdc_SetDACVOP = (XRFdc_SetDACVOP_t)dlsym(handle_, "XRFdc_SetDACVOP"); + XRFdc_DumpRegs = (XRFdc_DumpRegs_t)dlsym(handle_, "XRFdc_DumpRegs"); + XRFdc_GetPLLConfig = (XRFdc_GetPLLConfig_t)dlsym(handle_, "XRFdc_GetPLLConfig"); + XRFdc_SetupFIFOObs = (XRFdc_SetupFIFOObs_t)dlsym(handle_, "XRFdc_SetupFIFOObs"); + XRFdc_SetupFIFOBoth = (XRFdc_SetupFIFOBoth_t)dlsym(handle_, "XRFdc_SetupFIFOBoth"); + XRFdc_GetFIFOStatusObs = (XRFdc_GetFIFOStatusObs_t)dlsym(handle_, "XRFdc_GetFIFOStatusObs"); + XRFdc_GetClkDistribution = (XRFdc_GetClkDistribution_t)dlsym(handle_, "XRFdc_GetClkDistribution"); + XRFdc_SetClkDistribution = (XRFdc_SetClkDistribution_t)dlsym(handle_, "XRFdc_SetClkDistribution"); + + if (!XRFdc_LookupConfig || !XRFdc_CfgInitialize || + !XRFdc_GetIPStatus || !XRFdc_GetBlockStatus || + !XRFdc_StartUp || !XRFdc_Shutdown || !XRFdc_Reset || + !XRFdc_SetupFIFO || !XRFdc_DynamicPLLConfig) { + unloadLibrary(); + throw std::runtime_error("Failed to load required XRFdc functions"); + } + +#ifdef DEBUG + std::cout << "librfdc.so loaded successfully" << std::endl; +#endif +} + +void libxrfdcManager::unloadLibrary() { + if (handle_) { +#ifdef DEBUG + std::cout << "Unloading librfdc.so..." << std::endl; +#endif + dlclose(handle_); + handle_ = nullptr; + } +} + +// ============================================================================ +// XrfdcRemote Implementation +// ============================================================================ + +XrfdcRemote::XrfdcRemote() + : rfdc_inst_(nullptr), config_(nullptr), device_id_(0), + io_(nullptr), mem_fd_(-1), mapped_base_(nullptr), mapped_size_(0) { +#ifdef DEBUG + std::cout << "XrfdcRemote: Loading librfdc.so" << std::endl; +#endif + lib_manager_.loadLibrary(); +#ifdef DEBUG + std::cout << "XrfdcRemote initialized" << std::endl; +#endif +} + +XrfdcRemote::~XrfdcRemote() { +#ifdef DEBUG + std::cout << "XrfdcRemote: Unloading library" << std::endl; +#endif + cleanup(); + lib_manager_.unloadLibrary(); +#ifdef DEBUG + std::cout << "XrfdcRemote destroyed" << std::endl; +#endif +} + +void XrfdcRemote::cleanup() { + if (config_) { + free(config_); + config_ = nullptr; + } + if (rfdc_inst_) { + free(rfdc_inst_); + rfdc_inst_ = nullptr; + } + if (io_) { + free(io_); + io_ = nullptr; + } + if (mapped_base_ && mapped_size_ > 0) { + munmap(mapped_base_, mapped_size_); + mapped_base_ = nullptr; + } + mapped_size_ = 0; + if (mem_fd_ >= 0) { + close(mem_fd_); + mem_fd_ = -1; + } +} + +void XrfdcRemote::Invalidate() { + cleanup(); +} + +struct metal_io_region* XrfdcRemote::create_io_region_from_devmem( + void *virt_addr, uint64_t phys_addr, size_t size) { + struct metal_io_region *io; + metal_phys_addr_t phys = phys_addr; + + io = (struct metal_io_region*)malloc(sizeof(struct metal_io_region)); + if (!io) return nullptr; + + metal_io_init(io, virt_addr, &phys, size, + sizeof(metal_phys_addr_t) << 3, 0, nullptr); + + return io; +} + +XRFdc_Config* XrfdcRemote::ConvertProtoToConfig(const xrfdc::RFdcConfig& proto_config) { + XRFdc_Config *Config = (XRFdc_Config*)malloc(sizeof(XRFdc_Config)); + if (!Config) return nullptr; + + memset(Config, 0, sizeof(XRFdc_Config)); + + // Top-level configuration + Config->DeviceId = proto_config.device_id(); + Config->BaseAddr = proto_config.base_addr(); + Config->ADCType = proto_config.adc_type(); + Config->MasterADCTile = proto_config.master_adc_tile(); + Config->MasterDACTile = proto_config.master_dac_tile(); + Config->ADCSysRefSource = proto_config.adc_sysref_source(); + Config->DACSysRefSource = proto_config.dac_sysref_source(); + Config->IPType = proto_config.ip_type(); + Config->SiRevision = proto_config.si_revision(); + + // DAC Tile configurations (4 tiles) + for (int tile = 0; tile < 4 && tile < proto_config.dac_tile_config_size(); tile++) { + const xrfdc::DACTileConfig& proto_tile = proto_config.dac_tile_config(tile); + XRFdc_DACTile_Config& c_tile = Config->DACTile_Config[tile]; + + // Tile-level fields + c_tile.Enable = proto_tile.enable(); + c_tile.PLLEnable = proto_tile.pll_enable(); + c_tile.SamplingRate = proto_tile.sampling_rate(); + c_tile.RefClkFreq = proto_tile.ref_clk_freq(); + c_tile.FabClkFreq = proto_tile.fab_clk_freq(); + c_tile.FeedbackDiv = proto_tile.feedback_div(); + c_tile.OutputDiv = proto_tile.output_div(); + c_tile.RefClkDiv = proto_tile.ref_clk_div(); + c_tile.MultibandConfig = proto_tile.multiband_config(); + c_tile.MaxSampleRate = proto_tile.max_sample_rate(); + c_tile.NumSlices = proto_tile.num_slices(); + + // DAC Block Analog config (4 blocks per tile) + for (int block = 0; block < 4 && block < proto_tile.dac_block_analog_config_size(); block++) { + const xrfdc::DACBlockAnalogDataPathConfig& proto_analog = proto_tile.dac_block_analog_config(block); + XRFdc_DACBlock_AnalogDataPath_Config& c_analog = c_tile.DACBlock_Analog_Config[block]; + + c_analog.BlockAvailable = proto_analog.block_available(); + c_analog.InvSyncEnable = proto_analog.inv_sync_enable(); + c_analog.MixMode = proto_analog.mix_mode(); + c_analog.DecoderMode = proto_analog.decoder_mode(); + } + + // DAC Block Digital config (4 blocks per tile) + for (int block = 0; block < 4 && block < proto_tile.dac_block_digital_config_size(); block++) { + const xrfdc::DACBlockDigitalDataPathConfig& proto_digital = proto_tile.dac_block_digital_config(block); + XRFdc_DACBlock_DigitalDataPath_Config& c_digital = c_tile.DACBlock_Digital_Config[block]; + + c_digital.MixerInputDataType = proto_digital.mixer_input_data_type(); + c_digital.DataWidth = proto_digital.data_width(); + c_digital.InterpolationMode = proto_digital.interpolation_mode(); + c_digital.FifoEnable = proto_digital.fifo_enable(); + c_digital.AdderEnable = proto_digital.adder_enable(); + c_digital.MixerType = proto_digital.mixer_type(); + } + } + + // ADC Tile configurations (4 tiles) + for (int tile = 0; tile < 4 && tile < proto_config.adc_tile_config_size(); tile++) { + const xrfdc::ADCTileConfig& proto_tile = proto_config.adc_tile_config(tile); + XRFdc_ADCTile_Config& c_tile = Config->ADCTile_Config[tile]; + + // Tile-level fields + c_tile.Enable = proto_tile.enable(); + c_tile.PLLEnable = proto_tile.pll_enable(); + c_tile.SamplingRate = proto_tile.sampling_rate(); + c_tile.RefClkFreq = proto_tile.ref_clk_freq(); + c_tile.FabClkFreq = proto_tile.fab_clk_freq(); + c_tile.FeedbackDiv = proto_tile.feedback_div(); + c_tile.OutputDiv = proto_tile.output_div(); + c_tile.RefClkDiv = proto_tile.ref_clk_div(); + c_tile.MultibandConfig = proto_tile.multiband_config(); + c_tile.MaxSampleRate = proto_tile.max_sample_rate(); + c_tile.NumSlices = proto_tile.num_slices(); + + // ADC Block Analog config (4 blocks per tile) + for (int block = 0; block < 4 && block < proto_tile.adc_block_analog_config_size(); block++) { + const xrfdc::ADCBlockAnalogDataPathConfig& proto_analog = proto_tile.adc_block_analog_config(block); + XRFdc_ADCBlock_AnalogDataPath_Config& c_analog = c_tile.ADCBlock_Analog_Config[block]; + + c_analog.BlockAvailable = proto_analog.block_available(); + c_analog.MixMode = proto_analog.mix_mode(); + } + + // ADC Block Digital config (4 blocks per tile) + for (int block = 0; block < 4 && block < proto_tile.adc_block_digital_config_size(); block++) { + const xrfdc::ADCBlockDigitalDataPathConfig& proto_digital = proto_tile.adc_block_digital_config(block); + XRFdc_ADCBlock_DigitalDataPath_Config& c_digital = c_tile.ADCBlock_Digital_Config[block]; + + c_digital.MixerInputDataType = proto_digital.mixer_input_data_type(); + c_digital.DataWidth = proto_digital.data_width(); + c_digital.DecimationMode = proto_digital.decimation_mode(); + c_digital.FifoEnable = proto_digital.fifo_enable(); + c_digital.MixerType = proto_digital.mixer_type(); + } + } + + return Config; +} + +// ============================================================================ +// Helper Functions: C Structures -> Protobuf Messages +// ============================================================================ + +void XrfdcRemote::ConvertBlockStatus(const XRFdc_BlockStatus& c_block, xrfdc::BlockStatus* proto_block) { + proto_block->set_sampling_freq(c_block.SamplingFreq); + proto_block->set_analog_data_path_status(c_block.AnalogDataPathStatus); + proto_block->set_digital_data_path_status(c_block.DigitalDataPathStatus); + proto_block->set_data_path_clocks_status(c_block.DataPathClocksStatus); + proto_block->set_is_fifo_flags_enabled(c_block.IsFIFOFlagsEnabled); + proto_block->set_is_fifo_flags_asserted(c_block.IsFIFOFlagsAsserted); +} + +void XrfdcRemote::ConvertTileStatus(const XRFdc_TileStatus& c_tile, + xrfdc::TileStatus* proto_tile, + u32 tile_type, u32 tile_id) { + proto_tile->set_is_enabled(c_tile.IsEnabled != 0); + proto_tile->set_tile_state(static_cast(c_tile.TileState)); + proto_tile->set_block_status_mask(c_tile.BlockStatusMask); + proto_tile->set_power_up_state(c_tile.PowerUpState); + proto_tile->set_pll_state(static_cast(c_tile.PLLState)); + + // Get detailed block status for each active block + for (int block = 0; block < 4; block++) { + if (c_tile.BlockStatusMask & (1 << block)) { + XRFdc_BlockStatus BlockStatus; + int ret = lib_manager_.XRFdc_GetBlockStatus(rfdc_inst_, tile_type, tile_id, block, &BlockStatus); + if (ret == XRFDC_SUCCESS) { + xrfdc::BlockStatus* proto_block = proto_tile->add_block_status(); + ConvertBlockStatus(BlockStatus, proto_block); + } + } + } +} + +void XrfdcRemote::ConvertIPStatus(const XRFdc_IPStatus& c_status, xrfdc::IPStatus* proto_status) { + // Convert 4 DAC tiles + for (int i = 0; i < 4; i++) { + xrfdc::TileStatus* dac_tile = proto_status->add_dac_tile_status(); + ConvertTileStatus(c_status.DACTileStatus[i], dac_tile, XRFDC_DAC_TILE, i); + } + + // Convert 4 ADC tiles + for (int i = 0; i < 4; i++) { + xrfdc::TileStatus* adc_tile = proto_status->add_adc_tile_status(); + ConvertTileStatus(c_status.ADCTileStatus[i], adc_tile, XRFDC_ADC_TILE, i); + } + + // Set overall IP state + proto_status->set_state(c_status.State); +} + +void XrfdcRemote::CfgInitialize(const xrfdc::CfgInitializeRequest& request) { + cleanup(); + + try { + const auto& proto_config = request.config(); + u32 base_addr = proto_config.base_addr(); + + // Get size from request, default to 256KB if not provided + u32 size = request.size() > 0 ? request.size() : 0x40000; + +#ifdef DEBUG + std::cout << "CfgInitialize called with base_addr: 0x" + << std::hex << base_addr + << " size: 0x" << size << std::dec << std::endl; +#endif + + // Store the size for cleanup + mapped_size_ = size; + + // Open /dev/mem + mem_fd_ = open("/dev/mem", O_RDWR | O_SYNC); + if (mem_fd_ == -1) { + throw std::runtime_error("Failed to open /dev/mem"); + } + + // Map RFDC registers with dynamic size + mapped_base_ = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd_, base_addr); + if (mapped_base_ == MAP_FAILED) { + mapped_base_ = nullptr; + throw std::runtime_error("Failed to map RFDC registers"); + } + + // Create libmetal I/O region with dynamic size + io_ = create_io_region_from_devmem(mapped_base_, base_addr, size); + if (!io_) { + throw std::runtime_error("Failed to create I/O region"); + } + + // Prepare RFDC instance + rfdc_inst_ = (XRFdc*)malloc(sizeof(XRFdc)); + if (!rfdc_inst_) { + throw std::runtime_error("Failed to allocate RFDC instance"); + } + memset(rfdc_inst_, 0, sizeof(XRFdc)); + rfdc_inst_->io = io_; + rfdc_inst_->BaseAddr = base_addr; + + // Convert protobuf config to C structure + config_ = ConvertProtoToConfig(proto_config); + if (!config_) { + throw std::runtime_error("Failed to convert protobuf configuration"); + } + + // Initialize RFDC driver + int status = lib_manager_.XRFdc_CfgInitialize(rfdc_inst_, config_); + if (status != XRFDC_SUCCESS) { + throw std::runtime_error("XRFdc_CfgInitialize failed with code " + + std::to_string(status)); + } + } catch (...) { + cleanup(); + throw; + } + +#ifdef DEBUG + std::cout << "CfgInitialize successful" << std::endl; +#endif +} + +xrfdc::IPStatus XrfdcRemote::GetIPStatus(){ +#ifdef DEBUG + std::cout << "GetIPStatus called" << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + XRFdc_IPStatus c_status; + memset(&c_status, 0, sizeof(XRFdc_IPStatus)); + + int status = lib_manager_.XRFdc_GetIPStatus(rfdc_inst_, &c_status); + if (status != XRFDC_SUCCESS) { + throw std::runtime_error("XRFdc_GetIPStatus failed with code " + std::to_string(status)); + } + + xrfdc::IPStatus proto_status; + ConvertIPStatus(c_status, &proto_status); + +#ifdef DEBUG + std::cout << "GetIPStatus successful" << std::endl; +#endif + + return proto_status; +} + +// ============================================================================ +// Tile Control Methods +// ============================================================================ + +int XrfdcRemote::StartUp(u32 tile_type, u32 tile_id) { +#ifdef DEBUG + std::cout << "StartUp called: type=" << tile_type << " id=" << tile_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + int status = lib_manager_.XRFdc_StartUp(rfdc_inst_, tile_type, tile_id); + +#ifdef DEBUG + std::cout << "StartUp returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::Shutdown(u32 tile_type, u32 tile_id) { +#ifdef DEBUG + std::cout << "Shutdown called: type=" << tile_type << " id=" << tile_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + int status = lib_manager_.XRFdc_Shutdown(rfdc_inst_, tile_type, tile_id); + +#ifdef DEBUG + std::cout << "Shutdown returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::Reset(u32 tile_type, u32 tile_id) { +#ifdef DEBUG + std::cout << "Reset called: type=" << tile_type << " id=" << tile_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + int status = lib_manager_.XRFdc_Reset(rfdc_inst_, tile_type, tile_id); + +#ifdef DEBUG + std::cout << "Reset returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::SetupFIFO(u32 tile_type, u32 tile_id, bool enable) { +#ifdef DEBUG + std::cout << "SetupFIFO called: type=" << tile_type << " id=" << tile_id + << " enable=" << enable << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + int status = lib_manager_.XRFdc_SetupFIFO(rfdc_inst_, tile_type, tile_id, + enable ? 1 : 0); + +#ifdef DEBUG + std::cout << "SetupFIFO returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::DynamicPLLConfig(u32 tile_type, u32 tile_id, + u32 source, double ref_clk_freq, + double samp_rate) { +#ifdef DEBUG + std::cout << "DynamicPLLConfig called: type=" << tile_type << " id=" << tile_id + << " source=" << source << " ref_clk=" << ref_clk_freq + << " samp_rate=" << samp_rate << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + int status = lib_manager_.XRFdc_DynamicPLLConfig(rfdc_inst_, tile_type, tile_id, + source, ref_clk_freq, samp_rate); + +#ifdef DEBUG + std::cout << "DynamicPLLConfig returned: " << status << std::endl; +#endif + + return status; +} + +// ============================================================================ +// Status/Monitoring Methods +// ============================================================================ + +int XrfdcRemote::GetBlockStatus(u32 tile_type, u32 tile_id, + u32 block_id, XRFdc_BlockStatus* block_status) { +#ifdef DEBUG + std::cout << "GetBlockStatus called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetBlockStatus || !block_status) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_GetBlockStatus(rfdc_inst_, tile_type, tile_id, + block_id, block_status); + +#ifdef DEBUG + std::cout << "GetBlockStatus returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetFIFOStatus(u32 tile_type, u32 tile_id, + u32 block_id, bool* enable) { +#ifdef DEBUG + std::cout << "GetFIFOStatus called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetFIFOStatus) { + return XRFDC_FAILURE; + } + + uint8_t enable_u8 = 0; + int status = lib_manager_.XRFdc_GetFIFOStatus(rfdc_inst_, tile_type, tile_id, &enable_u8); + if (enable) { + *enable = (enable_u8 != 0); + } + +#ifdef DEBUG + std::cout << "GetFIFOStatus returned: " << status << " enable=" << (int)enable_u8 << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetPLLLockStatus(u32 tile_type, u32 tile_id, u32* lock_status) { +#ifdef DEBUG + std::cout << "GetPLLLockStatus called: type=" << tile_type << " tile=" << tile_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetPLLLockStatus || !lock_status) { + return XRFDC_FAILURE; + } + + *lock_status = 0; + int status = lib_manager_.XRFdc_GetPLLLockStatus(rfdc_inst_, tile_type, tile_id, lock_status); + +#ifdef DEBUG + std::cout << "GetPLLLockStatus returned: " << status << " lock_status=" << *lock_status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetClockSource(u32 tile_type, u32 tile_id, u32* clock_source) { +#ifdef DEBUG + std::cout << "GetClockSource called: type=" << tile_type << " tile=" << tile_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetClockSource || !clock_source) { + return XRFDC_FAILURE; + } + + *clock_source = 0; + int status = lib_manager_.XRFdc_GetClockSource(rfdc_inst_, tile_type, tile_id, clock_source); + +#ifdef DEBUG + std::cout << "GetClockSource returned: " << status << " clock_source=" << *clock_source << std::endl; +#endif + + return status; +} + +// ============================================================================ +// Clock Configuration Methods +// ============================================================================ + +int XrfdcRemote::SetFabClkOutDiv(u32 tile_type, u32 tile_id, u32 fab_clk_div) { +#ifdef DEBUG + std::cout << "SetFabClkOutDiv called: type=" << tile_type << " tile=" << tile_id + << " div=" << fab_clk_div << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetFabClkOutDiv) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_SetFabClkOutDiv(rfdc_inst_, tile_type, tile_id, + static_cast(fab_clk_div)); + +#ifdef DEBUG + std::cout << "SetFabClkOutDiv returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetFabClkOutDiv(u32 tile_type, u32 tile_id, u32* fab_clk_div) { +#ifdef DEBUG + std::cout << "GetFabClkOutDiv called: type=" << tile_type << " tile=" << tile_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetFabClkOutDiv) { + return XRFDC_FAILURE; + } + + uint16_t div_u16 = 0; + int status = lib_manager_.XRFdc_GetFabClkOutDiv(rfdc_inst_, tile_type, tile_id, &div_u16); + if (fab_clk_div) { + *fab_clk_div = static_cast(div_u16); + } + +#ifdef DEBUG + std::cout << "GetFabClkOutDiv returned: " << status << " div=" << div_u16 << std::endl; +#endif + + return status; +} + +// ============================================================================ +// Mixer Methods +// ============================================================================ + +int XrfdcRemote::SetMixerSettings(u32 tile_type, u32 tile_id, u32 block_id, + const xrfdc::MixerSettings& settings) { +#ifdef DEBUG + std::cout << "SetMixerSettings called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << " freq=" << settings.freq() << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetMixerSettings) { + return XRFDC_FAILURE; + } + + XRFdc_Mixer_Settings c_settings; + memset(&c_settings, 0, sizeof(XRFdc_Mixer_Settings)); + + c_settings.Freq = settings.freq(); + c_settings.PhaseOffset = settings.phase_offset(); + c_settings.EventSource = settings.event_source(); + c_settings.CoarseMixFreq = settings.coarse_mix_freq(); + c_settings.MixerMode = settings.mixer_mode(); + c_settings.FineMixerScale = settings.fine_mixer_scale(); + c_settings.MixerType = settings.mixer_type(); + + int status = lib_manager_.XRFdc_SetMixerSettings(rfdc_inst_, tile_type, tile_id, + block_id, &c_settings); + +#ifdef DEBUG + std::cout << "SetMixerSettings returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetMixerSettings(u32 tile_type, u32 tile_id, u32 block_id, + xrfdc::MixerSettings* settings) { +#ifdef DEBUG + std::cout << "GetMixerSettings called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetMixerSettings || !settings) { + return XRFDC_FAILURE; + } + + XRFdc_Mixer_Settings c_settings; + memset(&c_settings, 0, sizeof(XRFdc_Mixer_Settings)); + + int status = lib_manager_.XRFdc_GetMixerSettings(rfdc_inst_, tile_type, tile_id, + block_id, &c_settings); + + if (status == XRFDC_SUCCESS) { + settings->set_freq(c_settings.Freq); + settings->set_phase_offset(c_settings.PhaseOffset); + settings->set_event_source(c_settings.EventSource); + settings->set_coarse_mix_freq(c_settings.CoarseMixFreq); + settings->set_mixer_mode(c_settings.MixerMode); + settings->set_fine_mixer_scale(c_settings.FineMixerScale); + settings->set_mixer_type(c_settings.MixerType); + } + +#ifdef DEBUG + std::cout << "GetMixerSettings returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::ResetNCOPhase(u32 tile_type, u32 tile_id, u32 block_id) { +#ifdef DEBUG + std::cout << "ResetNCOPhase called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_ResetNCOPhase) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_ResetNCOPhase(rfdc_inst_, tile_type, tile_id, block_id); + +#ifdef DEBUG + std::cout << "ResetNCOPhase returned: " << status << std::endl; +#endif + + return status; +} + +// ============================================================================ +// Nyquist Zone Methods +// ============================================================================ + +int XrfdcRemote::SetNyquistZone(u32 tile_type, u32 tile_id, u32 block_id, + u32 nyquist_zone) { +#ifdef DEBUG + std::cout << "SetNyquistZone called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << " zone=" << nyquist_zone << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetNyquistZone) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_SetNyquistZone(rfdc_inst_, tile_type, tile_id, + block_id, nyquist_zone); + +#ifdef DEBUG + std::cout << "SetNyquistZone returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetNyquistZone(u32 tile_type, u32 tile_id, u32 block_id, + u32* nyquist_zone) { +#ifdef DEBUG + std::cout << "GetNyquistZone called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetNyquistZone) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_GetNyquistZone(rfdc_inst_, tile_type, tile_id, + block_id, nyquist_zone); + +#ifdef DEBUG + std::cout << "GetNyquistZone returned: " << status << std::endl; +#endif + + return status; +} + +// ============================================================================ +// Interpolation/Decimation Methods +// ============================================================================ + +int XrfdcRemote::SetInterpolationFactor(u32 tile_id, u32 block_id, + u32 interp_factor) { +#ifdef DEBUG + std::cout << "SetInterpolationFactor called: tile=" << tile_id << " block=" << block_id + << " factor=" << interp_factor << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetInterpolationFactor) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_SetInterpolationFactor(rfdc_inst_, tile_id, block_id, + interp_factor); + +#ifdef DEBUG + std::cout << "SetInterpolationFactor returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetInterpolationFactor(u32 tile_id, u32 block_id, + u32* interp_factor) { +#ifdef DEBUG + std::cout << "GetInterpolationFactor called: tile=" << tile_id << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetInterpolationFactor) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_GetInterpolationFactor(rfdc_inst_, tile_id, block_id, + interp_factor); + +#ifdef DEBUG + std::cout << "GetInterpolationFactor returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::SetDecimationFactor(u32 tile_id, u32 block_id, + u32 dec_factor) { +#ifdef DEBUG + std::cout << "SetDecimationFactor called: tile=" << tile_id << " block=" << block_id + << " factor=" << dec_factor << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetDecimationFactor) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_SetDecimationFactor(rfdc_inst_, tile_id, block_id, + dec_factor); + +#ifdef DEBUG + std::cout << "SetDecimationFactor returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetDecimationFactor(u32 tile_id, u32 block_id, + u32* dec_factor) { +#ifdef DEBUG + std::cout << "GetDecimationFactor called: tile=" << tile_id << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetDecimationFactor) { + return XRFDC_FAILURE; + } + + int status = lib_manager_.XRFdc_GetDecimationFactor(rfdc_inst_, tile_id, block_id, + dec_factor); + +#ifdef DEBUG + std::cout << "GetDecimationFactor returned: " << status << std::endl; +#endif + + return status; +} + +// ============================================================================ +// QMC Methods +// ============================================================================ + +int XrfdcRemote::SetQMCSettings(u32 tile_type, u32 tile_id, u32 block_id, + const xrfdc::QMCSettings& settings) { +#ifdef DEBUG + std::cout << "SetQMCSettings called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetQMCSettings) { + return XRFDC_FAILURE; + } + + XRFdc_QMC_Settings c_settings; + memset(&c_settings, 0, sizeof(XRFdc_QMC_Settings)); + + c_settings.EnablePhase = settings.enable_phase() ? 1 : 0; + c_settings.EnableGain = settings.enable_gain() ? 1 : 0; + c_settings.GainCorrectionFactor = settings.gain_correction_factor(); + c_settings.PhaseCorrectionFactor = settings.phase_correction_factor(); + c_settings.OffsetCorrectionFactor = settings.offset_correction_factor(); + c_settings.EventSource = settings.event_source(); + + int status = lib_manager_.XRFdc_SetQMCSettings(rfdc_inst_, tile_type, tile_id, + block_id, &c_settings); + +#ifdef DEBUG + std::cout << "SetQMCSettings returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetQMCSettings(u32 tile_type, u32 tile_id, u32 block_id, + xrfdc::QMCSettings* settings) { +#ifdef DEBUG + std::cout << "GetQMCSettings called: type=" << tile_type << " tile=" << tile_id + << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetQMCSettings || !settings) { + return XRFDC_FAILURE; + } + + XRFdc_QMC_Settings c_settings; + memset(&c_settings, 0, sizeof(XRFdc_QMC_Settings)); + + int status = lib_manager_.XRFdc_GetQMCSettings(rfdc_inst_, tile_type, tile_id, + block_id, &c_settings); + + if (status == XRFDC_SUCCESS) { + settings->set_enable_phase(c_settings.EnablePhase != 0); + settings->set_enable_gain(c_settings.EnableGain != 0); + settings->set_gain_correction_factor(c_settings.GainCorrectionFactor); + settings->set_phase_correction_factor(c_settings.PhaseCorrectionFactor); + settings->set_offset_correction_factor(c_settings.OffsetCorrectionFactor); + settings->set_event_source(c_settings.EventSource); + } + +#ifdef DEBUG + std::cout << "GetQMCSettings returned: " << status << std::endl; +#endif + + return status; +} + +// ============================================================================ +// Threshold Methods (ADC only) +// ============================================================================ + +int XrfdcRemote::SetThresholdSettings(u32 tile_id, u32 block_id, + const xrfdc::ThresholdSettings& settings) { +#ifdef DEBUG + std::cout << "SetThresholdSettings called: tile=" << tile_id << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_SetThresholdSettings) { + return XRFDC_FAILURE; + } + + XRFdc_Threshold_Settings c_settings; + memset(&c_settings, 0, sizeof(XRFdc_Threshold_Settings)); + + c_settings.UpdateThreshold = settings.update_threshold(); + for (int i = 0; i < 2; ++i) { + c_settings.ThresholdMode[i] = + settings.threshold_mode_size() > i ? settings.threshold_mode(i) : 0; + c_settings.ThresholdAvgVal[i] = + settings.threshold_avg_val_size() > i ? settings.threshold_avg_val(i) : 0; + c_settings.ThresholdUnderVal[i] = + settings.threshold_under_val_size() > i ? settings.threshold_under_val(i) : 0; + c_settings.ThresholdOverVal[i] = + settings.threshold_over_val_size() > i ? settings.threshold_over_val(i) : 0; + } + + int status = lib_manager_.XRFdc_SetThresholdSettings(rfdc_inst_, tile_id, block_id, + &c_settings); + +#ifdef DEBUG + std::cout << "SetThresholdSettings returned: " << status << std::endl; +#endif + + return status; +} + +int XrfdcRemote::GetThresholdSettings(u32 tile_id, u32 block_id, + xrfdc::ThresholdSettings* settings) { +#ifdef DEBUG + std::cout << "GetThresholdSettings called: tile=" << tile_id << " block=" << block_id << std::endl; +#endif + + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized. Call CfgInitialize first."); + } + + if (!lib_manager_.XRFdc_GetThresholdSettings || !settings) { + return XRFDC_FAILURE; + } + + XRFdc_Threshold_Settings c_settings; + memset(&c_settings, 0, sizeof(XRFdc_Threshold_Settings)); + + int status = lib_manager_.XRFdc_GetThresholdSettings(rfdc_inst_, tile_id, block_id, + &c_settings); + + if (status == XRFDC_SUCCESS) { + settings->set_update_threshold(c_settings.UpdateThreshold); + for (int i = 0; i < 2; ++i) { + settings->add_threshold_mode(c_settings.ThresholdMode[i]); + settings->add_threshold_avg_val(c_settings.ThresholdAvgVal[i]); + settings->add_threshold_under_val(c_settings.ThresholdUnderVal[i]); + settings->add_threshold_over_val(c_settings.ThresholdOverVal[i]); + } + } + +#ifdef DEBUG + std::cout << "GetThresholdSettings returned: " << status << std::endl; +#endif + + return status; +} + + +// ============================================================================ +// Additional XrfdcRemote Wrapper Methods +// ============================================================================ + +u32 XrfdcRemote::SetThresholdClrMode(u32 tile_id, u32 block_id, + u32 threshold_to_update, u32 clr_mode) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_SetThresholdClrMode) { + return XRFDC_FAILURE; + } + return lib_manager_.XRFdc_SetThresholdClrMode(rfdc_inst_, tile_id, block_id, + threshold_to_update, clr_mode); +} + +u32 XrfdcRemote::ThresholdStickyClear(u32 tile_id, u32 block_id, + u32 threshold_to_update) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_ThresholdStickyClear) { + return XRFDC_FAILURE; + } + return lib_manager_.XRFdc_ThresholdStickyClear(rfdc_inst_, tile_id, block_id, + threshold_to_update); +} + +u32 XrfdcRemote::GetEnabledInterrupts(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_GetEnabledInterrupts) { + return 0; + } + u32 intr_mask = 0; + u32 status = lib_manager_.XRFdc_GetEnabledInterrupts(rfdc_inst_, tile_type, tile_id, block_id, &intr_mask); + if (status != XRFDC_SUCCESS) { + return 0; + } + return intr_mask; +} + +u32 XrfdcRemote::UpdateEvent(u32 tile_type, u32 tile_id, u32 block_id, u32 event) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_UpdateEvent) { + return XRFDC_FAILURE; + } + return lib_manager_.XRFdc_UpdateEvent(rfdc_inst_, tile_type, tile_id, block_id, event); +} + +u32 XrfdcRemote::ResetInternalFIFOWidth(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_ResetInternalFIFOWidth) { + return XRFDC_FAILURE; + } + return lib_manager_.XRFdc_ResetInternalFIFOWidth(rfdc_inst_, tile_type, tile_id, block_id); +} + +int XrfdcRemote::GetConnectedIData(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_GetConnectedIData) { + return -1; + } + return lib_manager_.XRFdc_GetConnectedIData(rfdc_inst_, tile_type, tile_id, block_id); +} + +int XrfdcRemote::GetConnectedQData(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (!lib_manager_.XRFdc_GetConnectedQData) { + return -1; + } + return lib_manager_.XRFdc_GetConnectedQData(rfdc_inst_, tile_type, tile_id, block_id); +} + +void XrfdcRemote::DumpRegs(u32 tile_type, u32 tile_id) { + if (!rfdc_inst_) { + throw std::runtime_error("RFDC not initialized"); + } + if (lib_manager_.XRFdc_DumpRegs) { + lib_manager_.XRFdc_DumpRegs(rfdc_inst_, tile_type, tile_id); + } +} + +// Note: Some functions might not be available in all versions of librfdc.so +// Functions will return FAILURE or default values if not loaded + +// ADC-specific methods +uint8_t XrfdcRemote::GetCalibrationMode(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetCalibrationMode) return 0; + uint8_t mode = 0; + u32 status = lib_manager_.XRFdc_GetCalibrationMode(rfdc_inst_, tile_id, block_id, &mode); + if (status != XRFDC_SUCCESS) return 0; + return mode; +} + +u32 XrfdcRemote::SetCalibrationMode(u32 tile_id, u32 block_id, uint8_t mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetCalibrationMode) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetCalibrationMode(rfdc_inst_, tile_id, block_id, mode); +} + +u32 XrfdcRemote::GetFabRdVldWords(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetFabRdVldWords) return 0; + u32 words = 0; + u32 status = lib_manager_.XRFdc_GetFabRdVldWords(rfdc_inst_, tile_type, tile_id, block_id, &words); + if (status != XRFDC_SUCCESS) return 0; + return words; +} + +u32 XrfdcRemote::SetFabRdVldWords(u32 tile_type, u32 tile_id, u32 block_id, u32 words) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetFabRdVldWords) return XRFDC_FAILURE; + (void)tile_type; + return lib_manager_.XRFdc_SetFabRdVldWords(rfdc_inst_, tile_id, block_id, words); +} + +u32 XrfdcRemote::GetFabWrVldWords(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetFabWrVldWords) return 0; + u32 words = 0; + u32 status = lib_manager_.XRFdc_GetFabWrVldWords(rfdc_inst_, tile_type, tile_id, block_id, &words); + if (status != XRFDC_SUCCESS) return 0; + return words; +} + +u32 XrfdcRemote::SetFabWrVldWords(u32 tile_type, u32 tile_id, u32 block_id, u32 words) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetFabWrVldWords) return XRFDC_FAILURE; + (void)tile_type; + return lib_manager_.XRFdc_SetFabWrVldWords(rfdc_inst_, tile_id, block_id, words); +} + +u32 XrfdcRemote::GetDither(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetDither) return 0; + u32 mode = 0; + u32 status = lib_manager_.XRFdc_GetDither(rfdc_inst_, tile_id, block_id, &mode); + if (status != XRFDC_SUCCESS) return 0; + return mode; +} + +u32 XrfdcRemote::SetDither(u32 tile_id, u32 block_id, u32 mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDither) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDither(rfdc_inst_, tile_id, block_id, mode); +} + +// DAC-specific methods +u32 XrfdcRemote::GetDecoderMode(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetDecoderMode) return 0; + u32 mode = 0; + u32 status = lib_manager_.XRFdc_GetDecoderMode(rfdc_inst_, tile_id, block_id, &mode); + if (status != XRFDC_SUCCESS) return 0; + return mode; +} + +u32 XrfdcRemote::SetDecoderMode(u32 tile_id, u32 block_id, u32 mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDecoderMode) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDecoderMode(rfdc_inst_, tile_id, block_id, mode); +} + +u32 XrfdcRemote::GetOutputCurr(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetOutputCurr) return 0; + u32 curr = 0; + u32 status = lib_manager_.XRFdc_GetOutputCurr(rfdc_inst_, tile_id, block_id, &curr); + if (status != XRFDC_SUCCESS) return 0; + return curr; +} + +uint16_t XrfdcRemote::GetInvSincFIR(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetInvSincFIR) return 0; + uint16_t mode = 0; + u32 status = lib_manager_.XRFdc_GetInvSincFIR(rfdc_inst_, tile_id, block_id, &mode); + if (status != XRFDC_SUCCESS) return 0; + return mode; +} + +u32 XrfdcRemote::SetInvSincFIR(u32 tile_id, u32 block_id, uint16_t mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetInvSincFIR) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetInvSincFIR(rfdc_inst_, tile_id, block_id, mode); +} + +u32 XrfdcRemote::GetDataPathMode(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetDataPathMode) return 0; + u32 mode = 0; + u32 status = lib_manager_.XRFdc_GetDataPathMode(rfdc_inst_, tile_id, block_id, &mode); + if (status != XRFDC_SUCCESS) return 0; + return mode; +} + +u32 XrfdcRemote::SetDataPathMode(u32 tile_id, u32 block_id, u32 mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDataPathMode) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDataPathMode(rfdc_inst_, tile_id, block_id, mode); +} + +u32 XrfdcRemote::GetIMRPassMode(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetIMRPassMode) return 0; + u32 mode = 0; + u32 status = lib_manager_.XRFdc_GetIMRPassMode(rfdc_inst_, tile_id, block_id, &mode); + if (status != XRFDC_SUCCESS) return 0; + return mode; +} + +u32 XrfdcRemote::SetIMRPassMode(u32 tile_id, u32 block_id, u32 mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetIMRPassMode) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetIMRPassMode(rfdc_inst_, tile_id, block_id, mode); +} + +u32 XrfdcRemote::GetDACCompMode(u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetDACCompMode) return 0; + u32 enabled = 0; + u32 status = lib_manager_.XRFdc_GetDACCompMode(rfdc_inst_, tile_id, block_id, &enabled); + if (status != XRFDC_SUCCESS) return 0; + return enabled; +} + +u32 XrfdcRemote::SetDACCompMode(u32 tile_id, u32 block_id, u32 mode) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDACCompMode) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDACCompMode(rfdc_inst_, tile_id, block_id, mode); +} + +u32 XrfdcRemote::SetDACVOP(u32 tile_id, u32 block_id, u32 uACurrent) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDACVOP) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDACVOP(rfdc_inst_, tile_id, block_id, uACurrent); +} + +u32 XrfdcRemote::SetupFIFOObs(u32 tile_type, u32 tile_id, uint8_t enable) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetupFIFOObs) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetupFIFOObs(rfdc_inst_, tile_type, tile_id, enable); +} + +u32 XrfdcRemote::SetupFIFOBoth(u32 tile_type, u32 tile_id, uint8_t enable) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetupFIFOBoth) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetupFIFOBoth(rfdc_inst_, tile_type, tile_id, enable); +} + +u32 XrfdcRemote::GetFIFOStatusObs(u32 tile_type, u32 tile_id, uint8_t* enable) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetFIFOStatusObs || !enable) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetFIFOStatusObs(rfdc_inst_, tile_type, tile_id, enable); +} + +// ============================================================================ +// Missing Methods Implementation +// ============================================================================ + +u32 XrfdcRemote::GetPLLConfig(u32 tile_type, u32 tile_id, XRFdc_PLL_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetPLLConfig || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetPLLConfig(rfdc_inst_, tile_type, tile_id, settings); +} + +u32 XrfdcRemote::GetCoarseDelaySettings(u32 tile_type, u32 tile_id, u32 block_id, XRFdc_CoarseDelay_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetCoarseDelaySettings || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetCoarseDelaySettings(rfdc_inst_, tile_type, tile_id, block_id, settings); +} + +u32 XrfdcRemote::SetCoarseDelaySettings(u32 tile_type, u32 tile_id, u32 block_id, const XRFdc_CoarseDelay_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetCoarseDelaySettings || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetCoarseDelaySettings(rfdc_inst_, tile_type, tile_id, block_id, const_cast(settings)); +} + +u32 XrfdcRemote::GetPwrMode(u32 tile_type, u32 tile_id, u32 block_id, XRFdc_Pwr_Mode_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetPwrMode || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetPwrMode(rfdc_inst_, tile_type, tile_id, block_id, settings); +} + +u32 XrfdcRemote::SetPwrMode(u32 tile_type, u32 tile_id, u32 block_id, const XRFdc_Pwr_Mode_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetPwrMode || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetPwrMode(rfdc_inst_, tile_type, tile_id, block_id, const_cast(settings)); +} + +u32 XrfdcRemote::GetDecimationFactorObs(u32 tile_id, u32 block_id, u32* dec_factor) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetDecimationFactorObs || !dec_factor) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetDecimationFactorObs(rfdc_inst_, tile_id, block_id, dec_factor); +} + +u32 XrfdcRemote::SetDecimationFactorObs(u32 tile_id, u32 block_id, u32 dec_factor) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDecimationFactorObs) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDecimationFactorObs(rfdc_inst_, tile_id, block_id, dec_factor); +} + +u32 XrfdcRemote::GetFabRdVldWordsObs(u32 tile_type, u32 tile_id, u32 block_id, u32* words) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetFabRdVldWordsObs || !words) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetFabRdVldWordsObs(rfdc_inst_, tile_type, tile_id, block_id, words); +} + +u32 XrfdcRemote::SetFabRdVldWordsObs(u32 tile_type, u32 tile_id, u32 block_id, u32 words) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetFabRdVldWordsObs) return XRFDC_FAILURE; + (void)tile_type; + return lib_manager_.XRFdc_SetFabRdVldWordsObs(rfdc_inst_, tile_id, block_id, words); +} + +u32 XrfdcRemote::GetFabWrVldWordsObs(u32 tile_type, u32 tile_id, u32 block_id, u32* words) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetFabWrVldWordsObs || !words) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetFabWrVldWordsObs(rfdc_inst_, tile_type, tile_id, block_id, words); +} + +u32 XrfdcRemote::GetCalFreeze(u32 tile_id, u32 block_id, XRFdc_Cal_Freeze_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetCalFreeze || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetCalFreeze(rfdc_inst_, tile_id, block_id, settings); +} + +u32 XrfdcRemote::SetCalFreeze(u32 tile_id, u32 block_id, const XRFdc_Cal_Freeze_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetCalFreeze || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetCalFreeze(rfdc_inst_, tile_id, block_id, const_cast(settings)); +} + +u32 XrfdcRemote::GetDSA(u32 tile_id, u32 block_id, XRFdc_DSA_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetDSA || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetDSA(rfdc_inst_, tile_id, block_id, settings); +} + +u32 XrfdcRemote::SetDSA(u32 tile_id, u32 block_id, const XRFdc_DSA_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetDSA || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetDSA(rfdc_inst_, tile_id, block_id, const_cast(settings)); +} + +u32 XrfdcRemote::DisableCoefficientsOverride(u32 tile_id, u32 block_id, u32 calibration_block) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_DisableCoefficientsOverride) return XRFDC_FAILURE; + return lib_manager_.XRFdc_DisableCoefficientsOverride(rfdc_inst_, tile_id, block_id, calibration_block); +} + +u32 XrfdcRemote::ResetInternalFIFOWidthObs(u32 tile_type, u32 tile_id, u32 block_id) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_ResetInternalFIFOWidthObs) return XRFDC_FAILURE; + (void)tile_type; + return lib_manager_.XRFdc_ResetInternalFIFOWidthObs(rfdc_inst_, tile_id, block_id); +} + +u32 XrfdcRemote::SetCalCoefficients(u32 tile_id, u32 block_id, u32 calibration_block, const XRFdc_Calibration_Coefficients* coeffs) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetCalCoefficients || !coeffs) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetCalCoefficients(rfdc_inst_, tile_id, block_id, calibration_block, const_cast(coeffs)); +} + +u32 XrfdcRemote::GetCalCoefficients(u32 tile_id, u32 block_id, u32 calibration_block, XRFdc_Calibration_Coefficients* coeffs) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetCalCoefficients || !coeffs) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetCalCoefficients(rfdc_inst_, tile_id, block_id, calibration_block, coeffs); +} + +u32 XrfdcRemote::GetClkDistribution(XRFdc_Distribution_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_GetClkDistribution || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_GetClkDistribution(rfdc_inst_, settings); +} + +u32 XrfdcRemote::SetClkDistribution(const XRFdc_Distribution_Settings* settings) { + if (!rfdc_inst_ || !lib_manager_.XRFdc_SetClkDistribution || !settings) return XRFDC_FAILURE; + return lib_manager_.XRFdc_SetClkDistribution(rfdc_inst_, const_cast(settings)); +} + +// ============================================================================ +// Enhanced Error Handling +// ============================================================================ + +void XrfdcRemote::PopulateStatus(xrfdc::Status* status, + const std::string& operation, + uint32_t code, + uint32_t tile_type, + int32_t tile_id, + int32_t block_id) { + status->set_code(code); + status->set_operation(operation); + status->set_tile_type_name(TileTypeName(tile_type)); + status->set_tile_id(tile_id); + status->set_block_id(block_id); + + // Build message only on failure to avoid unnecessary allocation + if (code == 0) { + status->set_message("OK"); + } else { + status->set_message(FormatXrfdcError(operation, code, tile_type, + tile_id, block_id)); + } +} + +using grpc::ServerContext; +using xrfdc::CfgInitializeRequest; +using xrfdc::CfgInitializeResponse; +using xrfdc::GetIPStatusRequest; +using xrfdc::GetIPStatusResponse; +using xrfdc::TileControlRequest; +using xrfdc::TileControlResponse; +using xrfdc::SetupFIFORequest; +using xrfdc::DynamicPLLConfigRequest; +using xrfdc::GetFabRdVldWordsResponse; +using xrfdc::GetFabWrVldWordsResponse; +using xrfdc::GetDitherResponse; +using xrfdc::GetDecoderModeResponse; +using xrfdc::GetOutputCurrResponse; +using xrfdc::GetInvSincFIRResponse; +using xrfdc::GetDataPathModeResponse; +using xrfdc::GetIMRPassModeResponse; +using xrfdc::GetDACCompModeResponse; + + +XrfdcImpl::XrfdcImpl() : initialized_(false), rfdc_remote_(std::make_unique<::XrfdcRemote>()) { + #ifdef DEBUG + std::cout << "XrfdcImpl: Service created" << std::endl; + #endif + } + +XrfdcImpl::~XrfdcImpl() { + #ifdef DEBUG + std::cout << "XrfdcImpl: Service destroyed" << std::endl; + #endif + } + +void XrfdcImpl::invalidate() { + std::lock_guard lk(mu_); + initialized_ = false; + if (rfdc_remote_) { + rfdc_remote_->Invalidate(); + } +} + + /** + * @brief Initialize the RFDC hardware. + * + * @param context gRPC server context + * @param request Configuration request containing complete RFdcConfig + * @param response Status response + * @return grpc::Status indicating success or failure + */ +grpc::Status XrfdcImpl::CfgInitialize(ServerContext* context, + const CfgInitializeRequest* request, + CfgInitializeResponse* response) { + std::lock_guard lk(mu_); + + #ifdef DEBUG + std::cout << "CfgInitialize RPC called" << std::endl; + #endif + + try { + // Validate that config is provided + if (!request->has_config()) { + throw std::runtime_error("RFdcConfig is required in CfgInitializeRequest"); + } + + // Pass the entire request (includes config and size) to CfgInitialize + initialized_ = false; + rfdc_remote_->CfgInitialize(*request); + initialized_ = true; + + auto* status = response->mutable_status(); + status->set_code(0); + status->set_message("RFDC initialized successfully"); + + #ifdef DEBUG + std::cout << "CfgInitialize RPC completed successfully" << std::endl; + #endif + return grpc::Status::OK; + + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("Initialization failed: ") + e.what()); + + std::cerr << "CfgInitialize RPC failed: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + /** + * @brief Get comprehensive IP status including all tiles and blocks. + * + * @param context gRPC server context + * @param request Status request (empty) + * @param response Status response with complete IP status + * @return grpc::Status indicating success or failure + */ +grpc::Status XrfdcImpl::GetIPStatus(ServerContext* context, + const GetIPStatusRequest* request, + GetIPStatusResponse* response) { + std::lock_guard lk(mu_); + + #ifdef DEBUG + std::cout << "GetIPStatus RPC called" << std::endl; + #endif + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, + "RFDC not initialized"); + } + + try { + // Get IP status from hardware + xrfdc::IPStatus ip_status = rfdc_remote_->GetIPStatus(); + + // Copy to response + response->mutable_ip_status()->CopyFrom(ip_status); + + // Set success status + auto* status = response->mutable_status(); + status->set_code(0); + status->set_message("IP status retrieved successfully"); + + #ifdef DEBUG + std::cout << "GetIPStatus RPC completed successfully" << std::endl; + #endif + return grpc::Status::OK; + + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("Failed to get IP status: ") + e.what()); + + std::cerr << "GetIPStatus RPC failed: " << e.what() << std::endl; + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + /** + * @brief Start up a tile. + */ +grpc::Status XrfdcImpl::StartUp(ServerContext* context, + const TileControlRequest* request, + TileControlResponse* response) { + std::lock_guard lk(mu_); + + #ifdef DEBUG + std::cout << "StartUp RPC called: type=" << request->tile_type() + << " id=" << request->tile_id() << std::endl; + #endif + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, + "RFDC not initialized"); + } + + try { + int ret = rfdc_remote_->StartUp(request->tile_type(), request->tile_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "StartUp", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation, no block_id + ); + + return grpc::Status::OK; + + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("StartUp failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + /** + * @brief Shut down a tile. + */ +grpc::Status XrfdcImpl::Shutdown(ServerContext* context, + const TileControlRequest* request, + TileControlResponse* response) { + std::lock_guard lk(mu_); + + #ifdef DEBUG + std::cout << "Shutdown RPC called: type=" << request->tile_type() + << " id=" << request->tile_id() << std::endl; + #endif + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, + "RFDC not initialized"); + } + + try { + int ret = rfdc_remote_->Shutdown(request->tile_type(), request->tile_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "Shutdown", + ret, + request->tile_type(), + request->tile_id(), + -1 + ); + + return grpc::Status::OK; + + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("Shutdown failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + /** + * @brief Reset a tile. + */ +grpc::Status XrfdcImpl::Reset(ServerContext* context, + const TileControlRequest* request, + TileControlResponse* response) { + std::lock_guard lk(mu_); + + #ifdef DEBUG + std::cout << "Reset RPC called: type=" << request->tile_type() + << " id=" << request->tile_id() << std::endl; + #endif + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, + "RFDC not initialized"); + } + + try { + int ret = rfdc_remote_->Reset(request->tile_type(), request->tile_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "Reset", + ret, + request->tile_type(), + request->tile_id(), + -1 + ); + + return grpc::Status::OK; + + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("Reset failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + /** + * @brief Setup FIFO for a tile. + */ +grpc::Status XrfdcImpl::SetupFIFO(ServerContext* context, + const SetupFIFORequest* request, + TileControlResponse* response) { + std::lock_guard lk(mu_); + + #ifdef DEBUG + std::cout << "SetupFIFO RPC called: type=" << request->tile_type() + << " id=" << request->tile_id() << " enable=" << request->enable() + << std::endl; + #endif + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, + "RFDC not initialized"); + } + + try { + int ret = rfdc_remote_->SetupFIFO(request->tile_type(), request->tile_id(), + request->enable()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetupFIFO", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + return grpc::Status::OK; + + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetupFIFO failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + /** + * @brief Configure PLL dynamically. + */ +grpc::Status XrfdcImpl::DynamicPLLConfig(ServerContext* context, + const DynamicPLLConfigRequest* request, + TileControlResponse* response) { + std::lock_guard lk(mu_); + +#ifdef DEBUG + std::cerr << "[XRFDC] DynamicPLLConfig called: tile_type=" << request->tile_type() + << " tile_id=" << request->tile_id() << " source=" << request->source() + << " ref_clk=" << request->ref_clk_freq() << " MHz" + << " samp_rate=" << request->samp_rate() << " MSPS" << std::endl; +#endif + + if (!initialized_) { +#ifdef DEBUG + std::cerr << "[XRFDC] ERROR: RFDC not initialized!" << std::endl; +#endif + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, + "RFDC not initialized"); + } + + try { + int ret = rfdc_remote_->DynamicPLLConfig(request->tile_type(), + request->tile_id(), + request->source(), + request->ref_clk_freq(), + request->samp_rate()); + +#ifdef DEBUG + std::cerr << "[XRFDC] DynamicPLLConfig returned: " << ret + << (ret == 0 ? " (SUCCESS)" : " (FAILED)") << std::endl; +#endif + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "DynamicPLLConfig", + ret, + request->tile_type(), + request->tile_id(), + -1 + ); + + return grpc::Status::OK; + + } catch (const std::exception& e) { +#ifdef DEBUG + std::cerr << "[XRFDC] DynamicPLLConfig exception: " << e.what() << std::endl; +#endif + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("DynamicPLLConfig failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetBlockStatus(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetBlockStatusResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_BlockStatus c_status; + memset(&c_status, 0, sizeof(XRFdc_BlockStatus)); + int ret = rfdc_remote_->GetBlockStatus(request->tile_type(), request->tile_id(), + request->block_id(), &c_status); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetBlockStatus", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + if (ret == 0) { + response->set_sampling_freq(c_status.SamplingFreq); + response->set_analog_data_path_status(c_status.AnalogDataPathStatus); + response->set_digital_data_path_status(c_status.DigitalDataPathStatus); + response->set_data_path_clocks_status(c_status.DataPathClocksStatus); + response->set_is_fifo_flags_enabled(c_status.IsFIFOFlagsEnabled); + response->set_is_fifo_flags_asserted(c_status.IsFIFOFlagsAsserted); + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetBlockStatus failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFIFOStatus(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::GetFIFOStatusResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + bool enable = false; + int ret = rfdc_remote_->GetFIFOStatus(request->tile_type(), request->tile_id(), 0, &enable); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFIFOStatus", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + response->set_enable(enable); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFIFOStatus failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetPLLLockStatus(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::GetPLLLockStatusResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t lock_status = 0; + int ret = rfdc_remote_->GetPLLLockStatus(request->tile_type(), request->tile_id(), &lock_status); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetPLLLockStatus", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + response->set_lock_status(lock_status); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetPLLLockStatus failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetClockSource(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::GetClockSourceResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t clock_source = 0; + int ret = rfdc_remote_->GetClockSource(request->tile_type(), request->tile_id(), &clock_source); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetClockSource", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + response->set_clock_source(clock_source); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetClockSource failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetFabClkOutDiv(ServerContext* context, + const xrfdc::SetFabClkOutDivRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetFabClkOutDiv(request->tile_type(), request->tile_id(), request->fab_clk_div()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetFabClkOutDiv", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetFabClkOutDiv failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFabClkOutDiv(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::GetFabClkOutDivResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t div = 0; + int ret = rfdc_remote_->GetFabClkOutDiv(request->tile_type(), request->tile_id(), &div); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFabClkOutDiv", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + response->set_fab_clk_div(div); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFabClkOutDiv failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetMixerSettings(ServerContext* context, + const xrfdc::SetMixerSettingsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + std::cerr << "[XRFDC] SetMixerSettings called: tile_type=" << request->tile_type() + << " tile_id=" << request->tile_id() << " block_id=" << request->block_id() << std::endl; + std::cerr << "[XRFDC] Settings: freq=" << request->settings().freq() + << " phase_offset=" << request->settings().phase_offset() + << " event_source=" << request->settings().event_source() + << " coarse_mix_freq=" << request->settings().coarse_mix_freq() + << " mixer_mode=" << request->settings().mixer_mode() + << " fine_mixer_scale=" << request->settings().fine_mixer_scale() + << " mixer_type=" << request->settings().mixer_type() << std::endl; + + if (!initialized_) { + std::cerr << "[XRFDC] ERROR: RFDC not initialized!" << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetMixerSettings(request->tile_type(), request->tile_id(), + request->block_id(), request->settings()); + std::cerr << "[XRFDC] SetMixerSettings returned: " << ret + << (ret == 0 ? " (SUCCESS)" : " (FAILED)") << std::endl; + + // Use helper to populate status with full context + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetMixerSettings", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + std::cerr << "[XRFDC] SetMixerSettings exception: " << e.what() << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetMixerSettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetMixerSettings(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetMixerSettingsResponse* response) { + std::lock_guard lk(mu_); + + std::cerr << "[XRFDC] GetMixerSettings called: tile_type=" << request->tile_type() + << " tile_id=" << request->tile_id() << " block_id=" << request->block_id() << std::endl; + + if (!initialized_) { + std::cerr << "[XRFDC] ERROR: RFDC not initialized!" << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->GetMixerSettings(request->tile_type(), request->tile_id(), + request->block_id(), response->mutable_settings()); + std::cerr << "[XRFDC] GetMixerSettings returned: " << ret + << (ret == 0 ? " (SUCCESS)" : " (FAILED)") << std::endl; + if (ret == 0) { + const auto& settings = response->settings(); + std::cerr << "[XRFDC] Retrieved: freq=" << settings.freq() + << " phase_offset=" << settings.phase_offset() + << " event_source=" << settings.event_source() + << " coarse_mix_freq=" << settings.coarse_mix_freq() + << " mixer_mode=" << settings.mixer_mode() + << " fine_mixer_scale=" << settings.fine_mixer_scale() + << " mixer_type=" << settings.mixer_type() << std::endl; + } + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetMixerSettings", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + std::cerr << "[XRFDC] GetMixerSettings exception: " << e.what() << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetMixerSettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::ResetNCOPhase(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->ResetNCOPhase(request->tile_type(), request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "ResetNCOPhase", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("ResetNCOPhase failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetNyquistZone(ServerContext* context, + const xrfdc::SetNyquistZoneRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetNyquistZone(request->tile_type(), request->tile_id(), + request->block_id(), request->nyquist_zone()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetNyquistZone", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetNyquistZone failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetNyquistZone(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetNyquistZoneResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t zone = 0; + int ret = rfdc_remote_->GetNyquistZone(request->tile_type(), request->tile_id(), request->block_id(), &zone); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetNyquistZone", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_nyquist_zone(zone); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetNyquistZone failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetInterpolationFactor(ServerContext* context, + const xrfdc::SetInterpolationFactorRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetInterpolationFactor(request->tile_id(), request->block_id(), request->interp_factor()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetInterpolationFactor", + ret, + XRFDC_DAC_TILE, // Interpolation is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetInterpolationFactor failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetInterpolationFactor(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetInterpolationFactorResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t factor = 0; + int ret = rfdc_remote_->GetInterpolationFactor(request->tile_id(), request->block_id(), &factor); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetInterpolationFactor", + ret, + XRFDC_DAC_TILE, // Interpolation is DAC-only + request->tile_id(), + request->block_id() + ); + + response->set_interp_factor(factor); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetInterpolationFactor failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDecimationFactor(ServerContext* context, + const xrfdc::SetDecimationFactorRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetDecimationFactor(request->tile_id(), request->block_id(), request->dec_factor()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDecimationFactor", + ret, + XRFDC_ADC_TILE, // Decimation is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDecimationFactor failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDecimationFactor(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDecimationFactorResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t factor = 0; + int ret = rfdc_remote_->GetDecimationFactor(request->tile_id(), request->block_id(), &factor); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDecimationFactor", + ret, + XRFDC_ADC_TILE, // Decimation is ADC-only + request->tile_id(), + request->block_id() + ); + + response->set_dec_factor(factor); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDecimationFactor failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetQMCSettings(ServerContext* context, + const xrfdc::SetQMCSettingsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetQMCSettings(request->tile_type(), request->tile_id(), + request->block_id(), request->settings()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetQMCSettings", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetQMCSettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetQMCSettings(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetQMCSettingsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->GetQMCSettings(request->tile_type(), request->tile_id(), + request->block_id(), response->mutable_settings()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetQMCSettings", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetQMCSettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetThresholdSettings(ServerContext* context, + const xrfdc::SetThresholdSettingsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->SetThresholdSettings(request->tile_id(), request->block_id(), request->settings()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetThresholdSettings", + ret, + XRFDC_ADC_TILE, // Threshold is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetThresholdSettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetThresholdSettings(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetThresholdSettingsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->GetThresholdSettings(request->tile_id(), request->block_id(), + response->mutable_settings()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetThresholdSettings", + ret, + XRFDC_ADC_TILE, // Threshold is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetThresholdSettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + // ======================================================================== + // Additional RPC Handlers + // ======================================================================== + +grpc::Status XrfdcImpl::SetThresholdClrMode(ServerContext* context, + const xrfdc::SetThresholdClrModeRequest* request, + xrfdc::SetThresholdClrModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetThresholdClrMode(request->tile_id(), request->block_id(), + request->threshold_to_update(), request->clr_mode()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetThresholdClrMode", + ret, + XRFDC_ADC_TILE, // Threshold is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetThresholdClrMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::ThresholdStickyClear(ServerContext* context, + const xrfdc::ThresholdStickyClearRequest* request, + xrfdc::ThresholdStickyClearResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int ret = rfdc_remote_->ThresholdStickyClear(request->tile_id(), request->block_id(), + request->threshold_to_update()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "ThresholdStickyClear", + ret, + XRFDC_ADC_TILE, // Threshold is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("ThresholdStickyClear failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetEnabledInterrupts(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetEnabledInterruptsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t interrupts = rfdc_remote_->GetEnabledInterrupts(request->tile_type(), + request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetEnabledInterrupts", + 0, // GetEnabledInterrupts doesn't return error code + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(interrupts); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetEnabledInterrupts failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::UpdateEvent(ServerContext* context, + const xrfdc::UpdateEventRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + std::cerr << "[XRFDC] UpdateEvent called: tile_type=" << request->tile_type() + << " tile_id=" << request->tile_id() << " block_id=" << request->block_id() + << " event=" << request->event() << std::endl; + + if (!initialized_) { + std::cerr << "[XRFDC] ERROR: RFDC not initialized!" << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->UpdateEvent(request->tile_type(), request->tile_id(), + request->block_id(), request->event()); + std::cerr << "[XRFDC] UpdateEvent returned: " << ret + << (ret == 0 ? " (SUCCESS)" : " (FAILED)") << std::endl; + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "UpdateEvent", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + std::cerr << "[XRFDC] UpdateEvent exception: " << e.what() << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("UpdateEvent failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::ResetInternalFIFOWidth(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->ResetInternalFIFOWidth(request->tile_type(), request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "ResetInternalFIFOWidth", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("ResetInternalFIFOWidth failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetConnectedIData(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetConnectedDataResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int value = rfdc_remote_->GetConnectedIData(request->tile_type(), request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetConnectedIData", + 0, // GetConnectedIData doesn't return error code + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(value); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetConnectedIData failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetConnectedQData(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetConnectedDataResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int value = rfdc_remote_->GetConnectedQData(request->tile_type(), request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetConnectedQData", + 0, // GetConnectedQData doesn't return error code + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(value); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetConnectedQData failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetCalibrationMode(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetCalibrationModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint8_t mode = rfdc_remote_->GetCalibrationMode(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetCalibrationMode", + 0, // GetCalibrationMode doesn't return error code + XRFDC_ADC_TILE, // Calibration is ADC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(mode); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetCalibrationMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetCalibrationMode(ServerContext* context, + const xrfdc::SetCalibrationModeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetCalibrationMode(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetCalibrationMode", + ret, + XRFDC_ADC_TILE, // Calibration is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetCalibrationMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFabRdVldWords(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetFabRdVldWordsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t words = rfdc_remote_->GetFabRdVldWords(request->tile_type(), request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFabRdVldWords", + 0, // GetFabRdVldWords doesn't return error code + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(words); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFabRdVldWords failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetFabRdVldWords(ServerContext* context, + const xrfdc::SetFabRdVldWordsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetFabRdVldWords(XRFDC_ADC_TILE, request->tile_id(), + request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetFabRdVldWords", + ret, + XRFDC_ADC_TILE, // FabRdVldWords is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetFabRdVldWords failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFabWrVldWords(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetFabWrVldWordsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t words = rfdc_remote_->GetFabWrVldWords(request->tile_type(), request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFabWrVldWords", + 0, // GetFabWrVldWords doesn't return error code + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(words); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFabWrVldWords failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetFabWrVldWords(ServerContext* context, + const xrfdc::SetFabWrVldWordsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetFabWrVldWords(XRFDC_DAC_TILE, request->tile_id(), + request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetFabWrVldWords", + ret, + XRFDC_DAC_TILE, // FabWrVldWords is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetFabWrVldWords failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDither(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDitherResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t dither = rfdc_remote_->GetDither(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDither", + 0, // GetDither doesn't return error code + XRFDC_DAC_TILE, // Dither is DAC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(dither); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDither failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDither(ServerContext* context, + const xrfdc::SetDitherRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetDither(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDither", + ret, + XRFDC_DAC_TILE, // Dither is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDither failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDecoderMode(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDecoderModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t mode = rfdc_remote_->GetDecoderMode(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDecoderMode", + 0, // GetDecoderMode doesn't return error code + XRFDC_ADC_TILE, // Decoder is ADC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(mode); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDecoderMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDecoderMode(ServerContext* context, + const xrfdc::SetDecoderModeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetDecoderMode(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDecoderMode", + ret, + XRFDC_ADC_TILE, // Decoder is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDecoderMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetOutputCurr(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetOutputCurrResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + int current = rfdc_remote_->GetOutputCurr(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetOutputCurr", + 0, // GetOutputCurr doesn't return error code + XRFDC_DAC_TILE, // Output current is DAC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(current); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetOutputCurr failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetInvSincFIR(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetInvSincFIRResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint16_t mode = rfdc_remote_->GetInvSincFIR(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetInvSincFIR", + 0, // GetInvSincFIR doesn't return error code + XRFDC_DAC_TILE, // InvSincFIR is DAC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(mode); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetInvSincFIR failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetInvSincFIR(ServerContext* context, + const xrfdc::SetInvSincFIRRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetInvSincFIR(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetInvSincFIR", + ret, + XRFDC_DAC_TILE, // InvSincFIR is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetInvSincFIR failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDataPathMode(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDataPathModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t mode = rfdc_remote_->GetDataPathMode(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDataPathMode", + 0, // GetDataPathMode doesn't return error code + XRFDC_ADC_TILE, // DataPathMode is ADC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(mode); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDataPathMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDataPathMode(ServerContext* context, + const xrfdc::SetDataPathModeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetDataPathMode(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDataPathMode", + ret, + XRFDC_ADC_TILE, // DataPathMode is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDataPathMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetIMRPassMode(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetIMRPassModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t mode = rfdc_remote_->GetIMRPassMode(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetIMRPassMode", + 0, // GetIMRPassMode doesn't return error code + XRFDC_ADC_TILE, // IMRPassMode is ADC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(mode); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetIMRPassMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetIMRPassMode(ServerContext* context, + const xrfdc::SetIMRPassModeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetIMRPassMode(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetIMRPassMode", + ret, + XRFDC_ADC_TILE, // IMRPassMode is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetIMRPassMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDACCompMode(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDACCompModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t mode = rfdc_remote_->GetDACCompMode(request->tile_id(), request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDACCompMode", + 0, // GetDACCompMode doesn't return error code + XRFDC_DAC_TILE, // DACCompMode is DAC-only + request->tile_id(), + request->block_id() + ); + + response->set_value(mode); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDACCompMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDACCompMode(ServerContext* context, + const xrfdc::SetDACCompModeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetDACCompMode(request->tile_id(), request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDACCompMode", + ret, + XRFDC_DAC_TILE, // DACCompMode is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDACCompMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDACVOP(ServerContext* context, + const xrfdc::SetDACVOPRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetDACVOP(request->tile_id(), request->block_id(), request->ua_current()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDACVOP", + ret, + XRFDC_DAC_TILE, // DACVOP is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDACVOP failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::DumpRegs(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + rfdc_remote_->DumpRegs(request->tile_type(), request->tile_id()); + auto* status = response->mutable_status(); + status->set_code(0); + status->set_message("Registers dumped successfully"); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("DumpRegs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetupFIFOObs(ServerContext* context, + const xrfdc::SetupFIFORequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetupFIFOObs(request->tile_type(), request->tile_id(), request->enable() ? 1 : 0); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetupFIFOObs", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetupFIFOObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetupFIFOBoth(ServerContext* context, + const xrfdc::SetupFIFORequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetupFIFOBoth(request->tile_type(), request->tile_id(), request->enable() ? 1 : 0); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetupFIFOBoth", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetupFIFOBoth failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFIFOStatusObs(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::GetFIFOStatusResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint8_t enable = 0; + u32 ret = rfdc_remote_->GetFIFOStatusObs(request->tile_type(), request->tile_id(), &enable); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFIFOStatusObs", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + response->set_enable(enable != 0); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFIFOStatusObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + + // ============================================================================ + // Missing gRPC Service Method Implementations + // ============================================================================ + +grpc::Status XrfdcImpl::GetPLLConfig(ServerContext* context, + const xrfdc::TileRequest* request, + xrfdc::GetPLLConfigResponse* response) { + std::lock_guard lk(mu_); + + std::cerr << "[XRFDC] GetPLLConfig called: tile_type=" << request->tile_type() + << " tile_id=" << request->tile_id() << std::endl; + + if (!initialized_) { + std::cerr << "[XRFDC] ERROR: RFDC not initialized!" << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_PLL_Settings pll_settings; + u32 ret = rfdc_remote_->GetPLLConfig(request->tile_type(), request->tile_id(), &pll_settings); + std::cerr << "[XRFDC] GetPLLConfig returned: " << ret + << (ret == 0 ? " (SUCCESS)" : " (FAILED)") << std::endl; + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetPLLConfig", + ret, + request->tile_type(), + request->tile_id(), + -1 // Tile-level operation + ); + + if (ret == 0) { + auto* settings = response->mutable_settings(); + settings->set_enabled(pll_settings.Enabled); + settings->set_ref_clk_freq(pll_settings.RefClkFreq); + settings->set_sample_rate(pll_settings.SampleRate); + settings->set_ref_clk_divider(pll_settings.RefClkDivider); + settings->set_feedback_divider(pll_settings.FeedbackDivider); + settings->set_output_divider(pll_settings.OutputDivider); + settings->set_fractional_mode(pll_settings.FractionalMode); + settings->set_fractional_data(pll_settings.FractionalData); + settings->set_fract_width(pll_settings.FractWidth); + + std::cerr << "[XRFDC] PLL Settings: enabled=" << pll_settings.Enabled + << " ref_clk=" << pll_settings.RefClkFreq << " MHz" + << " sample_rate=" << pll_settings.SampleRate << " MSPS" + << " ref_div=" << pll_settings.RefClkDivider + << " fb_div=" << pll_settings.FeedbackDivider + << " out_div=" << pll_settings.OutputDivider << std::endl; + } + return grpc::Status::OK; + } catch (const std::exception& e) { + std::cerr << "[XRFDC] GetPLLConfig exception: " << e.what() << std::endl; + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetPLLConfig failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetCoarseDelaySettings(ServerContext* context, + const xrfdc::GetCoarseDelaySettingsRequest* request, + xrfdc::GetCoarseDelaySettingsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_CoarseDelay_Settings settings; + u32 ret = rfdc_remote_->GetCoarseDelaySettings(request->tile_type(), request->tile_id(), + request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetCoarseDelaySettings", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + if (ret == 0) { + auto* delay_settings = response->mutable_settings(); + delay_settings->set_coarse_delay(settings.CoarseDelay); + delay_settings->set_event_source(settings.EventSource); + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetCoarseDelaySettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetCoarseDelaySettings(ServerContext* context, + const xrfdc::SetCoarseDelaySettingsRequest* request, + xrfdc::SetCoarseDelaySettingsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_CoarseDelay_Settings settings; + settings.CoarseDelay = request->settings().coarse_delay(); + settings.EventSource = request->settings().event_source(); + u32 ret = rfdc_remote_->SetCoarseDelaySettings(request->tile_type(), request->tile_id(), + request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetCoarseDelaySettings", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetCoarseDelaySettings failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetPwrMode(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetPwrModeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Pwr_Mode_Settings settings; + u32 ret = rfdc_remote_->GetPwrMode(request->tile_type(), request->tile_id(), + request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetPwrMode", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + if (ret == 0) { + auto* pwr_settings = response->mutable_settings(); + pwr_settings->set_disable_ip_control(settings.DisableIPControl); + pwr_settings->set_pwr_mode(settings.PwrMode); + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetPwrMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetPwrMode(ServerContext* context, + const xrfdc::SetPwrModeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Pwr_Mode_Settings settings; + settings.DisableIPControl = request->settings().disable_ip_control(); + settings.PwrMode = request->settings().pwr_mode(); + u32 ret = rfdc_remote_->SetPwrMode(request->tile_type(), request->tile_id(), + request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetPwrMode", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetPwrMode failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDecimationFactorObs(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDecimationFactorResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t dec_factor = 0; + u32 ret = rfdc_remote_->GetDecimationFactorObs(request->tile_id(), request->block_id(), &dec_factor); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDecimationFactorObs", + ret, + XRFDC_ADC_TILE, // Obs decimation is ADC-only + request->tile_id(), + request->block_id() + ); + + response->set_dec_factor(dec_factor); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDecimationFactorObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDecimationFactorObs(ServerContext* context, + const xrfdc::SetDecimationFactorRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetDecimationFactorObs(request->tile_id(), request->block_id(), + request->dec_factor()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDecimationFactorObs", + ret, + XRFDC_ADC_TILE, // Obs decimation is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDecimationFactorObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFabRdVldWordsObs(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetFabRdVldWordsObsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t words = 0; + u32 ret = rfdc_remote_->GetFabRdVldWordsObs(request->tile_type(), request->tile_id(), + request->block_id(), &words); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFabRdVldWordsObs", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(words); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFabRdVldWordsObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetFabRdVldWordsObs(ServerContext* context, + const xrfdc::SetFabRdVldWordsObsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->SetFabRdVldWordsObs(XRFDC_ADC_TILE, request->tile_id(), + request->block_id(), request->value()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetFabRdVldWordsObs", + ret, + XRFDC_ADC_TILE, // Obs is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetFabRdVldWordsObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetFabWrVldWordsObs(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetFabWrVldWordsObsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + uint32_t words = 0; + u32 ret = rfdc_remote_->GetFabWrVldWordsObs(request->tile_type(), request->tile_id(), + request->block_id(), &words); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetFabWrVldWordsObs", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + response->set_value(words); + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetFabWrVldWordsObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetCalFreeze(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetCalFreezeResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Cal_Freeze_Settings settings; + u32 ret = rfdc_remote_->GetCalFreeze(request->tile_id(), request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetCalFreeze", + ret, + XRFDC_ADC_TILE, // CalFreeze is ADC-only + request->tile_id(), + request->block_id() + ); + + if (ret == 0) { + auto* freeze_settings = response->mutable_settings(); + freeze_settings->set_cal_frozen(settings.CalFrozen); + freeze_settings->set_disable_freeze_pin(settings.DisableFreezePin); + freeze_settings->set_freeze_calibration(settings.FreezeCalibration); + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetCalFreeze failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetCalFreeze(ServerContext* context, + const xrfdc::SetCalFreezeRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Cal_Freeze_Settings settings; + settings.CalFrozen = request->settings().cal_frozen(); + settings.DisableFreezePin = request->settings().disable_freeze_pin(); + settings.FreezeCalibration = request->settings().freeze_calibration(); + u32 ret = rfdc_remote_->SetCalFreeze(request->tile_id(), request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetCalFreeze", + ret, + XRFDC_ADC_TILE, // CalFreeze is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetCalFreeze failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetDSA(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::GetDSAResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_DSA_Settings settings; + u32 ret = rfdc_remote_->GetDSA(request->tile_id(), request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetDSA", + ret, + XRFDC_DAC_TILE, // DSA is DAC-only + request->tile_id(), + request->block_id() + ); + + if (ret == 0) { + auto* dsa_settings = response->mutable_settings(); + dsa_settings->set_disable_rts(settings.DisableRTS); + dsa_settings->set_attenuation(settings.Attenuation); + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetDSA failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetDSA(ServerContext* context, + const xrfdc::SetDSARequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_DSA_Settings settings; + settings.DisableRTS = request->settings().disable_rts(); + settings.Attenuation = request->settings().attenuation(); + u32 ret = rfdc_remote_->SetDSA(request->tile_id(), request->block_id(), &settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetDSA", + ret, + XRFDC_DAC_TILE, // DSA is DAC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetDSA failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::DisableCoefficientsOverride(ServerContext* context, + const xrfdc::DisableCoefficientsOverrideRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->DisableCoefficientsOverride(request->tile_id(), request->block_id(), + request->calibration_block()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "DisableCoefficientsOverride", + ret, + XRFDC_ADC_TILE, // Coefficients are ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("DisableCoefficientsOverride failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::ResetInternalFIFOWidthObs(ServerContext* context, + const xrfdc::BlockRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + u32 ret = rfdc_remote_->ResetInternalFIFOWidthObs(request->tile_type(), request->tile_id(), + request->block_id()); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "ResetInternalFIFOWidthObs", + ret, + request->tile_type(), + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("ResetInternalFIFOWidthObs failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetCalCoefficients(ServerContext* context, + const xrfdc::SetCalCoefficientsRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Calibration_Coefficients coeffs; + coeffs.Coeff0 = request->coeffs().coeff0(); + coeffs.Coeff1 = request->coeffs().coeff1(); + coeffs.Coeff2 = request->coeffs().coeff2(); + coeffs.Coeff3 = request->coeffs().coeff3(); + coeffs.Coeff4 = request->coeffs().coeff4(); + coeffs.Coeff5 = request->coeffs().coeff5(); + coeffs.Coeff6 = request->coeffs().coeff6(); + coeffs.Coeff7 = request->coeffs().coeff7(); + u32 ret = rfdc_remote_->SetCalCoefficients(request->tile_id(), request->block_id(), + request->calibration_block(), &coeffs); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetCalCoefficients", + ret, + XRFDC_ADC_TILE, // Calibration is ADC-only + request->tile_id(), + request->block_id() + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetCalCoefficients failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetCalCoefficients(ServerContext* context, + const xrfdc::GetCalCoefficientsRequest* request, + xrfdc::GetCalCoefficientsResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Calibration_Coefficients coeffs; + u32 ret = rfdc_remote_->GetCalCoefficients(request->tile_id(), request->block_id(), + request->calibration_block(), &coeffs); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetCalCoefficients", + ret, + XRFDC_ADC_TILE, // Calibration is ADC-only + request->tile_id(), + request->block_id() + ); + + if (ret == 0) { + auto* cal_coeffs = response->mutable_coeffs(); + cal_coeffs->set_coeff0(coeffs.Coeff0); + cal_coeffs->set_coeff1(coeffs.Coeff1); + cal_coeffs->set_coeff2(coeffs.Coeff2); + cal_coeffs->set_coeff3(coeffs.Coeff3); + cal_coeffs->set_coeff4(coeffs.Coeff4); + cal_coeffs->set_coeff5(coeffs.Coeff5); + cal_coeffs->set_coeff6(coeffs.Coeff6); + cal_coeffs->set_coeff7(coeffs.Coeff7); + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetCalCoefficients failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::GetClkDistribution(ServerContext* context, + const xrfdc::GetClkDistributionRequest* request, + xrfdc::GetClkDistributionResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Distribution_Settings settings; + u32 ret = rfdc_remote_->GetClkDistribution(&settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "GetClkDistribution", + ret, + 0, // IP-wide operation + -1, // No tile + -1 // No block + ); + + if (ret == 0) { + auto* dist_settings = response->mutable_settings(); + // Populate DAC tile settings + for (int i = 0; i < 4; i++) { + auto* dac_tile = dist_settings->add_dac(); + const auto& dac_clk = settings.Info.ClkSettings[XRFDC_DAC_TILE][i]; + dac_tile->set_source_type(dac_clk.SourceType); + dac_tile->set_source_tile(dac_clk.SourceTile); + dac_tile->set_pll_enable(dac_clk.PLLEnable); + dac_tile->set_ref_clk_freq(dac_clk.RefClkFreq); + dac_tile->set_sample_rate(dac_clk.SampleRate); + dac_tile->set_division_factor(dac_clk.DivisionFactor); + dac_tile->set_delay(dac_clk.Delay); + dac_tile->set_distributed_clock(dac_clk.DistributedClock); + } + // Populate ADC tile settings + for (int i = 0; i < 4; i++) { + auto* adc_tile = dist_settings->add_adc(); + const auto& adc_clk = settings.Info.ClkSettings[XRFDC_ADC_TILE][i]; + adc_tile->set_source_type(adc_clk.SourceType); + adc_tile->set_source_tile(adc_clk.SourceTile); + adc_tile->set_pll_enable(adc_clk.PLLEnable); + adc_tile->set_ref_clk_freq(adc_clk.RefClkFreq); + adc_tile->set_sample_rate(adc_clk.SampleRate); + adc_tile->set_division_factor(adc_clk.DivisionFactor); + adc_tile->set_delay(adc_clk.Delay); + adc_tile->set_distributed_clock(adc_clk.DistributedClock); + } + // Populate distribution status + { + auto* dist_status = dist_settings->mutable_distribution_info(); + const auto& dist_info = settings.Info; + dist_status->set_source(dist_info.Source); + dist_status->set_upper_bound(dist_info.UpperBound); + dist_status->set_lower_bound(dist_info.LowerBound); + dist_status->set_max_delay(dist_info.MaxDelay); + dist_status->set_min_delay(dist_info.MinDelay); + dist_status->set_is_delay_balanced(dist_info.IsDelayBalanced); + } + } + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("GetClkDistribution failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } + +grpc::Status XrfdcImpl::SetClkDistribution(ServerContext* context, + const xrfdc::SetClkDistributionRequest* request, + xrfdc::TileControlResponse* response) { + std::lock_guard lk(mu_); + + if (!initialized_) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message("RFDC not initialized. Call CfgInitialize first."); + return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "RFDC not initialized"); + } + try { + XRFdc_Distribution_Settings settings; + memset(&settings, 0, sizeof(settings)); + + // Populate DAC tile settings from request + for (int i = 0; i < 4 && i < request->settings().dac_size(); i++) { + const auto& dac = request->settings().dac(i); + auto& dac_clk = settings.Info.ClkSettings[XRFDC_DAC_TILE][i]; + dac_clk.SourceType = dac.source_type(); + dac_clk.SourceTile = dac.source_tile(); + dac_clk.PLLEnable = dac.pll_enable(); + dac_clk.DivisionFactor = dac.division_factor(); + dac_clk.Delay = dac.delay(); + dac_clk.DistributedClock = dac.distributed_clock(); + dac_clk.RefClkFreq = dac.ref_clk_freq(); + dac_clk.SampleRate = dac.sample_rate(); + } + // Populate ADC tile settings from request + for (int i = 0; i < 4 && i < request->settings().adc_size(); i++) { + const auto& adc = request->settings().adc(i); + auto& adc_clk = settings.Info.ClkSettings[XRFDC_ADC_TILE][i]; + adc_clk.SourceType = adc.source_type(); + adc_clk.SourceTile = adc.source_tile(); + adc_clk.PLLEnable = adc.pll_enable(); + adc_clk.DivisionFactor = adc.division_factor(); + adc_clk.Delay = adc.delay(); + adc_clk.DistributedClock = adc.distributed_clock(); + adc_clk.RefClkFreq = adc.ref_clk_freq(); + adc_clk.SampleRate = adc.sample_rate(); + } + + // Populate distribution status from request + const auto& dist = request->settings().distribution_info(); + auto& dist_info = settings.Info; + dist_info.Source = dist.source(); + dist_info.UpperBound = dist.upper_bound(); + dist_info.LowerBound = dist.lower_bound(); + dist_info.MaxDelay = dist.max_delay(); + dist_info.MinDelay = dist.min_delay(); + dist_info.IsDelayBalanced = dist.is_delay_balanced(); + + u32 ret = rfdc_remote_->SetClkDistribution(&settings); + + rfdc_remote_->PopulateStatus( + response->mutable_status(), + "SetClkDistribution", + ret, + 0, // IP-wide operation + -1, // No tile + -1 // No block + ); + + return grpc::Status::OK; + } catch (const std::exception& e) { + auto* status = response->mutable_status(); + status->set_code(1); + status->set_message(std::string("SetClkDistribution failed: ") + e.what()); + return grpc::Status(grpc::StatusCode::INTERNAL, e.what()); + } + } diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.h b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.h new file mode 100644 index 000000000..c91eff8f5 --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/cpp/xrfdc.h @@ -0,0 +1,563 @@ +#ifndef XRFDC_H +#define XRFDC_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +// Include XRFdc C API headers +extern "C" { + #include // Xilinx C library header from librfdc.so + #include +} + +class libxrfdcManager +{ +private: + void* handle_; +public: + + libxrfdcManager(); + ~libxrfdcManager(); + + // Load and unload the shared library + void loadLibrary(); + void unloadLibrary(); + + // Function pointers for XRFdc C API functions + typedef XRFdc_Config* (*XRFdc_LookupConfig_t)(u16 DeviceId); + typedef u32 (*XRFdc_CfgInitialize_t)(XRFdc* InstancePtr, XRFdc_Config* ConfigPtr); + typedef u32 (*XRFdc_GetIPStatus_t)(XRFdc* InstancePtr, XRFdc_IPStatus* StatusPtr); + typedef u32 (*XRFdc_GetBlockStatus_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_BlockStatus* BlockStatusPtr); + typedef u32 (*XRFdc_StartUp_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id); + typedef u32 (*XRFdc_Shutdown_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id); + typedef u32 (*XRFdc_Reset_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id); + typedef u32 (*XRFdc_SetupFIFO_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id, u8 Enable); + typedef u32 (*XRFdc_DynamicPLLConfig_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u8 Source, double RefClkFreq, double SamplingRate); + typedef u32 (*XRFdc_GetFIFOStatus_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u8* EnablePtr); + typedef u32 (*XRFdc_GetPLLLockStatus_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32* LockStatusPtr); + typedef u32 (*XRFdc_GetClockSource_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32* ClockSourcePtr); + typedef u32 (*XRFdc_SetFabClkOutDiv_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u16 FabClkDiv); + typedef u32 (*XRFdc_GetFabClkOutDiv_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u16* FabClkDivPtr); + typedef u32 (*XRFdc_SetMixerSettings_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_Mixer_Settings* MixerSettingsPtr); + typedef u32 (*XRFdc_GetMixerSettings_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_Mixer_Settings* MixerSettingsPtr); + typedef u32 (*XRFdc_ResetNCOPhase_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id); + typedef u32 (*XRFdc_SetNyquistZone_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32 NyquistZone); + typedef u32 (*XRFdc_GetNyquistZone_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32* NyquistZonePtr); + typedef u32 (*XRFdc_SetInterpolationFactor_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 InterpolationFactor); + typedef u32 (*XRFdc_GetInterpolationFactor_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* InterpolationFactorPtr); + typedef u32 (*XRFdc_SetDecimationFactor_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 DecimationFactor); + typedef u32 (*XRFdc_GetDecimationFactor_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* DecimationFactorPtr); + typedef u32 (*XRFdc_SetQMCSettings_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_QMC_Settings* QMCSettingsPtr); + typedef u32 (*XRFdc_GetQMCSettings_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_QMC_Settings* QMCSettingsPtr); + typedef u32 (*XRFdc_SetThresholdSettings_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, XRFdc_Threshold_Settings* ThresholdSettingsPtr); + typedef u32 (*XRFdc_GetThresholdSettings_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, XRFdc_Threshold_Settings* ThresholdSettingsPtr); + typedef u32 (*XRFdc_SetThresholdClrMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 ThresholdToUpdate, u32 ClrMode); + typedef u32 (*XRFdc_ThresholdStickyClear_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 ThresholdToUpdate); + typedef u32 (*XRFdc_GetCoarseDelaySettings_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_CoarseDelay_Settings* CoarseDelaySettingsPtr); + typedef u32 (*XRFdc_SetCoarseDelaySettings_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_CoarseDelay_Settings* CoarseDelaySettingsPtr); + typedef u32 (*XRFdc_GetEnabledInterrupts_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32* IntrMask); + typedef u32 (*XRFdc_GetPwrMode_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_Pwr_Mode_Settings* SettingsPtr); + typedef u32 (*XRFdc_SetPwrMode_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, XRFdc_Pwr_Mode_Settings* SettingsPtr); + typedef u32 (*XRFdc_UpdateEvent_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32 Event); + typedef u32 (*XRFdc_ResetInternalFIFOWidth_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id); + typedef int (*XRFdc_GetConnectedIData_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id); + typedef int (*XRFdc_GetConnectedQData_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id); + typedef u32 (*XRFdc_GetCalibrationMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u8* CalibrationModePtr); + typedef u32 (*XRFdc_SetCalibrationMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u8 CalibrationMode); + typedef u32 (*XRFdc_GetFabRdVldWords_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32* FabricDataRatePtr); + typedef u32 (*XRFdc_SetFabRdVldWords_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 FabricRdVldWords); + typedef u32 (*XRFdc_GetFabWrVldWords_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32* FabricDataRatePtr); + typedef u32 (*XRFdc_SetFabWrVldWords_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 FabricWrVldWords); + typedef u32 (*XRFdc_GetDecimationFactorObs_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* DecimationFactorPtr); + typedef u32 (*XRFdc_SetDecimationFactorObs_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 DecimationFactor); + typedef u32 (*XRFdc_GetFabRdVldWordsObs_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32* FabricDataRatePtr); + typedef u32 (*XRFdc_SetFabRdVldWordsObs_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 FabricRdVldWords); + typedef u32 (*XRFdc_GetFabWrVldWordsObs_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u32 Block_Id, u32* FabricDataRatePtr); + typedef u32 (*XRFdc_GetDither_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* ModePtr); + typedef u32 (*XRFdc_SetDither_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 Mode); + typedef u32 (*XRFdc_GetCalFreeze_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, XRFdc_Cal_Freeze_Settings* SettingsPtr); + typedef u32 (*XRFdc_SetCalFreeze_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, XRFdc_Cal_Freeze_Settings* SettingsPtr); + typedef u32 (*XRFdc_GetDSA_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, XRFdc_DSA_Settings* SettingsPtr); + typedef u32 (*XRFdc_SetDSA_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, XRFdc_DSA_Settings* SettingsPtr); + typedef u32 (*XRFdc_DisableCoefficientsOverride_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 CalibrationBlock); + typedef u32 (*XRFdc_ResetInternalFIFOWidthObs_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id); + typedef u32 (*XRFdc_SetCalCoefficients_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 CalibrationBlock, XRFdc_Calibration_Coefficients* CoeffPtr); + typedef u32 (*XRFdc_GetCalCoefficients_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 CalibrationBlock, XRFdc_Calibration_Coefficients* CoeffPtr); + typedef u32 (*XRFdc_GetDecoderMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* DecoderModePtr); + typedef u32 (*XRFdc_SetDecoderMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 DecoderMode); + typedef u32 (*XRFdc_GetOutputCurr_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* OutputCurrPtr); + typedef u32 (*XRFdc_GetInvSincFIR_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u16* ModePtr); + typedef u32 (*XRFdc_SetInvSincFIR_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u16 Mode); + typedef u32 (*XRFdc_GetDataPathMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* ModePtr); + typedef u32 (*XRFdc_SetDataPathMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 Mode); + typedef u32 (*XRFdc_GetIMRPassMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* ModePtr); + typedef u32 (*XRFdc_SetIMRPassMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 Mode); + typedef u32 (*XRFdc_GetDACCompMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32* EnabledPtr); + typedef u32 (*XRFdc_SetDACCompMode_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 Mode); + typedef u32 (*XRFdc_SetDACVOP_t)(XRFdc* InstancePtr, u32 Tile_Id, u32 Block_Id, u32 uACurrent); + typedef void (*XRFdc_DumpRegs_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id); + typedef u32 (*XRFdc_GetPLLConfig_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, XRFdc_PLL_Settings* SettingsPtr); + typedef u32 (*XRFdc_SetupFIFOObs_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id, u8 Enable); + typedef u32 (*XRFdc_SetupFIFOBoth_t)(XRFdc* InstancePtr, u32 Type, int Tile_Id, u8 Enable); + typedef u32 (*XRFdc_GetFIFOStatusObs_t)(XRFdc* InstancePtr, u32 Type, u32 Tile_Id, u8* EnablePtr); + typedef u32 (*XRFdc_GetClkDistribution_t)(XRFdc* InstancePtr, XRFdc_Distribution_Settings* DistributionSettingsPtr); + typedef u32 (*XRFdc_SetClkDistribution_t)(XRFdc* InstancePtr, XRFdc_Distribution_Settings* DistributionSettingsPtr); + + XRFdc_LookupConfig_t XRFdc_LookupConfig; + XRFdc_CfgInitialize_t XRFdc_CfgInitialize; + XRFdc_GetIPStatus_t XRFdc_GetIPStatus; + XRFdc_GetBlockStatus_t XRFdc_GetBlockStatus; + XRFdc_StartUp_t XRFdc_StartUp; + XRFdc_Shutdown_t XRFdc_Shutdown; + XRFdc_Reset_t XRFdc_Reset; + XRFdc_SetupFIFO_t XRFdc_SetupFIFO; + XRFdc_DynamicPLLConfig_t XRFdc_DynamicPLLConfig; + XRFdc_GetFIFOStatus_t XRFdc_GetFIFOStatus; + XRFdc_GetPLLLockStatus_t XRFdc_GetPLLLockStatus; + XRFdc_GetClockSource_t XRFdc_GetClockSource; + XRFdc_SetFabClkOutDiv_t XRFdc_SetFabClkOutDiv; + XRFdc_GetFabClkOutDiv_t XRFdc_GetFabClkOutDiv; + XRFdc_SetMixerSettings_t XRFdc_SetMixerSettings; + XRFdc_GetMixerSettings_t XRFdc_GetMixerSettings; + XRFdc_ResetNCOPhase_t XRFdc_ResetNCOPhase; + XRFdc_SetNyquistZone_t XRFdc_SetNyquistZone; + XRFdc_GetNyquistZone_t XRFdc_GetNyquistZone; + XRFdc_SetInterpolationFactor_t XRFdc_SetInterpolationFactor; + XRFdc_GetInterpolationFactor_t XRFdc_GetInterpolationFactor; + XRFdc_SetDecimationFactor_t XRFdc_SetDecimationFactor; + XRFdc_GetDecimationFactor_t XRFdc_GetDecimationFactor; + XRFdc_SetQMCSettings_t XRFdc_SetQMCSettings; + XRFdc_GetQMCSettings_t XRFdc_GetQMCSettings; + XRFdc_SetThresholdSettings_t XRFdc_SetThresholdSettings; + XRFdc_GetThresholdSettings_t XRFdc_GetThresholdSettings; + XRFdc_SetThresholdClrMode_t XRFdc_SetThresholdClrMode; + XRFdc_ThresholdStickyClear_t XRFdc_ThresholdStickyClear; + XRFdc_GetCoarseDelaySettings_t XRFdc_GetCoarseDelaySettings; + XRFdc_SetCoarseDelaySettings_t XRFdc_SetCoarseDelaySettings; + XRFdc_GetEnabledInterrupts_t XRFdc_GetEnabledInterrupts; + XRFdc_GetPwrMode_t XRFdc_GetPwrMode; + XRFdc_SetPwrMode_t XRFdc_SetPwrMode; + XRFdc_UpdateEvent_t XRFdc_UpdateEvent; + XRFdc_ResetInternalFIFOWidth_t XRFdc_ResetInternalFIFOWidth; + XRFdc_GetConnectedIData_t XRFdc_GetConnectedIData; + XRFdc_GetConnectedQData_t XRFdc_GetConnectedQData; + XRFdc_GetCalibrationMode_t XRFdc_GetCalibrationMode; + XRFdc_SetCalibrationMode_t XRFdc_SetCalibrationMode; + XRFdc_GetFabRdVldWords_t XRFdc_GetFabRdVldWords; + XRFdc_SetFabRdVldWords_t XRFdc_SetFabRdVldWords; + XRFdc_GetFabWrVldWords_t XRFdc_GetFabWrVldWords; + XRFdc_SetFabWrVldWords_t XRFdc_SetFabWrVldWords; + XRFdc_GetDecimationFactorObs_t XRFdc_GetDecimationFactorObs; + XRFdc_SetDecimationFactorObs_t XRFdc_SetDecimationFactorObs; + XRFdc_GetFabRdVldWordsObs_t XRFdc_GetFabRdVldWordsObs; + XRFdc_SetFabRdVldWordsObs_t XRFdc_SetFabRdVldWordsObs; + XRFdc_GetFabWrVldWordsObs_t XRFdc_GetFabWrVldWordsObs; + XRFdc_GetDither_t XRFdc_GetDither; + XRFdc_SetDither_t XRFdc_SetDither; + XRFdc_GetCalFreeze_t XRFdc_GetCalFreeze; + XRFdc_SetCalFreeze_t XRFdc_SetCalFreeze; + XRFdc_GetDSA_t XRFdc_GetDSA; + XRFdc_SetDSA_t XRFdc_SetDSA; + XRFdc_DisableCoefficientsOverride_t XRFdc_DisableCoefficientsOverride; + XRFdc_ResetInternalFIFOWidthObs_t XRFdc_ResetInternalFIFOWidthObs; + XRFdc_SetCalCoefficients_t XRFdc_SetCalCoefficients; + XRFdc_GetCalCoefficients_t XRFdc_GetCalCoefficients; + XRFdc_GetDecoderMode_t XRFdc_GetDecoderMode; + XRFdc_SetDecoderMode_t XRFdc_SetDecoderMode; + XRFdc_GetOutputCurr_t XRFdc_GetOutputCurr; + XRFdc_GetInvSincFIR_t XRFdc_GetInvSincFIR; + XRFdc_SetInvSincFIR_t XRFdc_SetInvSincFIR; + XRFdc_GetDataPathMode_t XRFdc_GetDataPathMode; + XRFdc_SetDataPathMode_t XRFdc_SetDataPathMode; + XRFdc_GetIMRPassMode_t XRFdc_GetIMRPassMode; + XRFdc_SetIMRPassMode_t XRFdc_SetIMRPassMode; + XRFdc_GetDACCompMode_t XRFdc_GetDACCompMode; + XRFdc_SetDACCompMode_t XRFdc_SetDACCompMode; + XRFdc_SetDACVOP_t XRFdc_SetDACVOP; + XRFdc_DumpRegs_t XRFdc_DumpRegs; + XRFdc_GetPLLConfig_t XRFdc_GetPLLConfig; + XRFdc_SetupFIFOObs_t XRFdc_SetupFIFOObs; + XRFdc_SetupFIFOBoth_t XRFdc_SetupFIFOBoth; + XRFdc_GetFIFOStatusObs_t XRFdc_GetFIFOStatusObs; + XRFdc_GetClkDistribution_t XRFdc_GetClkDistribution; + XRFdc_SetClkDistribution_t XRFdc_SetClkDistribution; +}; + +// ============================================================================ +// Error Code Translation +// ============================================================================ + +/** + * @brief Map XRFdc error code to human-readable message + * + * The Xilinx XRFdc driver only defines two return codes: + * - 0 = XRFDC_SUCCESS + * - 1 = XRFDC_FAILURE + */ +inline std::string XrfdcErrorToString(uint32_t code) { + switch (code) { + case 0: return "Success"; + case 1: return "Operation failed (XRFDC_FAILURE)"; + default: return "Unknown error code: " + std::to_string(code); + } +} + +/** + * @brief Get human-readable tile type name + */ +inline std::string TileTypeName(uint32_t tile_type) { + return (tile_type == 0) ? "ADC" : (tile_type == 1) ? "DAC" : "Unknown"; +} + +/** + * @brief Format complete error message with context + */ +inline std::string FormatXrfdcError(const std::string& operation, + uint32_t code, + uint32_t tile_type, + int32_t tile_id, + int32_t block_id = -1) { + std::ostringstream oss; + oss << operation << " failed on " << TileTypeName(tile_type) + << " Tile " << tile_id; + + if (block_id >= 0) { + oss << " Block " << block_id; + } + + oss << ": " << XrfdcErrorToString(code) << " (code: " << code << ")"; + return oss.str(); +} + +/** + * @class XrfdcRemote + * @brief gRPC service implementation for Xilinx RF Data Converter. + * + * This class implements the Xrfdc service defined in xrfdc.proto, + * providing remote access to the XRFdc C API via gRPC. + */ +class XrfdcRemote +{ +private: + XRFdc* rfdc_inst_; + XRFdc_Config* config_; + libxrfdcManager lib_manager_; + uint16_t device_id_; + struct metal_io_region* io_; + int mem_fd_; + void* mapped_base_; + size_t mapped_size_; // Store size for cleanup + + // Helper methods + void cleanup(); + struct metal_io_region* create_io_region_from_devmem(void *virt_addr, uint64_t phys_addr, size_t size); + XRFdc_Config* ConvertProtoToConfig(const xrfdc::RFdcConfig& proto_config); + void ConvertBlockStatus(const XRFdc_BlockStatus& c_block, xrfdc::BlockStatus* proto_block); + void ConvertTileStatus(const XRFdc_TileStatus& c_tile, xrfdc::TileStatus* proto_tile, + u32 tile_type, u32 tile_id); + void ConvertIPStatus(const XRFdc_IPStatus& c_status, xrfdc::IPStatus* proto_status); + +public: + /** + * @brief Constructor for XrfdcRemote. + */ + XrfdcRemote(); + + /** + * @brief Destructor for XrfdcRemote. + */ + ~XrfdcRemote(); + + /** + * @brief Populate Status message with comprehensive error details + * + * @param status Protobuf Status message to populate + * @param operation Operation name (e.g., "SetMixerSettings") + * @param code XRFdc C API return code (0 = success) + * @param tile_type Tile type (XRFDC_ADC_TILE=0 or XRFDC_DAC_TILE=1) + * @param tile_id Tile index (0-3), use -1 if N/A + * @param block_id Block index (0-3), use -1 if tile-level operation + */ + void PopulateStatus(xrfdc::Status* status, + const std::string& operation, + uint32_t code, + uint32_t tile_type, + int32_t tile_id, + int32_t block_id = -1); + + /** + * @brief Initialize the RFDC with the given configuration. + * @param request CfgInitializeRequest containing config and memory size + */ + void CfgInitialize(const xrfdc::CfgInitializeRequest& request); + + /** + * @brief Get the current IP status including all tile and block details. + * @return IPStatus protobuf message + */ + xrfdc::IPStatus GetIPStatus(); + + /** + * @brief Start up a tile. + * @param tile_type Type of tile (XRFDC_ADC_TILE or XRFDC_DAC_TILE) + * @param tile_id Tile index (0-3) + * @return Status code (0 = success) + */ + int StartUp(u32 tile_type, u32 tile_id); + + /** + * @brief Shut down a tile. + * @param tile_type Type of tile (XRFDC_ADC_TILE or XRFDC_DAC_TILE) + * @param tile_id Tile index (0-3) + * @return Status code (0 = success) + */ + int Shutdown(u32 tile_type, u32 tile_id); + + /** + * @brief Reset a tile. + * @param tile_type Type of tile (XRFDC_ADC_TILE or XRFDC_DAC_TILE) + * @param tile_id Tile index (0-3) + * @return Status code (0 = success) + */ + int Reset(u32 tile_type, u32 tile_id); + + /** + * @brief Setup FIFO for a tile. + * @param tile_type Type of tile (XRFDC_ADC_TILE or XRFDC_DAC_TILE) + * @param tile_id Tile index (0-3) + * @param enable true to enable FIFO, false to disable + * @return Status code (0 = success) + */ + int SetupFIFO(u32 tile_type, u32 tile_id, bool enable); + + /** + * @brief Configure PLL dynamically. + * @param tile_type Type of tile (XRFDC_ADC_TILE or XRFDC_DAC_TILE) + * @param tile_id Tile index (0-3) + * @param source Clock source (0x1 = PLL, 0x2 = External) + * @param ref_clk_freq Reference clock frequency in MHz + * @param samp_rate Sampling rate in MSPS + * @return Status code (0 = success) + */ + int DynamicPLLConfig(u32 tile_type, u32 tile_id, u32 source, + double ref_clk_freq, double samp_rate); + + // Status/Monitoring Methods + int GetBlockStatus(u32 tile_type, u32 tile_id, u32 block_id, + XRFdc_BlockStatus* block_status); + int GetFIFOStatus(u32 tile_type, u32 tile_id, u32 block_id, bool* enable); + int GetPLLLockStatus(u32 tile_type, u32 tile_id, u32* lock_status); + int GetClockSource(u32 tile_type, u32 tile_id, u32* clock_source); + + // Clock Configuration Methods + int SetFabClkOutDiv(u32 tile_type, u32 tile_id, u32 fab_clk_div); + int GetFabClkOutDiv(u32 tile_type, u32 tile_id, u32* fab_clk_div); + + // Mixer Methods + int SetMixerSettings(u32 tile_type, u32 tile_id, u32 block_id, + const xrfdc::MixerSettings& settings); + int GetMixerSettings(u32 tile_type, u32 tile_id, u32 block_id, + xrfdc::MixerSettings* settings); + int ResetNCOPhase(u32 tile_type, u32 tile_id, u32 block_id); + + // Nyquist Zone Methods + int SetNyquistZone(u32 tile_type, u32 tile_id, u32 block_id, u32 nyquist_zone); + int GetNyquistZone(u32 tile_type, u32 tile_id, u32 block_id, u32* nyquist_zone); + + // Interpolation/Decimation Methods + int SetInterpolationFactor(u32 tile_id, u32 block_id, u32 interp_factor); + int GetInterpolationFactor(u32 tile_id, u32 block_id, u32* interp_factor); + int SetDecimationFactor(u32 tile_id, u32 block_id, u32 dec_factor); + int GetDecimationFactor(u32 tile_id, u32 block_id, u32* dec_factor); + + // QMC Methods + int SetQMCSettings(u32 tile_type, u32 tile_id, u32 block_id, + const xrfdc::QMCSettings& settings); + int GetQMCSettings(u32 tile_type, u32 tile_id, u32 block_id, + xrfdc::QMCSettings* settings); + + // Threshold Methods (ADC only) + int SetThresholdSettings(u32 tile_id, u32 block_id, + const xrfdc::ThresholdSettings& settings); + int GetThresholdSettings(u32 tile_id, u32 block_id, + xrfdc::ThresholdSettings* settings); + + u32 SetThresholdClrMode(u32 tile_id, u32 block_id, u32 threshold_to_update, u32 clr_mode); + u32 ThresholdStickyClear(u32 tile_id, u32 block_id, u32 threshold_to_update); + u32 GetEnabledInterrupts(u32 tile_type, u32 tile_id, u32 block_id); + u32 UpdateEvent(u32 tile_type, u32 tile_id, u32 block_id, u32 event); + u32 ResetInternalFIFOWidth(u32 tile_type, u32 tile_id, u32 block_id); + int GetConnectedIData(u32 tile_type, u32 tile_id, u32 block_id); + int GetConnectedQData(u32 tile_type, u32 tile_id, u32 block_id); + uint8_t GetCalibrationMode(u32 tile_id, u32 block_id); + u32 SetCalibrationMode(u32 tile_id, u32 block_id, uint8_t mode); + u32 GetFabRdVldWords(u32 tile_type, u32 tile_id, u32 block_id); + u32 SetFabRdVldWords(u32 tile_type, u32 tile_id, u32 block_id, u32 words); + u32 GetFabWrVldWords(u32 tile_type, u32 tile_id, u32 block_id); + u32 SetFabWrVldWords(u32 tile_type, u32 tile_id, u32 block_id, u32 words); + u32 GetDither(u32 tile_id, u32 block_id); + u32 SetDither(u32 tile_id, u32 block_id, u32 mode); + u32 GetDecoderMode(u32 tile_id, u32 block_id); + u32 SetDecoderMode(u32 tile_id, u32 block_id, u32 mode); + u32 GetOutputCurr(u32 tile_id, u32 block_id); + uint16_t GetInvSincFIR(u32 tile_id, u32 block_id); + u32 SetInvSincFIR(u32 tile_id, u32 block_id, uint16_t mode); + u32 GetDataPathMode(u32 tile_id, u32 block_id); + u32 SetDataPathMode(u32 tile_id, u32 block_id, u32 mode); + u32 GetIMRPassMode(u32 tile_id, u32 block_id); + u32 SetIMRPassMode(u32 tile_id, u32 block_id, u32 mode); + u32 GetDACCompMode(u32 tile_id, u32 block_id); + u32 SetDACCompMode(u32 tile_id, u32 block_id, u32 mode); + u32 SetDACVOP(u32 tile_id, u32 block_id, u32 uACurrent); + void DumpRegs(u32 tile_type, u32 tile_id); + u32 SetupFIFOObs(u32 tile_type, u32 tile_id, uint8_t enable); + u32 SetupFIFOBoth(u32 tile_type, u32 tile_id, uint8_t enable); + u32 GetFIFOStatusObs(u32 tile_type, u32 tile_id, uint8_t* enable); + + // Missing method declarations + u32 GetPLLConfig(u32 tile_type, u32 tile_id, XRFdc_PLL_Settings* settings); + u32 GetCoarseDelaySettings(u32 tile_type, u32 tile_id, u32 block_id, XRFdc_CoarseDelay_Settings* settings); + u32 SetCoarseDelaySettings(u32 tile_type, u32 tile_id, u32 block_id, const XRFdc_CoarseDelay_Settings* settings); + u32 GetPwrMode(u32 tile_type, u32 tile_id, u32 block_id, XRFdc_Pwr_Mode_Settings* settings); + u32 SetPwrMode(u32 tile_type, u32 tile_id, u32 block_id, const XRFdc_Pwr_Mode_Settings* settings); + u32 GetDecimationFactorObs(u32 tile_id, u32 block_id, u32* dec_factor); + u32 SetDecimationFactorObs(u32 tile_id, u32 block_id, u32 dec_factor); + u32 GetFabRdVldWordsObs(u32 tile_type, u32 tile_id, u32 block_id, u32* words); + u32 SetFabRdVldWordsObs(u32 tile_type, u32 tile_id, u32 block_id, u32 words); + u32 GetFabWrVldWordsObs(u32 tile_type, u32 tile_id, u32 block_id, u32* words); + u32 GetCalFreeze(u32 tile_id, u32 block_id, XRFdc_Cal_Freeze_Settings* settings); + u32 SetCalFreeze(u32 tile_id, u32 block_id, const XRFdc_Cal_Freeze_Settings* settings); + u32 GetDSA(u32 tile_id, u32 block_id, XRFdc_DSA_Settings* settings); + u32 SetDSA(u32 tile_id, u32 block_id, const XRFdc_DSA_Settings* settings); + u32 DisableCoefficientsOverride(u32 tile_id, u32 block_id, u32 calibration_block); + u32 ResetInternalFIFOWidthObs(u32 tile_type, u32 tile_id, u32 block_id); + u32 SetCalCoefficients(u32 tile_id, u32 block_id, u32 calibration_block, const XRFdc_Calibration_Coefficients* coeffs); + u32 GetCalCoefficients(u32 tile_id, u32 block_id, u32 calibration_block, XRFdc_Calibration_Coefficients* coeffs); + u32 GetClkDistribution(XRFdc_Distribution_Settings* settings); + u32 SetClkDistribution(const XRFdc_Distribution_Settings* settings); + + /** + * @brief Tear down the current RFDC mapping and instance. + * + * Frees rfdc_inst_, config_, io_, the mmap region and /dev/mem fd so the + * next CfgInitialize() call rebuilds against the freshly-loaded PL. + * Does not unload librfdc.so. + */ + void Invalidate(); +}; + +class XrfdcImpl final : public xrfdc::Xrfdc::Service +{ +private: + std::unique_ptr<::XrfdcRemote> rfdc_remote_; + bool initialized_; + std::mutex mu_; + +public: + XrfdcImpl(); + ~XrfdcImpl(); + + /** + * @brief Invalidate the current RFDC state after a bitstream reload. + * + * Called by the download RPC after the PL has been reprogrammed: drops + * the cached XRFdc instance (which was bound to the previous overlay's + * mapping) and clears initialized_ so the next service call returns + * FAILED_PRECONDITION until the client re-runs CfgInitialize. + */ + void invalidate(); + + grpc::Status CfgInitialize(grpc::ServerContext* context, const xrfdc::CfgInitializeRequest* request, xrfdc::CfgInitializeResponse* response) override; + grpc::Status GetIPStatus(grpc::ServerContext* context, const xrfdc::GetIPStatusRequest* request, xrfdc::GetIPStatusResponse* response) override; + grpc::Status StartUp(grpc::ServerContext* context, const xrfdc::TileControlRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status Shutdown(grpc::ServerContext* context, const xrfdc::TileControlRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status Reset(grpc::ServerContext* context, const xrfdc::TileControlRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status SetupFIFO(grpc::ServerContext* context, const xrfdc::SetupFIFORequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status DynamicPLLConfig(grpc::ServerContext* context, const xrfdc::DynamicPLLConfigRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetBlockStatus(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetBlockStatusResponse* response) override; + grpc::Status GetFIFOStatus(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::GetFIFOStatusResponse* response) override; + grpc::Status GetPLLLockStatus(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::GetPLLLockStatusResponse* response) override; + grpc::Status GetClockSource(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::GetClockSourceResponse* response) override; + grpc::Status SetFabClkOutDiv(grpc::ServerContext* context, const xrfdc::SetFabClkOutDivRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetFabClkOutDiv(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::GetFabClkOutDivResponse* response) override; + grpc::Status SetMixerSettings(grpc::ServerContext* context, const xrfdc::SetMixerSettingsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetMixerSettings(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetMixerSettingsResponse* response) override; + grpc::Status ResetNCOPhase(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status SetNyquistZone(grpc::ServerContext* context, const xrfdc::SetNyquistZoneRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetNyquistZone(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetNyquistZoneResponse* response) override; + grpc::Status SetInterpolationFactor(grpc::ServerContext* context, const xrfdc::SetInterpolationFactorRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetInterpolationFactor(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetInterpolationFactorResponse* response) override; + grpc::Status SetDecimationFactor(grpc::ServerContext* context, const xrfdc::SetDecimationFactorRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDecimationFactor(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDecimationFactorResponse* response) override; + grpc::Status SetQMCSettings(grpc::ServerContext* context, const xrfdc::SetQMCSettingsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetQMCSettings(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetQMCSettingsResponse* response) override; + grpc::Status SetThresholdSettings(grpc::ServerContext* context, const xrfdc::SetThresholdSettingsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetThresholdSettings(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetThresholdSettingsResponse* response) override; + grpc::Status SetThresholdClrMode(grpc::ServerContext* context, const xrfdc::SetThresholdClrModeRequest* request, xrfdc::SetThresholdClrModeResponse* response) override; + grpc::Status ThresholdStickyClear(grpc::ServerContext* context, const xrfdc::ThresholdStickyClearRequest* request, xrfdc::ThresholdStickyClearResponse* response) override; + grpc::Status GetEnabledInterrupts(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetEnabledInterruptsResponse* response) override; + grpc::Status UpdateEvent(grpc::ServerContext* context, const xrfdc::UpdateEventRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status ResetInternalFIFOWidth(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetConnectedIData(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetConnectedDataResponse* response) override; + grpc::Status GetConnectedQData(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetConnectedDataResponse* response) override; + grpc::Status GetCalibrationMode(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetCalibrationModeResponse* response) override; + grpc::Status SetCalibrationMode(grpc::ServerContext* context, const xrfdc::SetCalibrationModeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetFabRdVldWords(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetFabRdVldWordsResponse* response) override; + grpc::Status SetFabRdVldWords(grpc::ServerContext* context, const xrfdc::SetFabRdVldWordsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetFabWrVldWords(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetFabWrVldWordsResponse* response) override; + grpc::Status SetFabWrVldWords(grpc::ServerContext* context, const xrfdc::SetFabWrVldWordsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDither(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDitherResponse* response) override; + grpc::Status SetDither(grpc::ServerContext* context, const xrfdc::SetDitherRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDecoderMode(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDecoderModeResponse* response) override; + grpc::Status SetDecoderMode(grpc::ServerContext* context, const xrfdc::SetDecoderModeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetOutputCurr(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetOutputCurrResponse* response) override; + grpc::Status GetInvSincFIR(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetInvSincFIRResponse* response) override; + grpc::Status SetInvSincFIR(grpc::ServerContext* context, const xrfdc::SetInvSincFIRRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDataPathMode(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDataPathModeResponse* response) override; + grpc::Status SetDataPathMode(grpc::ServerContext* context, const xrfdc::SetDataPathModeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetIMRPassMode(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetIMRPassModeResponse* response) override; + grpc::Status SetIMRPassMode(grpc::ServerContext* context, const xrfdc::SetIMRPassModeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDACCompMode(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDACCompModeResponse* response) override; + grpc::Status SetDACCompMode(grpc::ServerContext* context, const xrfdc::SetDACCompModeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status SetDACVOP(grpc::ServerContext* context, const xrfdc::SetDACVOPRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status DumpRegs(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status SetupFIFOObs(grpc::ServerContext* context, const xrfdc::SetupFIFORequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status SetupFIFOBoth(grpc::ServerContext* context, const xrfdc::SetupFIFORequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetFIFOStatusObs(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::GetFIFOStatusResponse* response) override; + grpc::Status GetPLLConfig(grpc::ServerContext* context, const xrfdc::TileRequest* request, xrfdc::GetPLLConfigResponse* response) override; + grpc::Status GetCoarseDelaySettings(grpc::ServerContext* context, const xrfdc::GetCoarseDelaySettingsRequest* request, xrfdc::GetCoarseDelaySettingsResponse* response) override; + grpc::Status SetCoarseDelaySettings(grpc::ServerContext* context, const xrfdc::SetCoarseDelaySettingsRequest* request, xrfdc::SetCoarseDelaySettingsResponse* response) override; + grpc::Status GetPwrMode(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetPwrModeResponse* response) override; + grpc::Status SetPwrMode(grpc::ServerContext* context, const xrfdc::SetPwrModeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDecimationFactorObs(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDecimationFactorResponse* response) override; + grpc::Status SetDecimationFactorObs(grpc::ServerContext* context, const xrfdc::SetDecimationFactorRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetFabRdVldWordsObs(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetFabRdVldWordsObsResponse* response) override; + grpc::Status SetFabRdVldWordsObs(grpc::ServerContext* context, const xrfdc::SetFabRdVldWordsObsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetFabWrVldWordsObs(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetFabWrVldWordsObsResponse* response) override; + grpc::Status GetCalFreeze(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetCalFreezeResponse* response) override; + grpc::Status SetCalFreeze(grpc::ServerContext* context, const xrfdc::SetCalFreezeRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetDSA(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::GetDSAResponse* response) override; + grpc::Status SetDSA(grpc::ServerContext* context, const xrfdc::SetDSARequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status DisableCoefficientsOverride(grpc::ServerContext* context, const xrfdc::DisableCoefficientsOverrideRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status ResetInternalFIFOWidthObs(grpc::ServerContext* context, const xrfdc::BlockRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status SetCalCoefficients(grpc::ServerContext* context, const xrfdc::SetCalCoefficientsRequest* request, xrfdc::TileControlResponse* response) override; + grpc::Status GetCalCoefficients(grpc::ServerContext* context, const xrfdc::GetCalCoefficientsRequest* request, xrfdc::GetCalCoefficientsResponse* response) override; + grpc::Status GetClkDistribution(grpc::ServerContext* context, const xrfdc::GetClkDistributionRequest* request, xrfdc::GetClkDistributionResponse* response) override; + grpc::Status SetClkDistribution(grpc::ServerContext* context, const xrfdc::SetClkDistributionRequest* request, xrfdc::TileControlResponse* response) override; +}; + +#endif // XRFDC_H diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfclk.proto b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfclk.proto new file mode 100644 index 000000000..162b9abbe --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfclk.proto @@ -0,0 +1,47 @@ +syntax = "proto3"; + +package xrfclk; + +service Xrfclk{ + rpc find_devices (FindDevicesRequest) returns (FindDevicesResponse); + rpc write_lmk_regs (WriteLmkRegsRequest) returns (WriteLmkRegsResponse); + rpc write_lmx_regs (WriteLmxRegsRequest) returns (WriteLmxRegsResponse); + rpc program_lmk (ProgramLmkRequest) returns (ProgramLmkResponse); + rpc program_lmx (ProgramLmxRequest) returns (ProgramLmxResponse); +} + +message FindDevicesRequest { +} + +message FindDevicesResponse { + string lmk_device = 1; + string lmx_device = 2; +} + +message WriteLmkRegsRequest { + repeated uint32 reg_vals = 1; +} + +message WriteLmkRegsResponse { +} + +message WriteLmxRegsRequest { + repeated uint32 reg_vals = 1; +} + +message WriteLmxRegsResponse { +} + +message ProgramLmkRequest { + double freq = 1; +} + +message ProgramLmkResponse { +} + +message ProgramLmxRequest { + double freq = 1; +} + +message ProgramLmxResponse { +} \ No newline at end of file diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfdc.proto b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfdc.proto new file mode 100644 index 000000000..def655702 --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/files/protos/xrfdc.proto @@ -0,0 +1,733 @@ +syntax = "proto3"; + +package xrfdc; + +service Xrfdc { + rpc CfgInitialize(CfgInitializeRequest) returns (CfgInitializeResponse); + + rpc GetIPStatus(GetIPStatusRequest) returns (GetIPStatusResponse); + rpc GetBlockStatus(BlockRequest) returns (GetBlockStatusResponse); + rpc GetFIFOStatus(TileRequest) returns (GetFIFOStatusResponse); + rpc GetPLLLockStatus(TileRequest) returns (GetPLLLockStatusResponse); + rpc GetClockSource(TileRequest) returns (GetClockSourceResponse); + + rpc StartUp(TileControlRequest) returns (TileControlResponse); + rpc Shutdown(TileControlRequest) returns (TileControlResponse); + rpc Reset(TileControlRequest) returns (TileControlResponse); + rpc SetupFIFO(SetupFIFORequest) returns (TileControlResponse); + rpc DynamicPLLConfig(DynamicPLLConfigRequest) returns (TileControlResponse); + + rpc SetFabClkOutDiv(SetFabClkOutDivRequest) returns (TileControlResponse); + rpc GetFabClkOutDiv(TileRequest) returns (GetFabClkOutDivResponse); + + rpc SetMixerSettings(SetMixerSettingsRequest) returns (TileControlResponse); + rpc GetMixerSettings(BlockRequest) returns (GetMixerSettingsResponse); + rpc ResetNCOPhase(BlockRequest) returns (TileControlResponse); + + rpc SetNyquistZone(SetNyquistZoneRequest) returns (TileControlResponse); + rpc GetNyquistZone(BlockRequest) returns (GetNyquistZoneResponse); + + rpc SetInterpolationFactor(SetInterpolationFactorRequest) returns (TileControlResponse); + rpc GetInterpolationFactor(BlockRequest) returns (GetInterpolationFactorResponse); + rpc SetDecimationFactor(SetDecimationFactorRequest) returns (TileControlResponse); + rpc GetDecimationFactor(BlockRequest) returns (GetDecimationFactorResponse); + + rpc SetQMCSettings(SetQMCSettingsRequest) returns (TileControlResponse); + rpc GetQMCSettings(BlockRequest) returns (GetQMCSettingsResponse); + + rpc SetThresholdSettings(SetThresholdSettingsRequest) returns (TileControlResponse); + rpc GetThresholdSettings(BlockRequest) returns (GetThresholdSettingsResponse); + rpc SetThresholdClrMode(SetThresholdClrModeRequest) returns (SetThresholdClrModeResponse); + rpc ThresholdStickyClear(ThresholdStickyClearRequest) returns (ThresholdStickyClearResponse); + + rpc GetCoarseDelaySettings(GetCoarseDelaySettingsRequest) returns (GetCoarseDelaySettingsResponse); + rpc SetCoarseDelaySettings(SetCoarseDelaySettingsRequest) returns (SetCoarseDelaySettingsResponse); + + rpc GetEnabledInterrupts(BlockRequest) returns (GetEnabledInterruptsResponse); + rpc GetPwrMode(BlockRequest) returns (GetPwrModeResponse); + rpc SetPwrMode(SetPwrModeRequest) returns (TileControlResponse); + rpc UpdateEvent(UpdateEventRequest) returns (TileControlResponse); + rpc ResetInternalFIFOWidth(BlockRequest) returns (TileControlResponse); + rpc GetConnectedIData(BlockRequest) returns (GetConnectedDataResponse); + rpc GetConnectedQData(BlockRequest) returns (GetConnectedDataResponse); + + rpc GetCalibrationMode(BlockRequest) returns (GetCalibrationModeResponse); + rpc SetCalibrationMode(SetCalibrationModeRequest) returns (TileControlResponse); + + rpc GetFabRdVldWords(BlockRequest) returns (GetFabRdVldWordsResponse); + rpc SetFabRdVldWords(SetFabRdVldWordsRequest) returns (TileControlResponse); + rpc GetFabWrVldWords(BlockRequest) returns (GetFabWrVldWordsResponse); + rpc SetFabWrVldWords(SetFabWrVldWordsRequest) returns (TileControlResponse); + + rpc GetDecimationFactorObs(BlockRequest) returns (GetDecimationFactorResponse); + rpc SetDecimationFactorObs(SetDecimationFactorRequest) returns (TileControlResponse); + rpc GetFabRdVldWordsObs(BlockRequest) returns (GetFabRdVldWordsObsResponse); + rpc SetFabRdVldWordsObs(SetFabRdVldWordsObsRequest) returns (TileControlResponse); + rpc GetFabWrVldWordsObs(BlockRequest) returns (GetFabWrVldWordsObsResponse); + + rpc GetDither(BlockRequest) returns (GetDitherResponse); + rpc SetDither(SetDitherRequest) returns (TileControlResponse); + rpc GetCalFreeze(BlockRequest) returns (GetCalFreezeResponse); + rpc SetCalFreeze(SetCalFreezeRequest) returns (TileControlResponse); + rpc GetDSA(BlockRequest) returns (GetDSAResponse); + rpc SetDSA(SetDSARequest) returns (TileControlResponse); + + rpc DisableCoefficientsOverride(DisableCoefficientsOverrideRequest) returns (TileControlResponse); + rpc ResetInternalFIFOWidthObs(BlockRequest) returns (TileControlResponse); + rpc SetCalCoefficients(SetCalCoefficientsRequest) returns (TileControlResponse); + rpc GetCalCoefficients(GetCalCoefficientsRequest) returns (GetCalCoefficientsResponse); + + rpc GetDecoderMode(BlockRequest) returns (GetDecoderModeResponse); + rpc SetDecoderMode(SetDecoderModeRequest) returns (TileControlResponse); + rpc GetOutputCurr(BlockRequest) returns (GetOutputCurrResponse); + rpc GetInvSincFIR(BlockRequest) returns (GetInvSincFIRResponse); + rpc SetInvSincFIR(SetInvSincFIRRequest) returns (TileControlResponse); + rpc GetDataPathMode(BlockRequest) returns (GetDataPathModeResponse); + rpc SetDataPathMode(SetDataPathModeRequest) returns (TileControlResponse); + rpc GetIMRPassMode(BlockRequest) returns (GetIMRPassModeResponse); + rpc SetIMRPassMode(SetIMRPassModeRequest) returns (TileControlResponse); + rpc GetDACCompMode(BlockRequest) returns (GetDACCompModeResponse); + rpc SetDACCompMode(SetDACCompModeRequest) returns (TileControlResponse); + rpc SetDACVOP(SetDACVOPRequest) returns (TileControlResponse); + + rpc DumpRegs(TileRequest) returns (TileControlResponse); + rpc GetPLLConfig(TileRequest) returns (GetPLLConfigResponse); + rpc SetupFIFOObs(SetupFIFORequest) returns (TileControlResponse); + rpc SetupFIFOBoth(SetupFIFORequest) returns (TileControlResponse); + rpc GetFIFOStatusObs(TileRequest) returns (GetFIFOStatusResponse); + + rpc GetClkDistribution(GetClkDistributionRequest) returns (GetClkDistributionResponse); + rpc SetClkDistribution(SetClkDistributionRequest) returns (TileControlResponse); +} + +message Status { + uint32 code = 1; + string message = 2; + reserved 3; + string operation = 4; + string tile_type_name = 5; + int32 tile_id = 6; + int32 block_id = 7; +} + +message BlockStatus { + double sampling_freq = 1; + uint32 analog_data_path_status = 2; + uint32 digital_data_path_status = 3; + uint32 data_path_clocks_status = 4; + uint32 is_fifo_flags_enabled = 5; + uint32 ib_supply = 6; + uint32 is_fifo_flags_asserted = 7; +} + +message TileStatus { + uint32 is_enabled = 1; + uint32 tile_state = 2; + uint32 block_status_mask = 3; + uint32 power_up_state = 4; + uint32 pll_state = 5; + repeated BlockStatus block_status = 6; // 4 blocks +} + +message IPStatus { + repeated TileStatus dac_tile_status = 1; // 4 tiles + repeated TileStatus adc_tile_status = 2; // 4 tiles + uint32 state = 3; +} + +message DACBlockAnalogDataPathConfig { + uint32 block_available = 1; + uint32 inv_sync_enable = 2; + uint32 mix_mode = 3; + uint32 decoder_mode = 4; +} + +message DACBlockDigitalDataPathConfig { + uint32 mixer_input_data_type = 1; + uint32 data_width = 2; + uint32 interpolation_mode = 3; + uint32 fifo_enable = 4; + uint32 adder_enable = 5; + uint32 mixer_type = 6; +} + +message ADCBlockAnalogDataPathConfig { + uint32 block_available = 1; + uint32 mix_mode = 2; +} + +message ADCBlockDigitalDataPathConfig { + uint32 mixer_input_data_type = 1; + uint32 data_width = 2; + uint32 decimation_mode = 3; + uint32 fifo_enable = 4; + uint32 mixer_type = 5; +} + +message DACTileConfig { + uint32 enable = 1; + uint32 pll_enable = 2; + double sampling_rate = 3; + double ref_clk_freq = 4; + double fab_clk_freq = 5; + uint32 feedback_div = 6; + uint32 output_div = 7; + uint32 ref_clk_div = 8; + uint32 multiband_config = 9; + double max_sample_rate = 10; + uint32 num_slices = 11; + repeated DACBlockAnalogDataPathConfig dac_block_analog_config = 12; // 4 blocks + repeated DACBlockDigitalDataPathConfig dac_block_digital_config = 13; // 4 blocks +} + +message ADCTileConfig { + uint32 enable = 1; + uint32 pll_enable = 2; + double sampling_rate = 3; + double ref_clk_freq = 4; + double fab_clk_freq = 5; + uint32 feedback_div = 6; + uint32 output_div = 7; + uint32 ref_clk_div = 8; + uint32 multiband_config = 9; + double max_sample_rate = 10; + uint32 num_slices = 11; + repeated ADCBlockAnalogDataPathConfig adc_block_analog_config = 12; // 4 blocks + repeated ADCBlockDigitalDataPathConfig adc_block_digital_config = 13; // 4 blocks +} + +message RFdcConfig { + uint32 device_id = 1; + uint64 base_addr = 2; + uint32 adc_type = 3; + uint32 master_adc_tile = 4; + uint32 master_dac_tile = 5; + uint32 adc_sysref_source = 6; + uint32 dac_sysref_source = 7; + uint32 ip_type = 8; + uint32 si_revision = 9; + repeated DACTileConfig dac_tile_config = 10; // 4 tiles + repeated ADCTileConfig adc_tile_config = 11; // 4 tiles +} + +message CfgInitializeRequest { + RFdcConfig config = 1; + uint64 size = 2; +} + +message CfgInitializeResponse { + Status status = 1; +} + +message GetIPStatusRequest { +} + +message GetIPStatusResponse { + Status status = 1; + IPStatus ip_status = 2; +} + +message TileControlRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; +} + +message TileControlResponse { + Status status = 1; +} + +message SetupFIFORequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + bool enable = 3; + uint32 block_id = 4; +} + +message DynamicPLLConfigRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 source = 3; + double ref_clk_freq = 4; // MHz + double samp_rate = 5; // MHz +} + +message BlockRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; +} + +message TileRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; +} + +message GetBlockStatusResponse { + Status status = 1; + double sampling_freq = 2; + uint32 analog_data_path_status = 3; + uint32 digital_data_path_status = 4; + uint32 data_path_clocks_status = 5; + uint32 is_fifo_flags_enabled = 6; + uint32 is_fifo_flags_asserted = 7; +} + +message GetFIFOStatusResponse { + Status status = 1; + bool enable = 2; +} + +message GetPLLLockStatusResponse { + Status status = 1; + uint32 lock_status = 2; +} + +message GetClockSourceResponse { + Status status = 1; + uint32 clock_source = 2; +} + +message SetFabClkOutDivRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 fab_clk_div = 3; +} + +message GetFabClkOutDivResponse { + Status status = 1; + uint32 fab_clk_div = 2; +} + +message MixerSettings { + double freq = 1; + double phase_offset = 2; + uint32 event_source = 3; + uint32 coarse_mix_freq = 4; + uint32 mixer_mode = 5; + uint32 fine_mixer_scale = 6; + uint32 mixer_type = 7; +} + +message SetMixerSettingsRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; + MixerSettings settings = 4; +} + +message GetMixerSettingsResponse { + Status status = 1; + MixerSettings settings = 2; +} + +message ResetNCOPhaseRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; +} + +message SetNyquistZoneRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; + uint32 nyquist_zone = 4; +} + +message GetNyquistZoneResponse { + Status status = 1; + uint32 nyquist_zone = 2; +} + +message SetInterpolationFactorRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 interp_factor = 3; +} + +message GetInterpolationFactorResponse { + Status status = 1; + uint32 interp_factor = 2; +} + +message SetDecimationFactorRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 dec_factor = 3; +} + +message GetDecimationFactorResponse { + Status status = 1; + uint32 dec_factor = 2; +} + +message QMCSettings { + bool enable_phase = 1; + bool enable_gain = 2; + bool enable_offset_corr = 3; + double gain_correction_factor = 4; + double phase_correction_factor = 5; + int32 offset_correction_factor = 6; + uint32 event_source = 7; +} + +message SetQMCSettingsRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; + QMCSettings settings = 4; +} + +message GetQMCSettingsResponse { + Status status = 1; + QMCSettings settings = 2; +} + +message ThresholdSettings { + uint32 update_threshold = 1; + repeated uint32 threshold_mode = 2; + repeated uint32 threshold_avg_val = 3; + repeated uint32 threshold_under_val = 4; + repeated uint32 threshold_over_val = 5; +} + +message SetThresholdSettingsRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + ThresholdSettings settings = 3; +} + +message GetThresholdSettingsResponse { + Status status = 1; + ThresholdSettings settings = 2; +} + +message CoarseDelaySettings { + uint32 coarse_delay = 1; + uint32 event_source = 2; +} + +message SetThresholdClrModeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 threshold_to_update = 3; + uint32 clr_mode = 4; +} + +message SetThresholdClrModeResponse { + Status status = 1; +} + +message ThresholdStickyClearRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 threshold_to_update = 3; +} + +message ThresholdStickyClearResponse { + Status status = 1; +} + +message GetCoarseDelaySettingsRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; +} + +message GetCoarseDelaySettingsResponse { + Status status = 1; + CoarseDelaySettings settings = 2; +} + +message SetCoarseDelaySettingsRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; + CoarseDelaySettings settings = 4; +} + +message SetCoarseDelaySettingsResponse { + Status status = 1; +} + +message PwrModeSettings { + uint32 disable_ip_control = 1; + uint32 pwr_mode = 2; +} + +message GetPwrModeResponse { + Status status = 1; + PwrModeSettings settings = 2; +} + +message SetPwrModeRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; + PwrModeSettings settings = 4; +} + +message UpdateEventRequest { + uint32 tile_type = 1; + uint32 tile_id = 2; + uint32 block_id = 3; + uint32 event = 4; +} + +message GetConnectedDataResponse { + Status status = 1; + int32 value = 2; +} + +message GetEnabledInterruptsResponse { + Status status = 1; + uint32 value = 2; +} + +message GetCalibrationModeResponse { + Status status = 1; + uint32 value = 2; +} + +message SetCalibrationModeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetFabRdVldWordsResponse { + Status status = 1; + uint32 value = 2; +} + +message SetFabRdVldWordsRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetFabWrVldWordsResponse { + Status status = 1; + uint32 value = 2; +} + +message SetFabWrVldWordsRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetFabRdVldWordsObsResponse { + Status status = 1; + uint32 value = 2; +} + +message SetFabRdVldWordsObsRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetFabWrVldWordsObsResponse { + Status status = 1; + uint32 value = 2; +} + +message SetDitherRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetDitherResponse { + Status status = 1; + uint32 value = 2; +} + +message SetDecoderModeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetDecoderModeResponse { + Status status = 1; + uint32 value = 2; +} + +message GetOutputCurrResponse { + Status status = 1; + uint32 value = 2; +} + +message GetInvSincFIRResponse { + Status status = 1; + uint32 value = 2; +} + +message SetInvSincFIRRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetDataPathModeResponse { + Status status = 1; + uint32 value = 2; +} + +message SetDataPathModeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetIMRPassModeResponse { + Status status = 1; + uint32 value = 2; +} + +message SetIMRPassModeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message GetDACCompModeResponse { + Status status = 1; + uint32 value = 2; +} + +message SetDACCompModeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 value = 3; +} + +message CalFreezeSettings { + uint32 cal_frozen = 1; + uint32 disable_freeze_pin = 2; + uint32 freeze_calibration = 3; +} + +message GetCalFreezeResponse { + Status status = 1; + CalFreezeSettings settings = 2; +} + +message SetCalFreezeRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + CalFreezeSettings settings = 3; +} + +message DSASettings { + uint32 disable_rts = 1; + float attenuation = 2; +} + +message GetDSAResponse { + Status status = 1; + DSASettings settings = 2; +} + +message SetDSARequest { + uint32 tile_id = 1; + uint32 block_id = 2; + DSASettings settings = 3; +} + +message DisableCoefficientsOverrideRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 calibration_block = 3; +} + +message CalibrationCoefficients { + uint32 coeff0 = 1; + uint32 coeff1 = 2; + uint32 coeff2 = 3; + uint32 coeff3 = 4; + uint32 coeff4 = 5; + uint32 coeff5 = 6; + uint32 coeff6 = 7; + uint32 coeff7 = 8; +} + +message SetCalCoefficientsRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 calibration_block = 3; + CalibrationCoefficients coeffs = 4; +} + +message GetCalCoefficientsRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 calibration_block = 3; +} + +message GetCalCoefficientsResponse { + Status status = 1; + CalibrationCoefficients coeffs = 2; +} + +message SetDACVOPRequest { + uint32 tile_id = 1; + uint32 block_id = 2; + uint32 uA_current = 3; +} + +message PLLSettings { + uint32 enabled = 1; + double ref_clk_freq = 2; + double sample_rate = 3; + uint32 ref_clk_divider = 4; + uint32 feedback_divider = 5; + uint32 output_divider = 6; + uint32 fractional_mode = 7; + uint64 fractional_data = 8; + uint32 fract_width = 9; +} + +message GetPLLConfigResponse { + Status status = 1; + PLLSettings settings = 2; +} + +message GetClkDistributionRequest { +} + +message Distribution { + uint32 source = 1; + uint32 upper_bound = 2; + uint32 lower_bound = 3; + uint32 max_delay = 4; + uint32 min_delay = 5; + uint32 is_delay_balanced = 6; +} + +message TileClockSettings { + uint32 source_type = 1; + uint32 source_tile = 2; + uint32 pll_enable = 3; + double ref_clk_freq = 4; + double sample_rate = 5; + uint32 division_factor = 6; + uint32 distributed_clock = 7; + uint32 delay = 8; +} + +message ClkDistributionSettings { + repeated TileClockSettings dac = 1; + repeated TileClockSettings adc = 2; + Distribution distribution_info = 3; +} + +message GetClkDistributionResponse { + Status status = 1; + ClkDistributionSettings settings = 2; +} + +message SetClkDistributionRequest { + ClkDistributionSettings settings = 1; +} diff --git a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/pynq-cpp.bb b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/pynq-cpp.bb index 408a26f85..23bfcb781 100644 --- a/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/pynq-cpp.bb +++ b/sdbuild/boot/meta-pynq/recipes-apps/pynq-cpp/pynq-cpp.bb @@ -5,6 +5,12 @@ LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda DEPENDS = "protobuf grpc protobuf-native grpc-native xrt" +# RFSoC services (xrfdc, xrfclk) are gated by the "rfsoc" PACKAGECONFIG. +# The PYNQ Makefile writes a per-project bbappend that appends "rfsoc" to +# PACKAGECONFIG when RFSoC_=1. +PACKAGECONFIG ??= "" +PACKAGECONFIG[rfsoc] = "-DRFSOC=ON,-DRFSOC=OFF,rfdc libmetal,rfdc libmetal" + SRC_URI = "file://cpp/CMakeLists.txt \ file://cpp/pynq-remote.cc \ file://cpp/device.cc \ @@ -22,6 +28,11 @@ SRC_URI = "file://cpp/CMakeLists.txt \ file://cmake/common.cmake \ file://pynq-remote.service" +SRC_URI:append = " ${@bb.utils.contains('PACKAGECONFIG', 'rfsoc', \ + 'file://cpp/xrfclk.cc file://cpp/xrfclk.h \ + file://cpp/xrfdc.cc file://cpp/xrfdc.h \ + file://protos/xrfclk.proto file://protos/xrfdc.proto', '', d)}" + S = "${WORKDIR}/cpp" inherit cmake deploy systemd diff --git a/sdbuild/boot/meta-pynq/recipes-bsp/rfdc/rfdc_%.bbappend b/sdbuild/boot/meta-pynq/recipes-bsp/rfdc/rfdc_%.bbappend new file mode 100644 index 000000000..2878ca3fc --- /dev/null +++ b/sdbuild/boot/meta-pynq/recipes-bsp/rfdc/rfdc_%.bbappend @@ -0,0 +1,3 @@ +# Override machine compatibility restriction for RFSoC boards +# The build system only adds rfdc when RFSoC_boardname := 1 +COMPATIBLE_MACHINE = ".*" From 91d1fe2a112bd0abc1c2e6a55e71aa3a2b110a59 Mon Sep 17 00:00:00 2001 From: Mario Ruiz <11815099+mariodruiz@users.noreply.github.com> Date: Thu, 11 Jun 2026 12:08:09 +0100 Subject: [PATCH 4/4] Add AUP-ZU3 getting started (#1541) --- docs/source/getting_started.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/getting_started.rst b/docs/source/getting_started.rst index 6c092d1ea..a3adaaafb 100644 --- a/docs/source/getting_started.rst +++ b/docs/source/getting_started.rst @@ -20,6 +20,7 @@ Zynq, Zynq Ultrascale+ and Zynq RFSoC getting_started/pynq_z2_setup.rst getting_started/zcu104_setup.rst +* `AUP-ZU3 `_ * `Ultra96 `_ * `PYNQ-ZU `_