def _init_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Peripherals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.mboard_info.get('product') in self.pids.values(), \
"Device product could not be determined!"
# Init Mboard Regs
self.mboard_regs_control = MboardRegsControl(self.mboard_regs_label,
self.log)
self.mboard_regs_control.get_git_hash()
self.mboard_regs_control.get_build_timestamp()
self._check_fpga_compat()
self._update_fpga_type()
# Init clocking
self._init_ref_clock_and_time(args)
# Init CHDR transports
self._xport_mgrs = {
'liberio': E310XportMgrLiberio(self.log.getChild('liberio')),
}
# Init complete.
self.log.debug("mboard info: {}".format(self.mboard_info))
def get_ad9361_lo_lock(self, which):
"""
Return LO lock status (Boolean!) of AD9361. 'which' must be
either 'tx' or 'rx'
"""
assert which in ('rx', 'tx')
mboard_regs_control = \
MboardRegsControl(self.mboard_regs_label, self.log)
if which == "tx":
return mboard_regs_control.get_ad9361_tx_lo_lock()
# else:
return mboard_regs_control.get_ad9361_rx_lo_lock()
def get_ad9361_lo_lock(self, which):
"""
Return LO lock status (Boolean!) of AD9361. 'which' must be
either 'tx' or 'rx'
"""
mboard_regs_control = \
MboardRegsControl(self.mboard_regs_label, self.log)
if which == "tx":
return mboard_regs_control.get_ad9361_tx_lo_lock()
elif which == "rx":
return mboard_regs_control.get_ad9361_rx_lo_lock()
self.log.warning(
"get_ad9361_lo_lock(): Invalid which param `{}'".format(which))
return False
def get_ad9361_lo_lock(self, which):
"""
Return LO lock status (Boolean!) of AD9361. 'which' must be
either 'tx' or 'rx'
"""
self.mboard_regs_label = "mboard-regs"
self.mboard_regs_control = MboardRegsControl(self.mboard_regs_label,
self.log)
if which == "tx":
locked = self.mboard_regs_control.get_ad9361_tx_lo_lock()
elif which == "rx":
locked = self.mboard_regs_control.get_ad9361_rx_lo_lock()
else:
locked = False
return locked
def _init_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Peripherals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.mboard_info.get('product') in self.pids.values(), \
"Device product could not be determined!"
# Init Mboard Regs
self.mboard_regs_control = MboardRegsControl(
self.mboard_regs_label, self.log)
self.mboard_regs_control.get_git_hash()
self.mboard_regs_control.get_build_timestamp()
self._check_fpga_compat()
self._update_fpga_type()
self.crossbar_base_port = self.mboard_regs_control.get_xbar_baseport()
self.log.debug("crossbar base port: {}".format(self.crossbar_base_port))
# Init clocking
self._init_ref_clock_and_time(args)
# Init CHDR transports
self._xport_mgrs = {
'liberio': E310XportMgrLiberio(self.log.getChild('liberio')),
}
# Init complete.
self.log.debug("mboard info: {}".format(self.mboard_info))
class E31x_db(DboardManagerBase):
"""
Holds all dboard specific information and methods of the E31x_db dboard
"""
#########################################################################
# Overridables
#
# See DboardManagerBase for documentation on these fields
#########################################################################
pids = [0x0110]
rx_sensor_callback_map = {
'ad9361_temperature': 'get_catalina_temp_sensor',
'rssi': 'get_rssi_sensor',
'lo_lock': 'get_lo_lock_sensor',
}
tx_sensor_callback_map = {
'ad9361_temperature': 'get_catalina_temp_sensor',
}
# Maps the chipselects to the corresponding devices:
spi_chipselect = {
"catalina": 0,
}
default_master_clock_rate = 16e6
MIN_MASTER_CLK_RATE = 220e3
MAX_MASTER_CLK_RATE = 61.44e6
def __init__(self, slot_idx, **kwargs):
super(E31x_db, self).__init__(slot_idx, **kwargs)
self.log = get_logger("E31x_db-{}".format(slot_idx))
self.log.trace("Initializing e31x daughterboard, slot index %d",
self.slot_idx)
self.rev = int(self.device_info['rev'])
self.log.trace("This is a rev: {}".format(chr(65 + self.rev)))
# These will get updated during init()
self.master_clock_rate = None
# Predeclare some attributes to make linter happy:
self.catalina = None
self.eeprom_fs = None
self.eeprom_path = None
# Now initialize all peripherals. If that doesn't work, put this class
# into a non-functional state (but don't crash, or we can't talk to it
# any more):
try:
self._init_periphs()
self._periphs_initialized = True
except Exception as ex:
self.log.error("Failed to initialize peripherals: %s", str(ex))
self._periphs_initialized = False
def _init_periphs(self):
"""
Initialize power and peripherals that don't need user-settings
"""
self.log.debug("Loading C++ drivers...")
# Setup Catalina / the E31x_db Manager
self._device = lib.dboards.e31x_db_manager(self._spi_nodes['catalina'])
self.catalina = self._device.get_radio_ctrl()
self.log.trace("Loaded C++ drivers.")
self._init_cat_api(self.catalina)
def _init_cat_api(self, cat):
"""
Propagate the C++ Catalina API into Python land.
"""
def export_method(obj, method):
" Export a method object, including docstring "
meth_obj = getattr(obj, method)
def func(*args):
" Functor for storing docstring too "
return meth_obj(*args)
func.__doc__ = meth_obj.__doc__
return func
self.log.trace("Forwarding AD9361 methods to E31x_db class...")
for method in [
x for x in dir(self.catalina)
if not x.startswith("_") and \
callable(getattr(self.catalina, x))]:
self.log.trace("adding {}".format(method))
setattr(self, method, export_method(cat, method))
def init(self, args):
if not self._periphs_initialized:
error_msg = "Cannot run init(), peripherals are not initialized!"
self.log.error(error_msg)
raise RuntimeError(error_msg)
master_clock_rate = \
float(args.get('master_clock_rate',
self.default_master_clock_rate))
assert self.MIN_MASTER_CLK_RATE <= master_clock_rate <= self.MAX_MASTER_CLK_RATE, \
"Invalid master clock rate: {:.02f} MHz".format(
master_clock_rate / 1e6)
master_clock_rate_changed = master_clock_rate != self.master_clock_rate
if master_clock_rate_changed:
self.master_clock_rate = master_clock_rate
self.log.debug("Updating master clock rate to {:.02f} MHz!".format(
self.master_clock_rate / 1e6))
# Some default chains on -- needed for setup purposes
self.catalina.set_active_chains(True, False, True, False)
self.set_catalina_clock_rate(self.master_clock_rate)
return True
def get_master_clock_rate(self):
" Return master clock rate (== sampling rate) "
return self.master_clock_rate
##########################################################################
# Sensors
##########################################################################
def get_ad9361_lo_lock(self, which):
"""
Return LO lock status (Boolean!) of AD9361. 'which' must be
either 'tx' or 'rx'
"""
self.mboard_regs_label = "mboard-regs"
self.mboard_regs_control = MboardRegsControl(self.mboard_regs_label,
self.log)
if which == "tx":
locked = self.mboard_regs_control.get_ad9361_tx_lo_lock()
elif which == "rx":
locked = self.mboard_regs_control.get_ad9361_rx_lo_lock()
else:
locked = False
return locked
def get_lo_lock_sensor(self, which):
"""
Get sensor dict with LO lock status
"""
self.log.trace("Reading LO Lock.")
lo_locked = self.get_ad9361_lo_lock(which)
return {
'name': 'ad9361_lock',
'type': 'BOOLEAN',
'unit': 'locked' if lo_locked else 'unlocked',
'value': str(lo_locked).lower(),
}
def get_catalina_temp_sensor(self, _):
"""
Get temperature sensor reading of Catalina.
"""
# Note: the unused argument is channel
self.log.trace("Reading Catalina temperature.")
return {
'name': 'ad9361_temperature',
'type': 'REALNUM',
'unit': 'C',
'value': str(self.catalina.get_temperature())
}
def get_rssi_val(self, which):
"""
Return the current RSSI of `which` chain in Catalina
"""
return self.catalina.get_rssi(which)
def get_rssi_sensor(self, chan):
"""
Return a sensor dictionary containing the current RSSI of `which` chain in Catalina
"""
which = 'RX' + str(chan + 1)
return {
'name': 'rssi',
'type': 'REALNUM',
'unit': 'dB',
'value': str(self.get_rssi_val(which)),
}
def set_catalina_clock_rate(self, rate):
"""
Async call to catalina set_clock_rate
"""
self.log.trace("Setting Clock rate to {}".format(rate))
async_exec(lib.ad9361, "set_clock_rate", self.catalina, rate)
return rate
def catalina_tune(self, which, freq):
"""
Async call to catalina tune
"""
self.log.trace("Tuning {} {}".format(which, freq))
async_exec(lib.ad9361, "tune", self.catalina, which, freq)
return self.catalina.get_freq(which)
class e31x(ZynqComponents, PeriphManagerBase):
"""
Holds E310 specific attributes and methods
"""
#########################################################################
# Overridables
#
# See PeriphManagerBase for documentation on these fields
#########################################################################
description = "E300-Series Device"
# 0x77d2 and 0x77d3
pids = {
0x77D2: 'e310_sg1', #sg1
0x77D3: 'e310_sg3'
} #sg3
# The E310 has a single EEPROM that stores both DB and MB information
mboard_eeprom_addr = "e0004000.i2c"
mboard_eeprom_offset = 0
mboard_eeprom_max_len = 64
# We have two nvem paths on the E310.
# This one ensures that we get the right path for the MB.
mboard_eeprom_path_index = 1
mboard_info = {"type": "e3xx"}
mboard_sensor_callback_map = {
'ref_locked': 'get_ref_lock_sensor',
'gps_locked': 'get_gps_lock_sensor',
'temp_fpga': 'get_fpga_temp_sensor',
'temp_mb': 'get_mb_temp_sensor',
}
# The E310 has a single EEPROM that stores both DB and MB information
dboard_eeprom_addr = "e0004000.i2c"
dboard_eeprom_path_index = 0
# Actual DB EEPROM bytes are just 28. Reading just a couple more.
# Refer e300_eeprom_manager.hpp
dboard_eeprom_max_len = 32
max_num_dboards = 1
# We're on a Zynq target, so the following two come from the Zynq standard
# device tree overlay (tree/arch/arm/boot/dts/zynq-7000.dtsi)
dboard_spimaster_addrs = ["e0006000.spi"]
# E310-specific settings
# Label for the mboard UIO
mboard_regs_label = "mboard-regs"
# Override the list of updateable components
updateable_components = {
'fpga': {
'callback': "update_fpga",
'path': '/lib/firmware/{}.bin',
'reset': True,
},
'dts': {
'callback': "update_dts",
'path': '/lib/firmware/{}.dts',
'output': '/lib/firmware/{}.dtbo',
'reset': False,
},
}
# This class removes the overlay in tear_down() resulting
# in stale references to methods in the RPC server. Setting
# this to True ensures that the RPC server clears all registered
# methods on unclaim() and registers them on the following claim().
clear_rpc_registry_on_unclaim = True
@classmethod
def generate_device_info(cls, eeprom_md, mboard_info, dboard_infos):
"""
Generate dictionary describing the device.
"""
# Add the default PeriphManagerBase information first
device_info = super().generate_device_info(eeprom_md, mboard_info,
dboard_infos)
# Then add E31x-specific information
mb_pid = eeprom_md.get('pid')
device_info['product'] = cls.pids.get(mb_pid, 'unknown')
return device_info
@staticmethod
def list_required_dt_overlays(device_info):
"""
Returns the name of the overlay for the regular image (not idle).
Either returns e310_sg1 or e310_sg3.
"""
return [device_info['product']]
### End of overridables ###################################################
@staticmethod
def get_idle_dt_overlay(device_info):
"""
Overlay to be applied to enter low power idle state.
"""
# e.g. e310_sg3_idle
idle_overlay = device_info['product'] + '_idle'
return idle_overlay
###########################################################################
# Ctor and device initialization tasks
###########################################################################
def __init__(self, args):
"""
Does partial initialization which loads low power idle image
"""
self._time_source = None
self._gpsd = None
self.dboards = []
self.dboard = None
self.mboard_regs_control = None
self._xport_mgrs = {}
self._initialization_status = ""
self._device_initialized = False
self.args_cached = args
# This will load the regular image to obtain all FPGA info
super(e31x, self).__init__()
args = self._update_default_args(args)
# Permanently store the value from mpm.conf:
self._do_not_reload_default = \
str2bool(args.get("no_reload_fpga", E310_DEFAULT_DONT_RELOAD_FPGA))
# This flag can change depending on UHD args:
self._do_not_reload = self._do_not_reload_default
# If we don't want to reload, we'll complete initialization now:
if self._do_not_reload:
try:
self.log.info("Not reloading FPGA images!")
self._init_normal()
except BaseException as ex:
self.log.error("Failed to initialize motherboard: %s", str(ex))
self._initialization_status = str(ex)
self._device_initialized = False
else: # Otherwise, put the USRP into low-power mode:
# Start clean by removing MPM-owned overlays.
active_overlays = self.list_active_overlays()
mpm_overlays = self.list_owned_overlays()
for overlay in active_overlays:
if overlay in mpm_overlays:
dtoverlay.rm_overlay(overlay)
# Apply idle overlay on boot to save power until
# an application tries to use the device.
self.apply_idle_overlay()
self._device_initialized = False
self._init_gps_sensors()
def _init_gps_sensors(self):
"""
Init and register the GPSd Iface and related sensor functions
Note: The GPS chip is not connected to the FPGA, so this is initialized
regardless of the idle state
"""
self.log.trace("Initializing GPSd interface")
self._gpsd = GPSDIfaceExtension()
new_methods = self._gpsd.extend(self)
for method_name in new_methods:
try:
# Extract the sensor name from the getter
sensor_name = re.search(r"get_(.*)_sensor",
method_name).group(1)
# Register it with the MB sensor framework
self.mboard_sensor_callback_map[sensor_name] = method_name
self.log.trace("Adding %s sensor function", sensor_name)
except AttributeError:
# re.search will return None is if can't find the sensor name
self.log.warning("Error while registering sensor function: %s",
method_name)
def _init_normal(self):
"""
Does full initialization. This gets called during claim(), because the
E310 usually gets freshly initialized on every UHD session for power
usage reasons, unless no_reload_fpga was provided in mpm.conf.
"""
if self._device_initialized:
return
if self.is_idle():
self.remove_idle_overlay()
self.overlay_apply()
self.init_dboards(self.args_cached)
if not self._device_initialized:
# Don't try and figure out what's going on. Just give up.
return
self._time_source = None
self.dboard = self.dboards[E310_DBOARD_SLOT_IDX]
try:
self._init_peripherals(self.args_cached)
except BaseException as ex:
self.log.error("Failed to initialize motherboard: %s", str(ex))
self._initialization_status = str(ex)
self._device_initialized = False
def _init_dboards(self, dboard_infos, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
dboard_infos -- List of dictionaries as returned from
PeriphManagerBase._get_dboard_eeprom_info()
override_dboard_pids -- List of dboard PIDs to force
default_args -- Default args
"""
# Overriding DB PIDs doesn't work here, the DB is coupled to the MB
if override_dboard_pids:
raise NotImplementedError("Can't override dboard pids")
# We have only one dboard
dboard_info = dboard_infos[0]
# Set up the SPI nodes
assert len(self.dboard_spimaster_addrs) == 1
spi_nodes = get_spidev_nodes(self.dboard_spimaster_addrs[0])
assert spi_nodes
self.log.trace("Found spidev nodes: {0}".format(str(spi_nodes)))
dboard_info.update({
'spi_nodes': spi_nodes,
'default_args': default_args,
})
self.dboards.append(E31x_db(E310_DBOARD_SLOT_IDX, **dboard_info))
self.log.info("Found %d daughterboard(s).", len(self.dboards))
def _check_fpga_compat(self):
" Throw an exception if the compat numbers don't match up "
actual_compat = self.mboard_regs_control.get_compat_number()
self.log.debug("Actual FPGA compat number: {:d}.{:d}".format(
actual_compat[0], actual_compat[1]))
assert_compat_number(E310_FPGA_COMPAT,
self.mboard_regs_control.get_compat_number(),
component="FPGA",
fail_on_old_minor=True,
log=self.log)
def _init_ref_clock_and_time(self, default_args):
"""
Initialize clock and time sources. After this function returns, the
reference signals going to the FPGA are valid.
"""
if not self.dboards:
self.log.warning(
"No dboards found, skipping setting clock and time source "
"configuration.")
self._time_source = E310_DEFAULT_TIME_SOURCE
else:
self.set_clock_source(
default_args.get('clock_source', E310_DEFAULT_CLOCK_SOURCE))
self.set_time_source(
default_args.get('time_source', E310_DEFAULT_TIME_SOURCE))
def _init_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Peripherals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.mboard_info.get('product') in self.pids.values(), \
"Device product could not be determined!"
# Init Mboard Regs
self.mboard_regs_control = MboardRegsControl(self.mboard_regs_label,
self.log)
self.mboard_regs_control.get_git_hash()
self.mboard_regs_control.get_build_timestamp()
self._check_fpga_compat()
self._update_fpga_type()
# Init clocking
self._init_ref_clock_and_time(args)
# Init CHDR transports
self._xport_mgrs = {
'liberio': E310XportMgrLiberio(self.log.getChild('liberio')),
}
# Init complete.
self.log.debug("mboard info: {}".format(self.mboard_info))
def _read_mboard_eeprom(self):
"""
Read out mboard EEPROM.
Returns a tuple: (eeprom_dict, eeprom_rawdata), where the the former is
a de-serialized dictionary representation of the data, and the latter
is a binary string with the raw data.
If no EEPROM is defined, returns empty values.
"""
eeprom_path = \
get_eeprom_paths(self.mboard_eeprom_addr)[self.mboard_eeprom_path_index]
if not eeprom_path:
self.log.error("Could not identify EEPROM path for %s!",
self.mboard_eeprom_addr)
return {}, b''
self.log.trace("MB EEPROM: Using path {}".format(eeprom_path))
(eeprom_head, eeprom_rawdata) = e31x_legacy_eeprom.read_eeprom(
True, # is_motherboard
eeprom_path,
self.mboard_eeprom_offset,
e31x_legacy_eeprom.MboardEEPROM.eeprom_header_format,
e31x_legacy_eeprom.MboardEEPROM.eeprom_header_keys,
self.mboard_eeprom_max_len)
self.log.trace("Read %d bytes of EEPROM data.", len(eeprom_rawdata))
return eeprom_head, eeprom_rawdata
def _get_dboard_eeprom_info(self):
"""
Read back EEPROM info from the daughterboards
"""
assert self.dboard_eeprom_addr
self.log.trace("Identifying dboard EEPROM paths from `{}'...".format(
self.dboard_eeprom_addr))
dboard_eeprom_path = \
get_eeprom_paths(self.dboard_eeprom_addr)[self.dboard_eeprom_path_index]
self.log.trace(
"Using dboard EEPROM paths: {}".format(dboard_eeprom_path))
self.log.debug("Reading EEPROM info for dboard...")
dboard_eeprom_md, dboard_eeprom_rawdata = e31x_legacy_eeprom.read_eeprom(
False, # is not motherboard.
dboard_eeprom_path,
self.dboard_eeprom_offset,
e31x_legacy_eeprom.DboardEEPROM.eeprom_header_format,
e31x_legacy_eeprom.DboardEEPROM.eeprom_header_keys,
self.dboard_eeprom_max_len)
self.log.trace("Read %d bytes of dboard EEPROM data.",
len(dboard_eeprom_rawdata))
db_pid = dboard_eeprom_md.get('pid')
if db_pid is None:
self.log.warning("No DB PID found in dboard EEPROM!")
else:
self.log.debug("Found DB PID in EEPROM: 0x{:04X}".format(db_pid))
return [{
'eeprom_md': dboard_eeprom_md,
'eeprom_rawdata': dboard_eeprom_rawdata,
'pid': db_pid,
}]
###########################################################################
# Session init and deinit
###########################################################################
def claim(self):
"""
Fully initializes a device when the rpc_server claim()
gets called to revive the device from idle state to be used
by an UHD application
"""
super(e31x, self).claim()
try:
self._init_normal()
except BaseException as ex:
self.log.error("e31x claim() failed: %s", str(ex))
def init(self, args):
"""
Calls init() on the parent class, and updates time/clock source.
"""
if not self._device_initialized:
self.log.warning(
"Cannot run init(), device was never fully initialized!")
return False
if args.get("clock_source", "") != "":
self.set_clock_source(args.get("clock_source"))
if args.get("time_source", "") != "":
self.set_time_source(args.get("time_source"))
if "no_reload_fpga" in args:
self._do_not_reload = \
str2bool(args.get("no_reload_fpga")) or args.get("no_reload_fpga") == ""
result = super(e31x, self).init(args)
for xport_mgr in itervalues(self._xport_mgrs):
xport_mgr.init(args)
return result
def apply_idle_overlay(self):
"""
Load all overlays required to go into idle power savings mode.
"""
idle_overlay = self.get_idle_dt_overlay(self.device_info)
self.log.debug(
"Motherboard requests device tree overlay for Idle power savings mode: {}"
.format(idle_overlay))
dtoverlay.apply_overlay_safe(idle_overlay)
def remove_idle_overlay(self):
"""
Remove idle mode overlay.
"""
idle_overlay = self.get_idle_dt_overlay(self.device_info)
self.log.trace("Removing Idle overlay: {}".format(idle_overlay))
dtoverlay.rm_overlay(idle_overlay)
def list_owned_overlays(self):
"""
Lists all overlays that can be possibly applied by MPM.
"""
all_overlays = self.list_required_dt_overlays(self.device_info)
all_overlays.append(self.get_idle_dt_overlay(self.device_info))
return all_overlays
def deinit(self):
"""
Clean up after a UHD session terminates.
"""
if not self._device_initialized:
self.log.warning(
"Cannot run deinit(), device was never fully initialized!")
return
super(e31x, self).deinit()
for xport_mgr in itervalues(self._xport_mgrs):
xport_mgr.deinit()
if not self._do_not_reload:
self.tear_down()
# Reset back to value from _default_args (mpm.conf)
self._do_not_reload = self._do_not_reload_default
def tear_down(self):
"""
Tear down all members that need to be specially handled before
deconstruction.
For E310, this means the overlay.
"""
self.log.trace("Tearing down E310 device...")
self.dboards = []
self.dboard.tear_down()
self.dboard = None
self.mboard_regs_control = None
self._device_initialized = False
active_overlays = self.list_active_overlays()
self.log.trace(
"E310 has active device tree overlays: {}".format(active_overlays))
for overlay in active_overlays:
dtoverlay.rm_overlay(overlay)
self.apply_idle_overlay()
self.log.debug("Teardown complete!")
def is_idle(self):
"""
Determine if the device is in the idle state.
"""
active_overlays = self.list_active_overlays()
idle_overlay = self.get_idle_dt_overlay(self.device_info)
is_idle = idle_overlay in active_overlays
if is_idle:
self.log.trace("Found idle overlay: %s", idle_overlay)
return is_idle
###########################################################################
# Transport API
###########################################################################
def get_chdr_link_types(self):
"""
See PeriphManagerBase.get_chdr_link_types() for docs.
"""
return ['liberio']
def get_chdr_link_options(self, xport_type):
"""
See PeriphManagerBase.get_chdr_link_options() for docs.
"""
assert xport_type == 'liberio', \
"Invalid xport_type! Must be 'liberio'"
return self._xport_mgrs['liberio'].get_chdr_link_options()
###########################################################################
# Device info
###########################################################################
def get_device_info_dyn(self):
"""
Append the device info with current IP addresses.
"""
if not self._device_initialized:
return {}
device_info = {}
device_info.update({
'fpga_version':
"{}.{}".format(*self.mboard_regs_control.get_compat_number()),
'fpga_version_hash':
"{:x}.{}".format(*self.mboard_regs_control.get_git_hash()),
'fpga':
self.updateable_components.get('fpga', {}).get('type', ""),
})
return device_info
###########################################################################
# Clock/Time API
###########################################################################
def get_clock_sources(self):
" Lists all available clock sources. "
self.log.trace("Listing available clock sources...")
return ('internal', )
def get_clock_source(self):
" Returns the currently selected clock source "
return E310_DEFAULT_CLOCK_SOURCE
def set_clock_source(self, *args):
"""
Note: E310 only supports one clock source ('internal'), so no need to do
an awful lot here.
"""
clock_source = args[0]
assert clock_source in self.get_clock_sources(), \
"Cannot set to invalid clock source: {}".format(clock_source)
def get_time_sources(self):
" Returns list of valid time sources "
return ['internal', 'external', 'gpsdo']
def get_time_source(self):
" Return the currently selected time source "
return self._time_source
def set_time_source(self, time_source):
" Set a time source "
assert time_source in self.get_time_sources(), \
"Cannot set to invalid time source: {}".format(time_source)
if time_source == self.get_time_source():
self.log.trace("Nothing to do -- time source already set.")
return
self._time_source = time_source
self.mboard_regs_control.set_time_source(time_source)
###########################################################################
# Hardware peripheral controls
###########################################################################
def set_fp_gpio_master(self, value):
"""set driver for front panel GPIO
Arguments:
value {unsigned} -- value is a single bit bit mask of 12 pins GPIO
"""
self.mboard_regs_control.set_fp_gpio_master(value)
def get_fp_gpio_master(self):
"""get "who" is driving front panel gpio
The return value is a bit mask of 8 pins GPIO.
0: means the pin is driven by PL
1: means the pin is driven by PS
"""
return self.mboard_regs_control.get_fp_gpio_master()
def set_fp_gpio_radio_src(self, value):
"""set driver for front panel GPIO
Arguments:
value {unsigned} -- value is 2-bit bit mask of 8 pins GPIO
00: means the pin is driven by radio 0
01: means the pin is driven by radio 1
"""
self.mboard_regs_control.set_fp_gpio_radio_src(value)
def get_fp_gpio_radio_src(self):
"""get which radio is driving front panel gpio
The return value is 2-bit bit mask of 8 pins GPIO.
00: means the pin is driven by radio 0
01: means the pin is driven by radio 1
"""
return self.mboard_regs_control.get_fp_gpio_radio_src()
def set_channel_mode(self, channel_mode):
"Set channel mode in FPGA and select which tx channel to use"
self.mboard_regs_control.set_channel_mode(channel_mode)
###########################################################################
# Sensors
###########################################################################
def get_ref_lock_sensor(self):
"""
Return main refclock lock status. In the FPGA, this is the reflck output
of the ppsloop module.
"""
self.log.trace("Querying ref lock status.")
lock_status = bool(self.mboard_regs_control.get_refclk_lock())
return {
'name': 'ref_locked',
'type': 'BOOLEAN',
'unit': 'locked' if lock_status else 'unlocked',
'value': str(lock_status).lower(),
}
def get_gps_lock_sensor(self):
"""
Get lock status of GPS as a sensor dict
"""
gps_locked = self._gpsd.get_gps_lock()
return {
'name': 'gps_lock',
'type': 'BOOLEAN',
'unit': 'locked' if gps_locked else 'unlocked',
'value': str(gps_locked).lower(),
}
def get_mb_temp_sensor(self):
"""
Get temperature sensor reading of the E310.
"""
self.log.trace("Reading temperature.")
temp = '-1'
raw_val = {}
data_probes = ['temp1_input']
try:
for data_probe in data_probes:
raw_val[data_probe] = read_sysfs_sensors_value(
'jc-42.4-temp', data_probe, 'hwmon', 'name')[0]
temp = str(raw_val['temp1_input'] / 1000)
except ValueError:
self.log.warning("Error when converting temperature value")
except KeyError:
self.log.warning("Can't read MB temperature!")
return {
'name': 'temp_mb',
'type': 'REALNUM',
'unit': 'C',
'value': temp
}
def get_fpga_temp_sensor(self):
"""
Get temperature sensor reading of the E310.
"""
self.log.trace("Reading temperature.")
temp = '-1'
raw_val = {}
data_probes = ['in_temp0_raw', 'in_temp0_scale', 'in_temp0_offset']
try:
for data_probe in data_probes:
raw_val[data_probe] = read_sysfs_sensors_value(
'xadc', data_probe, 'iio', 'name')[0]
temp = str((raw_val['in_temp0_raw'] + raw_val['in_temp0_offset']) \
* raw_val['in_temp0_scale'] / 1000)
except ValueError:
self.log.warning("Error when converting temperature value")
except KeyError:
self.log.warning("Can't read FPGA temperature!")
return {
'name': 'temp_fpga',
'type': 'REALNUM',
'unit': 'C',
'value': temp
}
###########################################################################
# EEPROMs
###########################################################################
def get_mb_eeprom(self):
"""
Return a dictionary with EEPROM contents.
All key/value pairs are string -> string.
We don't actually return the EEPROM contents, instead, we return the
mboard info again. This filters the EEPROM contents to what we think
the user wants to know/see.
"""
return self.mboard_info
def set_mb_eeprom(self, eeprom_vals):
"""
See PeriphManagerBase.set_mb_eeprom() for docs.
"""
self.log.warn("Called set_mb_eeprom(), but not implemented!")
def get_db_eeprom(self, dboard_idx):
"""
See PeriphManagerBase.get_db_eeprom() for docs.
"""
if dboard_idx != E310_DBOARD_SLOT_IDX:
self.log.warn("Trying to access invalid dboard index {}. "
"Using the only dboard.".format(dboard_idx))
db_eeprom_data = copy.copy(self.dboard.device_info)
return db_eeprom_data
def set_db_eeprom(self, dboard_idx, eeprom_data):
"""
See PeriphManagerBase.set_db_eeprom() for docs.
"""
self.log.warn("Called set_db_eeprom(), but not implemented!")
###########################################################################
# Component updating
###########################################################################
# Note: Component updating functions defined by ZynqComponents
@no_rpc
def _update_fpga_type(self):
"""Update the fpga type stored in the updateable components"""
fpga_type = "" # FIXME
self.log.debug(
"Updating mboard FPGA type info to {}".format(fpga_type))
self.updateable_components['fpga']['type'] = fpga_type
#######################################################################
# Timekeeper API
#######################################################################
def get_clocks(self):
"""
Gets the RFNoC-related clocks present in the FPGA design
"""
return [{
'name': 'radio_clk',
'freq': str(self.dboard.get_master_clock_rate()),
'mutable': 'true'
}, {
'name': 'bus_clk',
'freq': str(100e6),
}]
class e31x(ZynqComponents, PeriphManagerBase):
"""
Holds E310 specific attributes and methods
"""
#########################################################################
# Overridables
#
# See PeriphManagerBase for documentation on these fields
#########################################################################
description = "E300-Series Device"
# 0x77d2 and 0x77d3
pids = {0x77D2: 'e310_sg1', #sg1
0x77D3: 'e310_sg3'} #sg3
mboard_eeprom_addr = "e0004000.i2c"
mboard_eeprom_offset = 0
mboard_eeprom_max_len = 64
# We have two nvem paths on the E310.
# This one ensures that we get the right path for the MB.
mboard_eeprom_path_index = 1
mboard_info = {"type": "e3xx"}
mboard_sensor_callback_map = {
'ref_locked': 'get_ref_lock_sensor',
'temp_fpga' : 'get_fpga_temp_sensor',
'temp_mb' : 'get_mb_temp_sensor',
}
dboard_eeprom_addr = "e0004000.i2c"
# Actual DB EEPROM bytes are just 28. Reading just a couple more.
# Refer e300_eeprom_manager.hpp
dboard_eeprom_max_len = 32
max_num_dboards = 1
# We're on a Zynq target, so the following two come from the Zynq standard
# device tree overlay (tree/arch/arm/boot/dts/zynq-7000.dtsi)
dboard_spimaster_addrs = ["e0006000.spi"]
# E310-specific settings
# Label for the mboard UIO
mboard_regs_label = "mboard-regs"
# Override the list of updateable components
updateable_components = {
'fpga': {
'callback': "update_fpga",
'path': '/lib/firmware/{}.bin',
'reset': True,
},
'dts': {
'callback': "update_dts",
'path': '/lib/firmware/{}.dts',
'output': '/lib/firmware/{}.dtbo',
'reset': False,
},
}
# This class removes the overlay in tear_down() resulting
# in stale references to methods in the RPC server. Setting
# this to True ensures that the RPC server clears all registered
# methods on unclaim() and registers them on the following claim().
clear_rpc_method_registry_on_unclaim = True
@classmethod
def generate_device_info(cls, eeprom_md, mboard_info, dboard_infos):
"""
Generate dictionary describing the device.
"""
# Add the default PeriphManagerBase information first
device_info = super().generate_device_info(
eeprom_md, mboard_info, dboard_infos)
# Then add E31x-specific information
mb_pid = eeprom_md.get('pid')
device_info['product'] = cls.pids.get(mb_pid, 'unknown')
return device_info
@staticmethod
def list_required_dt_overlays(device_info):
"""
Lists device tree overlays that need to be applied before this class can
be used. List of strings.
Are applied in order.
eeprom_md -- Dictionary of info read out from the mboard EEPROM
device_args -- Arbitrary dictionary of info, typically user-defined
"""
return [device_info['product']]
@staticmethod
def get_idle_dt_overlay(device_info):
"""
Overlay to be applied to enter low power idle state.
"""
# e.g. e310_sg3_idle
idle_overlay = device_info['product'] + '_idle'
return idle_overlay
###########################################################################
# Ctor and device initialization tasks
###########################################################################
def __init__(self, args):
"""
Does partial initialization which loads low power idle image
"""
super(e31x, self).__init__()
# Start clean by removing MPM-owned overlays.
active_overlays = self.list_active_overlays()
mpm_overlays = self.list_owned_overlays()
for overlay in active_overlays:
if overlay in mpm_overlays:
dtoverlay.rm_overlay(overlay)
# Apply idle overlay on boot to save power until
# an application tries to use the device.
self.args_cached = args
self.apply_idle_overlay()
self._device_initialized = False
def _init_normal(self):
"""
Does full initialization
"""
if self._device_initialized:
return
if self.is_idle():
self.remove_idle_overlay()
self.overlay_apply()
self.init_dboards(self.args_cached)
if not self._device_initialized:
# Don't try and figure out what's going on. Just give up.
return
# Initialize _do_not_reload with value from _default_args (mpm.conf)
self._do_not_reload = str2bool(self._default_args.get("no_reload_fpga", "False"))
self._tear_down = False
self._clock_source = None
self._time_source = None
self._available_endpoints = list(range(256))
self.dboard = self.dboards[E310_DBOARD_SLOT_IDX]
try:
self._init_peripherals(self.args_cached)
except Exception as ex:
self.log.error("Failed to initialize motherboard: %s", str(ex))
self._initialization_status = str(ex)
self._device_initialized = False
def _init_dboards(self, dboard_infos, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
dboard_infos -- List of dictionaries as returned from
PeriphManagerBase._get_dboard_eeprom_info()
override_dboard_pids -- List of dboard PIDs to force
default_args -- Default args
"""
# Override the base class's implementation in order to avoid initializing our one "dboard"
# in the same way that, for example, N310's dboards are initialized. Specifically,
# - skip dboard EEPROM setup (we don't have one)
# - change the way we handle SPI devices
if override_dboard_pids:
self.log.warning("Overriding daughterboard PIDs with: {}"
.format(override_dboard_pids))
raise NotImplementedError("Can't override dboard pids")
# We have only one dboard
dboard_info = dboard_infos[0]
# Set up the SPI nodes
spi_nodes = []
for spi_addr in self.dboard_spimaster_addrs:
for spi_node in get_spidev_nodes(spi_addr):
bisect.insort(spi_nodes, spi_node)
self.log.trace("Found spidev nodes: {0}".format(spi_nodes))
if not spi_nodes:
self.log.warning("No SPI nodes for dboard %d.", E310_DBOARD_SLOT_IDX)
else:
dboard_info.update({
'spi_nodes': spi_nodes,
'default_args': default_args,
})
self.dboards.append(E31x_db(E310_DBOARD_SLOT_IDX, **dboard_info))
self.log.info("Found %d daughterboard(s).", len(self.dboards))
def _check_fpga_compat(self):
" Throw an exception if the compat numbers don't match up "
actual_compat = self.mboard_regs_control.get_compat_number()
self.log.debug("Actual FPGA compat number: {:d}.{:d}".format(
actual_compat[0], actual_compat[1]
))
assert_compat_number(
E310_FPGA_COMPAT,
self.mboard_regs_control.get_compat_number(),
component="FPGA",
fail_on_old_minor=True,
log=self.log
)
def _init_ref_clock_and_time(self, default_args):
"""
Initialize clock and time sources. After this function returns, the
reference signals going to the FPGA are valid.
"""
if not self.dboards:
self.log.warning(
"No dboards found, skipping setting clock and time source "
"configuration."
)
self._clock_source = E310_DEFAULT_CLOCK_SOURCE
self._time_source = E310_DEFAULT_TIME_SOURCE
else:
self.set_clock_source(
default_args.get('clock_source', E310_DEFAULT_CLOCK_SOURCE)
)
self.set_time_source(
default_args.get('time_source', E310_DEFAULT_TIME_SOURCE)
)
def _init_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Peripherals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.mboard_info.get('product') in self.pids.values(), \
"Device product could not be determined!"
# Init Mboard Regs
self.mboard_regs_control = MboardRegsControl(
self.mboard_regs_label, self.log)
self.mboard_regs_control.get_git_hash()
self.mboard_regs_control.get_build_timestamp()
self._check_fpga_compat()
self._update_fpga_type()
self.crossbar_base_port = self.mboard_regs_control.get_xbar_baseport()
self.log.debug("crossbar base port: {}".format(self.crossbar_base_port))
# Init clocking
self._init_ref_clock_and_time(args)
# Init CHDR transports
self._xport_mgrs = {
'liberio': E310XportMgrLiberio(self.log.getChild('liberio')),
}
# Init complete.
self.log.debug("mboard info: {}".format(self.mboard_info))
def _read_mboard_eeprom(self):
"""
Read out mboard EEPROM.
Returns a tuple: (eeprom_dict, eeprom_rawdata), where the the former is
a de-serialized dictionary representation of the data, and the latter
is a binary string with the raw data.
If no EEPROM is defined, returns empty values.
"""
if len(self.mboard_eeprom_addr):
(eeprom_head, eeprom_rawdata) = e31x_legacy_eeprom.read_eeprom(
True, # isMotherboard
get_eeprom_paths(self.mboard_eeprom_addr)[self.mboard_eeprom_path_index],
self.mboard_eeprom_offset,
e31x_legacy_eeprom.MboardEEPROM.eeprom_header_format,
e31x_legacy_eeprom.MboardEEPROM.eeprom_header_keys,
self.mboard_eeprom_max_len
)
self.log.trace("Found EEPROM metadata: `{}'"
.format(str(eeprom_head)))
self.log.trace("Read {} bytes of EEPROM data."
.format(len(eeprom_rawdata)))
return eeprom_head, eeprom_rawdata
# Nothing defined? Return defaults.
self.log.trace("No mboard EEPROM path defined. "
"Skipping mboard EEPROM readout.")
return {}, b''
def _get_dboard_eeprom_info(self):
"""
Read back EEPROM info from the daughterboards
"""
if self.dboard_eeprom_addr is None:
self.log.debug("No dboard EEPROM addresses given.")
return []
dboard_eeprom_addrs = self.dboard_eeprom_addr \
if isinstance(self.dboard_eeprom_addr, list) \
else [self.dboard_eeprom_addr]
dboard_eeprom_paths = []
self.log.trace("Identifying dboard EEPROM paths from addrs `{}'..."
.format(",".join(dboard_eeprom_addrs)))
for dboard_eeprom_addr in dboard_eeprom_addrs:
self.log.trace("Resolving %s...", dboard_eeprom_addr)
dboard_eeprom_paths += get_eeprom_paths(dboard_eeprom_addr)
self.log.trace("Found dboard EEPROM paths: {}"
.format(",".join(dboard_eeprom_paths)))
if len(dboard_eeprom_paths) > self.max_num_dboards:
self.log.warning("Found more EEPROM paths than daughterboards. "
"Ignoring some of them.")
dboard_eeprom_paths = dboard_eeprom_paths[:self.max_num_dboards]
dboard_info = []
for dboard_idx, dboard_eeprom_path in enumerate(dboard_eeprom_paths):
self.log.debug("Reading EEPROM info for dboard %d...", dboard_idx)
dboard_eeprom_md, dboard_eeprom_rawdata = e31x_legacy_eeprom.read_eeprom(
False, # is not motherboard.
dboard_eeprom_path,
self.dboard_eeprom_offset,
e31x_legacy_eeprom.DboardEEPROM.eeprom_header_format,
e31x_legacy_eeprom.DboardEEPROM.eeprom_header_keys,
self.dboard_eeprom_max_len
)
self.log.trace("Found dboard EEPROM metadata: `{}'"
.format(str(dboard_eeprom_md)))
self.log.trace("Read %d bytes of dboard EEPROM data.",
len(dboard_eeprom_rawdata))
db_pid = dboard_eeprom_md.get('pid')
if db_pid is None:
self.log.warning("No dboard PID found in dboard EEPROM!")
else:
self.log.debug("Found dboard PID in EEPROM: 0x{:04X}"
.format(db_pid))
dboard_info.append({
'eeprom_md': dboard_eeprom_md,
'eeprom_rawdata': dboard_eeprom_rawdata,
'pid': db_pid,
})
return dboard_info
###########################################################################
# Session init and deinit
###########################################################################
def claim(self):
"""
Fully initializes a device when the rpc_server claim()
gets called to revive the device from idle state to be used
by an UHD application
"""
super(e31x, self).claim()
try:
self._init_normal()
except Exception as ex:
self.log.error("e31x claim() failed: %s", str(ex))
def init(self, args):
"""
Calls init() on the parent class, and then programs the Ethernet
dispatchers accordingly.
"""
if not self._device_initialized:
self.log.warning(
"Cannot run init(), device was never fully initialized!")
return False
if args.get("clock_source", "") != "":
self.set_clock_source(args.get("clock_source"))
if args.get("time_source", "") != "":
self.set_time_source(args.get("time_source"))
if "no_reload_fpga" in args:
self._do_not_reload = str2bool(args.get("no_reload_fpga")) or args.get("no_reload_fpga") == ""
result = super(e31x, self).init(args)
for xport_mgr in itervalues(self._xport_mgrs):
xport_mgr.init(args)
return result
def apply_idle_overlay(self):
"""
Load all overlays required to go into idle power savings mode.
"""
idle_overlay = self.get_idle_dt_overlay(self.device_info)
self.log.debug("Motherboard requests device tree overlay for Idle power savings mode: {}".format(
idle_overlay
))
dtoverlay.apply_overlay_safe(idle_overlay)
def remove_idle_overlay(self):
"""
Remove idle mode overlay.
"""
idle_overlay = self.get_idle_dt_overlay(self.device_info)
self.log.trace("Removing Idle overlay: {}".format(
idle_overlay
))
dtoverlay.rm_overlay(idle_overlay)
def list_owned_overlays(self):
"""
Lists all overlays that can be possibly applied by MPM.
"""
all_overlays = self.list_required_dt_overlays(self.device_info)
all_overlays.append(self.get_idle_dt_overlay(self.device_info))
return all_overlays
def deinit(self):
"""
Clean up after a UHD session terminates.
"""
if not self._device_initialized:
self.log.warning(
"Cannot run deinit(), device was never fully initialized!")
return
super(e31x, self).deinit()
for xport_mgr in itervalues(self._xport_mgrs):
xport_mgr.deinit()
self.log.trace("Resetting SID pool...")
self._available_endpoints = list(range(256))
if not self._do_not_reload:
self.tear_down()
# Reset back to value from _default_args (mpm.conf)
self._do_not_reload = str2bool(self._default_args.get("no_reload_fpga", "False"))
def tear_down(self):
"""
Tear down all members that need to be specially handled before
deconstruction.
For E310, this means the overlay.
"""
self.log.trace("Tearing down E310 device...")
self._tear_down = True
self.dboards = []
self.dboard = None
self.mboard_regs_control = None
self._device_initialized = False
active_overlays = self.list_active_overlays()
self.log.trace("E310 has active device tree overlays: {}".format(
active_overlays
))
for overlay in active_overlays:
dtoverlay.rm_overlay(overlay)
self.apply_idle_overlay()
def is_idle(self):
"""
Determine if the device is in the idle state.
"""
active_overlays = self.list_active_overlays()
idle_overlay = self.get_idle_dt_overlay(self.device_info)
is_idle = idle_overlay in active_overlays
if is_idle:
self.log.trace("Found idle overlay: %s", idle_overlay)
return is_idle
###########################################################################
# Transport API
###########################################################################
def request_xport(
self,
dst_address,
suggested_src_address,
xport_type
):
"""
See PeriphManagerBase.request_xport() for docs.
"""
# Try suggested address first, then just pick the first available one:
src_address = suggested_src_address
if src_address not in self._available_endpoints:
if not self._available_endpoints:
raise RuntimeError(
"Depleted pool of SID endpoints for this device!")
else:
src_address = self._available_endpoints[0]
sid = SID(src_address << 16 | dst_address)
# Note: This SID may change its source address!
self.log.trace(
"request_xport(dst=0x%04X, suggested_src_address=0x%04X, xport_type=%s): " \
"operating on temporary SID: %s",
dst_address, suggested_src_address, str(xport_type), str(sid))
assert self.mboard_info['rpc_connection'] in ('local')
if self.mboard_info['rpc_connection'] == 'local':
return self._xport_mgrs['liberio'].request_xport(
sid,
xport_type,
)
def commit_xport(self, xport_info):
"""
See PeriphManagerBase.commit_xport() for docs.
Reminder: All connections are incoming, i.e. "send" or "TX" means
remote device to local device, and "receive" or "RX" means this local
device to remote device. "Remote device" can be, for example, a UHD
session.
"""
## Go, go, go
assert self.mboard_info['rpc_connection'] in ('local')
sid = SID(xport_info['send_sid'])
self._available_endpoints.remove(sid.src_ep)
self.log.debug("Committing transport for SID %s, xport info: %s",
str(sid), str(xport_info))
if self.mboard_info['rpc_connection'] == 'local':
return self._xport_mgrs['liberio'].commit_xport(sid, xport_info)
###########################################################################
# Device info
###########################################################################
def get_device_info_dyn(self):
"""
Append the device info with current IP addresses.
"""
if not self._device_initialized:
return {}
device_info = {}
device_info.update({
'fpga_version': "{}.{}".format(
*self.mboard_regs_control.get_compat_number()),
'fpga_version_hash': "{:x}.{}".format(
*self.mboard_regs_control.get_git_hash()),
'fpga': self.updateable_components.get('fpga', {}).get('type', ""),
})
return device_info
###########################################################################
# Clock/Time API
###########################################################################
def get_clock_sources(self):
" Lists all available clock sources. "
self.log.trace("Listing available clock sources...")
return ('internal',)
def get_clock_source(self):
" Returns the currently selected clock source "
return self._clock_source
def set_clock_source(self, *args):
"""
Switch reference clock.
Throws if clock_source is not a valid value.
"""
clock_source = args[0]
assert clock_source in self.get_clock_sources()
self.log.debug("Setting clock source to `{}'".format(clock_source))
if clock_source == self.get_clock_source():
self.log.trace("Nothing to do -- clock source already set.")
return
self._clock_source = clock_source
self.mboard_regs_control.set_clock_source(clock_source)
def get_time_sources(self):
" Returns list of valid time sources "
return ['internal', 'external', 'gpsdo']
def get_time_source(self):
" Return the currently selected time source "
return self._time_source
def set_time_source(self, time_source):
" Set a time source "
assert time_source in self.get_time_sources()
if time_source == self.get_time_source():
self.log.trace("Nothing to do -- time source already set.")
return
self._time_source = time_source
self.mboard_regs_control.set_time_source(time_source)
###########################################################################
# Hardware peripheral controls
###########################################################################
def set_fp_gpio_master(self, value):
"""set driver for front panel GPIO
Arguments:
value {unsigned} -- value is a single bit bit mask of 12 pins GPIO
"""
self.mboard_regs_control.set_fp_gpio_master(value)
def get_fp_gpio_master(self):
"""get "who" is driving front panel gpio
The return value is a bit mask of 8 pins GPIO.
0: means the pin is driven by PL
1: means the pin is driven by PS
"""
return self.mboard_regs_control.get_fp_gpio_master()
def set_fp_gpio_radio_src(self, value):
"""set driver for front panel GPIO
Arguments:
value {unsigned} -- value is 2-bit bit mask of 8 pins GPIO
00: means the pin is driven by radio 0
01: means the pin is driven by radio 1
"""
self.mboard_regs_control.set_fp_gpio_radio_src(value)
def get_fp_gpio_radio_src(self):
"""get which radio is driving front panel gpio
The return value is 2-bit bit mask of 8 pins GPIO.
00: means the pin is driven by radio 0
01: means the pin is driven by radio 1
"""
return self.mboard_regs_control.get_fp_gpio_radio_src()
def set_channel_mode(self, channel_mode):
"Set channel mode in FPGA and select which tx channel to use"
self.mboard_regs_control.set_channel_mode(channel_mode)
###########################################################################
# Sensors
###########################################################################
def get_ref_lock_sensor(self):
"""
#TODO: Where is ref lock signal coming from?
"""
self.log.trace("Querying ref lock status.")
lock_status = bool(self.mboard_regs_control.get_refclk_lock())
return {
'name': 'ref_locked',
'type': 'BOOLEAN',
'unit': 'locked' if lock_status else 'unlocked',
'value': str(lock_status).lower(),
}
def get_mb_temp_sensor(self):
"""
Get temperature sensor reading of the E310.
"""
self.log.trace("Reading temperature.")
temp = '-1'
raw_val = {}
data_probes = ['temp1_input']
try:
for data_probe in data_probes:
raw_val[data_probe] = read_sysfs_sensors_value('jc-42.4-temp', data_probe, 'hwmon', 'name')[0]
temp = str(raw_val['temp1_input'] / 1000)
except ValueError:
self.log.warning("Error when converting temperature value")
except KeyError:
self.log.warning("Can't read temp on thermal_zone".format(sensor))
return {
'name': 'temp_mb',
'type': 'REALNUM',
'unit': 'C',
'value': temp
}
def get_fpga_temp_sensor(self):
"""
Get temperature sensor reading of the E310.
"""
self.log.trace("Reading temperature.")
temp = '-1'
raw_val = {}
data_probes = ['in_temp0_raw', 'in_temp0_scale', 'in_temp0_offset']
try:
for data_probe in data_probes:
raw_val[data_probe] = read_sysfs_sensors_value('xadc', data_probe, 'iio', 'name')[0]
temp = str((raw_val['in_temp0_raw'] + raw_val['in_temp0_offset']) * raw_val['in_temp0_scale'] / 1000)
except ValueError:
self.log.warning("Error when converting temperature value")
except KeyError:
self.log.warning("Can't read temp on thermal_zone".format(sensor))
return {
'name': 'temp_fpga',
'type': 'REALNUM',
'unit': 'C',
'value': temp
}
###########################################################################
# EEPROMs
###########################################################################
def get_mb_eeprom(self):
"""
Return a dictionary with EEPROM contents.
All key/value pairs are string -> string.
We don't actually return the EEPROM contents, instead, we return the
mboard info again. This filters the EEPROM contents to what we think
the user wants to know/see.
"""
return self.mboard_info
def set_mb_eeprom(self, eeprom_vals):
"""
See PeriphManagerBase.set_mb_eeprom() for docs.
"""
self.log.warn("Called set_mb_eeprom(), but not implemented!")
raise NotImplementedError
def get_db_eeprom(self, dboard_idx):
"""
See PeriphManagerBase.get_db_eeprom() for docs.
"""
if dboard_idx != E310_DBOARD_SLOT_IDX:
self.log.warn("Trying to access invalid dboard index {}. "
"Using the only dboard.".format(dboard_idx))
db_eeprom_data = copy.copy(self.dboard.device_info)
return db_eeprom_data
def set_db_eeprom(self, dboard_idx, eeprom_data):
self.log.warn("Called set_db_eeprom(), but not implemented!")
raise NotImplementedError
###########################################################################
# Component updating
###########################################################################
# Note: Component updating functions defined by ZynqComponents
@no_rpc
def _update_fpga_type(self):
"""Update the fpga type stored in the updateable components"""
fpga_type = self.mboard_regs_control.get_fpga_type()
self.log.debug("Updating mboard FPGA type info to {}".format(fpga_type))
self.updateable_components['fpga']['type'] = fpga_type