def _init_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Periphals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.device_info.get('product') in self.product_map.values(), \
"Device product could not be determined!"
# Init peripherals
self.log.trace("Initializing TCA6424 port expander controls...")
self._gpios = TCA6424(int(self.mboard_info['rev']))
self.log.trace("Initializing back panel LED controls...")
self._bp_leds = BackpanelGPIO()
self.log.trace("Enabling power of MGT156MHZ clk")
self._gpios.set("PWREN-CLK-MGT156MHz")
self.enable_1g_ref_clock()
self.enable_wr_ref_clock()
self.enable_gps(
enable=str2bool(
args.get('enable_gps', N3XX_DEFAULT_ENABLE_GPS)
)
)
self.enable_fp_gpio(
enable=str2bool(
args.get(
'enable_fp_gpio',
N3XX_DEFAULT_ENABLE_FPGPIO
)
)
)
# 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.enable_ref_clock(enable=True)
self._ext_clock_freq = None
self._init_ref_clock_and_time(args)
self._init_meas_clock()
# Init CHDR transports
self._xport_mgrs = {
'udp': N3xxXportMgrUDP(self.log.getChild('UDP')),
'liberio': N3xxXportMgrLiberio(self.log.getChild('liberio')),
}
# Spawn status monitoring thread
self.log.trace("Spawning status monitor thread...")
self._status_monitor_thread = threading.Thread(
target=self._monitor_status,
name="N3xxStatusMonitorThread",
daemon=True,
)
self._status_monitor_thread.start()
# Init complete.
self.log.debug("Device info: {}".format(self.device_info))
def __init__(self, args):
self._tear_down = False
self._status_monitor_thread = None
self._ext_clock_freq = None
self._clock_source = None
self._time_source = None
self._bp_leds = None
self._gpsd = None
self._qsfp_retimer = None
super(n3xx, self).__init__()
try:
# Init peripherals
# these peripherals are specific to mboard and
# need to configured before applying fpga overlay
args = self._update_default_args(args)
self._gpios = TCA6424(int(self.mboard_info['rev']))
self.log.trace("Enabling power of MGT156MHZ clk")
self._gpios.set("PWREN-CLK-MGT156MHz")
self._gps_enabled = str2bool(
args.get('enable_gps', N3XX_DEFAULT_ENABLE_GPS))
if not self._gps_enabled:
self.log.info("Disabling GPS (gpsdo reference and time/location data).")
self.enable_1g_ref_clock()
self.enable_wr_ref_clock()
self.enable_gps(enable=self._gps_enabled)
self.enable_fp_gpio(
enable=str2bool(
args.get(
'enable_fp_gpio',
N3XX_DEFAULT_ENABLE_FPGPIO
)
)
)
# Apply overlay
self.overlay_apply()
# Run dboards init
self.init_dboards(args)
if not self._device_initialized:
# Don't try and figure out what's going on. Just give up.
return
self._init_peripherals(args)
except BaseException as ex:
self.log.error("Failed to initialize motherboard: %s", str(ex))
self._initialization_status = str(ex)
self._device_initialized = False
try:
if not args.get('skip_boot_init', False):
self.init(args)
except BaseException as ex:
self.log.warning("Failed to initialize device on boot: %s", str(ex))
def __init__(self, args):
self._tear_down = False
self._status_monitor_thread = None
self._ext_clock_freq = None
self._clock_source = None
self._time_source = None
self._available_endpoints = list(range(256))
self._bp_leds = None
self._gpsd = None
self._qsfp_retimer = None
super(n3xx, self).__init__()
try:
# Init peripherals
# these peripherals are specific to mboard and
# need to configured before applying fpga overlay
self._gpios = TCA6424(int(self.mboard_info['rev']))
self.log.trace("Enabling power of MGT156MHZ clk")
self._gpios.set("PWREN-CLK-MGT156MHz")
self.enable_1g_ref_clock()
self.enable_wr_ref_clock()
self.enable_gps(
enable=str2bool(
args.get('enable_gps', N3XX_DEFAULT_ENABLE_GPS)
)
)
self.enable_fp_gpio(
enable=str2bool(
args.get(
'enable_fp_gpio',
N3XX_DEFAULT_ENABLE_FPGPIO
)
)
)
# Apply overlay
self.overlay_apply()
# Run dboards init
self.init_dboards(args)
if not self._device_initialized:
# Don't try and figure out what's going on. Just give up.
return
self._init_peripherals(args)
except Exception as ex:
self.log.error("Failed to initialize motherboard: %s", str(ex))
self._initialization_status = str(ex)
self._device_initialized = False
try:
if not args.get('skip_boot_init', False):
self.init(args)
except Exception as ex:
self.log.warning("Failed to initialize device on boot: %s", str(ex))
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_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()
# Init peripherals
self.enable_gps(
enable=str2bool(
args.get('enable_gps', E320_DEFAULT_ENABLE_GPS)
)
)
self.enable_fp_gpio(
enable=args.get(
'enable_fp_gpio',
E320_DEFAULT_ENABLE_FPGPIO
)
)
# Init clocking
self._init_ref_clock_and_time(args)
# Init GPSd iface and GPS sensors
self._init_gps_sensors()
# Init CHDR transports
self._xport_mgrs = {
'udp': E320XportMgrUDP(self.log.getChild('UDP'), args),
'liberio': E320XportMgrLiberio(self.log.getChild('liberio')),
}
# Spawn status monitoring thread
self.log.trace("Spawning status monitor thread...")
self._status_monitor_thread = threading.Thread(
target=self._monitor_status,
name="E320StatusMonitorThread",
daemon=True,
)
self._status_monitor_thread.start()
# Init complete.
self.log.debug("mboard info: {}".format(self.mboard_info))
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()
# Init peripherals
self.enable_gps(
enable=str2bool(
args.get('enable_gps', E320_DEFAULT_ENABLE_GPS)
)
)
self.enable_fp_gpio(
enable=args.get(
'enable_fp_gpio',
E320_DEFAULT_ENABLE_FPGPIO
)
)
# Init clocking
self._init_ref_clock_and_time(args)
# Init GPSd iface and GPS sensors
self._init_gps_sensors()
# Init CHDR transports
self._xport_mgrs = {
'udp': E320XportMgrUDP(self.log.getChild('UDP')),
'liberio': E320XportMgrLiberio(self.log.getChild('liberio')),
}
# Spawn status monitoring thread
self.log.trace("Spawning status monitor thread...")
self._status_monitor_thread = threading.Thread(
target=self._monitor_status,
name="E320StatusMonitorThread",
daemon=True,
)
self._status_monitor_thread.start()
# Init complete.
self.log.debug("mboard info: {}".format(self.mboard_info))
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 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 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 __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_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Periphals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.device_info.get('product') in self.product_map.values(), \
"Device product could not be determined!"
# Init peripherals
self.log.trace("Initializing TCA6424 port expander controls...")
self._gpios = TCA6424(int(self.mboard_info['rev']))
self.log.trace("Initializing back panel LED controls...")
self._bp_leds = BackpanelGPIO()
self.log.trace("Enabling power of MGT156MHZ clk")
self._gpios.set("PWREN-CLK-MGT156MHz")
self.enable_1g_ref_clock()
self.enable_wr_ref_clock()
self.enable_gps(
enable=str2bool(
args.get('enable_gps', N3XX_DEFAULT_ENABLE_GPS)
)
)
self.enable_fp_gpio(
enable=str2bool(
args.get(
'enable_fp_gpio',
N3XX_DEFAULT_ENABLE_FPGPIO
)
)
)
# 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()
# Init clocking
self.enable_ref_clock(enable=True)
self._ext_clock_freq = None
self._init_ref_clock_and_time(args)
self._init_meas_clock()
# Init GPSd iface and GPS sensors
self._init_gps_sensors()
# Init QSFP board (if available)
qsfp_i2c = i2c_dev.of_get_i2c_adapter(N32X_QSFP_I2C_LABEL)
if qsfp_i2c:
self.log.debug("Creating QSFP Retimer control object...")
self._qsfp_retimer = RetimerQSFP(qsfp_i2c)
self._qsfp_retimer.set_rate_preset(N32X_DEFAULT_QSFP_RATE_PRESET)
self._qsfp_retimer.set_driver_preset(N32X_DEFAULT_QSFP_DRIVER_PRESET)
elif self.device_info['product'] == 'n320':
# If we have an N320, we should also have the QSFP board, but we
# won't freak out if we can't find it. Maybe someone removed or
# disabled it.
self.log.warning("No QSFP board detected!")
# Init CHDR transports
self._xport_mgrs = {
'udp': N3xxXportMgrUDP(self.log.getChild('UDP')),
'liberio': N3xxXportMgrLiberio(self.log.getChild('liberio')),
}
# Spawn status monitoring thread
self.log.trace("Spawning status monitor thread...")
self._status_monitor_thread = threading.Thread(
target=self._monitor_status,
name="N3xxStatusMonitorThread",
daemon=True,
)
self._status_monitor_thread.start()
# Init complete.
self.log.debug("Device info: {}".format(self.device_info))
def _init_peripherals(self, args):
"""
Turn on all peripherals. This may throw an error on failure, so make
sure to catch it.
Periphals are initialized in the order of least likely to fail, to most
likely.
"""
# Sanity checks
assert self.device_info.get('product') in self.product_map.values(), \
"Device product could not be determined!"
# Init peripherals
self.log.trace("Initializing TCA6424 port expander controls...")
self._gpios = TCA6424(int(self.mboard_info['rev']))
self.log.trace("Initializing back panel LED controls...")
self._bp_leds = BackpanelGPIO()
self.log.trace("Enabling power of MGT156MHZ clk")
self._gpios.set("PWREN-CLK-MGT156MHz")
self.enable_1g_ref_clock()
self.enable_wr_ref_clock()
self.enable_gps(
enable=str2bool(
args.get('enable_gps', N3XX_DEFAULT_ENABLE_GPS)
)
)
self.enable_fp_gpio(
enable=str2bool(
args.get(
'enable_fp_gpio',
N3XX_DEFAULT_ENABLE_FPGPIO
)
)
)
# 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()
# Init clocking
self.enable_ref_clock(enable=True)
self._ext_clock_freq = None
self._init_ref_clock_and_time(args)
self._init_meas_clock()
# Init GPSd iface and GPS sensors
self._init_gps_sensors()
# Init QSFP board (if available)
qsfp_i2c = i2c_dev.of_get_i2c_adapter(N32X_QSFP_I2C_LABEL)
if qsfp_i2c:
self.log.debug("Creating QSFP Retimer control object...")
self._qsfp_retimer = RetimerQSFP(qsfp_i2c)
self._qsfp_retimer.set_rate_preset(N32X_DEFAULT_QSFP_RATE_PRESET)
self._qsfp_retimer.set_driver_preset(N32X_DEFAULT_QSFP_DRIVER_PRESET)
elif self.device_info['product'] == 'n320':
# If we have an N320, we should also have the QSFP board, but we
# won't freak out if we can't find it. Maybe someone removed or
# disabled it.
self.log.warning("No QSFP board detected!")
# Init CHDR transports
self._xport_mgrs = {
'udp': N3xxXportMgrUDP(self.log.getChild('UDP'), args),
'liberio': N3xxXportMgrLiberio(self.log.getChild('liberio')),
}
# Spawn status monitoring thread
self.log.trace("Spawning status monitor thread...")
self._status_monitor_thread = threading.Thread(
target=self._monitor_status,
name="N3xxStatusMonitorThread",
daemon=True,
)
self._status_monitor_thread.start()
# Init complete.
self.log.debug("Device info: {}".format(self.device_info))
def init(self, args, old_args, fast_reinit):
"""
Runs the actual initialization.
Arguments:
args -- Dictionary with user-specified args
old_args -- Dictionary with user-specified args from the previous
initialization run.
fast_reinit -- A hint to do a fast reinit. If nothing changes, then
we don't have to re-init everything and their dogs, we
can skip a whole bunch of things.
"""
# If any of these changes, we need a full re-init:
# TODO: This is not very DRY (because we're repeating default values),
# and is generally smelly design. However, we're being super
# conservative for now, because the only reliable reset sequence we
# have for AD9371 is the full Monty. As we learn more about the chip,
# we might be able to get away with a partial (fast) reinit even when
# some of these values change.
args_that_must_not_change = [
('rx_lo_source', 'internal'),
('tx_lo_source', 'internal'),
('init_cals', 'DEFAULT'),
('tracking_cals', 'DEFAULT'),
('init_cals_timeout', str(self.mykonos.DEFAULT_INIT_CALS_TIMEOUT)),
]
if fast_reinit:
for arg_key, arg_default in args_that_must_not_change:
old_value = old_args.get(arg_key, arg_default)
new_value = args.get(arg_key, arg_default)
if old_value != new_value:
self.log.debug(
"The following init arg changed and caused "
"a full re-init sequence: {}".format(arg_key))
fast_reinit = False
# TODO: Maybe we can switch to digital loopback without running the
# initialization. For now, force init when rfic_digital_loopback is
# set because we're being conservative.
if 'rfic_digital_loopback' in args:
self.log.debug("Using rfic_digital_loopback flag causes a "
"full re-init sequence.")
fast_reinit = False
# If we can't do fast re-init, start from scratch:
if not fast_reinit:
if not self._full_init(
self.mg_class.slot_idx,
self.mg_class.master_clock_rate,
self.mg_class.ref_clock_freq,
args
):
return False
else:
self.log.debug("Running fast re-init with the following settings:")
for arg_key, arg_default in args_that_must_not_change:
self.log.debug(
"{}={}".format(arg_key, args.get(arg_key, arg_default)))
return True
if str2bool(args.get('rfic_digital_loopback')):
self.log.warning(
"RF Functionality Disabled: JESD204b digital loopback "
"enabled inside Mykonos!")
self.mykonos.enable_jesd_loopback(1)
else:
self.mykonos.start_radio()
return True
