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 _init_dboards(self, dboard_infos, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
dboard_infos -- List of dictionaries as returned from
_get_dboard_eeprom_info()
override_dboard_pids -- List of dboard PIDs to force
default_args -- Default args
"""
if override_dboard_pids:
self.log.warning("Overriding daughterboard PIDs with: {}".format(
",".join(override_dboard_pids)))
assert len(dboard_infos) <= self.max_num_dboards
if override_dboard_pids and \
len(override_dboard_pids) < len(dboard_infos):
self.log.warning("--override-db-pids is going to skip dboards.")
dboard_infos = dboard_infos[:len(override_dboard_pids)]
for dboard_idx, dboard_info in enumerate(dboard_infos):
self.log.debug("Initializing dboard %d...", dboard_idx)
db_pid = dboard_info.get('pid')
db_class = get_dboard_class_from_pid(db_pid)
if db_class is None:
self.log.warning("Could not identify daughterboard class "
"for PID {:04X}! Skipping.".format(db_pid))
continue
if len(self.dboard_spimaster_addrs) > dboard_idx:
spi_nodes = sorted(
get_spidev_nodes(self.dboard_spimaster_addrs[dboard_idx]))
self.log.trace("Found spidev nodes: {0}".format(spi_nodes))
else:
spi_nodes = []
self.log.warning("No SPI nodes for dboard %d.", dboard_idx)
dboard_info.update({
'spi_nodes': spi_nodes,
'default_args': default_args,
})
# If the MB supports the DB Iface architecture, pass
# the corresponding DB Iface to the dboard class
if self.db_iface is not None:
dboard_info['db_iface'] = self.db_iface(dboard_idx, self)
# This will actually instantiate the dboard class:
self.dboards.append(db_class(dboard_idx, **dboard_info))
self.log.info("Initialized %d daughterboard(s).", len(self.dboards))
def _init_dboards(self, dboard_infos, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
dboard_infos -- List of dictionaries as returned from
_get_dboard_eeprom_info()
override_dboard_pids -- List of dboard PIDs to force
default_args -- Default args
"""
if override_dboard_pids:
self.log.warning("Overriding daughterboard PIDs with: {}"
.format(",".join(override_dboard_pids)))
assert len(dboard_infos) <= self.max_num_dboards
if len(override_dboard_pids) and \
len(override_dboard_pids) < len(dboard_infos):
self.log.warning("--override-db-pids is going to skip dboards.")
dboard_infos = dboard_infos[:len(override_dboard_pids)]
for dboard_idx, dboard_info in enumerate(dboard_infos):
self.log.debug("Initializing dboard %d...", dboard_idx)
db_pid = dboard_info.get('pid')
db_class = get_dboard_class_from_pid(db_pid)
if db_class is None:
self.log.warning("Could not identify daughterboard class "
"for PID {:04X}! Skipping.".format(db_pid))
continue
if len(self.dboard_spimaster_addrs) > dboard_idx:
spi_nodes = sorted(get_spidev_nodes(
self.dboard_spimaster_addrs[dboard_idx]))
self.log.trace("Found spidev nodes: {0}".format(spi_nodes))
else:
spi_nodes = []
self.log.warning("No SPI nodes for dboard %d.", dboard_idx)
dboard_info.update({
'spi_nodes': spi_nodes,
'default_args': default_args,
})
# This will actually instantiate the dboard class:
self.dboards.append(db_class(dboard_idx, **dboard_info))
self.log.info("Initialized %d daughterboard(s).", len(self.dboards))
def _init_dboards(self, _, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
(dboard_infos) -- N/A
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")
# The DBoard PID is the same as the MBoard PID
db_pid = list(self.pids.keys())[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.",
E320_DBOARD_SLOT_IDX)
dboard_info = {
'eeprom_md': self.mboard_info,
'eeprom_rawdata': self._eeprom_rawdata,
'pid': db_pid,
'spi_nodes': spi_nodes,
'default_args': default_args,
}
# This will actually instantiate the dboard class:
self.dboards.append(Neon(E320_DBOARD_SLOT_IDX, **dboard_info))
self.log.info("Found %d daughterboard(s).", len(self.dboards))
def _init_dboards(self, _, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
(dboard_infos) -- N/A
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")
# The DBoard PID is the same as the MBoard PID
db_pid = list(self.pids.keys())[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.", E320_DBOARD_SLOT_IDX)
dboard_info = {
'eeprom_md': self.mboard_info,
'eeprom_rawdata': self._eeprom_rawdata,
'pid': db_pid,
'spi_nodes': spi_nodes,
'default_args': default_args,
}
# This will actually instantiate the dboard class:
self.dboards.append(Neon(E320_DBOARD_SLOT_IDX, **dboard_info))
self.log.info("Found %d daughterboard(s).", len(self.dboards))
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 _init_dboards(self, override_dboard_pids, default_args):
"""
Initialize all the daughterboards
"""
# Go, go, go!
override_dboard_pids = override_dboard_pids or []
if override_dboard_pids:
self.log.warning("Overriding daughterboard PIDs with: {}".format(
override_dboard_pids))
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]
if len(override_dboard_pids) and \
len(override_dboard_pids) < len(dboard_eeprom_paths):
self.log.warning("--override-db-pids is going to skip dboards.")
dboard_eeprom_paths = \
dboard_eeprom_paths[:len(override_dboard_pids)]
for dboard_idx, dboard_eeprom_path in enumerate(dboard_eeprom_paths):
self.log.debug("Initializing dboard %d...", dboard_idx)
dboard_eeprom_md, dboard_eeprom_rawdata = eeprom.read_eeprom(
dboard_eeprom_path,
eeprom.DboardEEPROM.eeprom_header_format,
eeprom.DboardEEPROM.eeprom_header_keys,
self.dboard_eeprom_magic,
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))
if len(override_dboard_pids) > dboard_idx:
db_pid = override_dboard_pids[dboard_idx]
self.log.warning("Overriding dboard PID for dboard {} "
"with 0x{:04X}.".format(dboard_idx, db_pid))
else:
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))
db_class = get_dboard_class_from_pid(db_pid)
if db_class is None:
self.log.warning("Could not identify daughterboard class "
"for PID {:04X}!".format(db_pid))
continue
if len(self.dboard_spimaster_addrs) > dboard_idx:
spi_nodes = sorted(
get_spidev_nodes(self.dboard_spimaster_addrs[dboard_idx]))
self.log.trace("Found spidev nodes: {0}".format(spi_nodes))
else:
spi_nodes = []
self.log.warning("No SPI nodes for dboard %d.", dboard_idx)
dboard_info = {
'eeprom_md': dboard_eeprom_md,
'eeprom_rawdata': dboard_eeprom_rawdata,
'pid': db_pid,
'spi_nodes': spi_nodes,
'default_args': default_args,
}
# This will actually instantiate the dboard class:
self.dboards.append(db_class(dboard_idx, **dboard_info))
self.log.info("Found %d daughterboard(s).", len(self.dboards))
