1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
#!/usr/bin/env python3
#
# Copyright 2019 Ettus Research, a National Instruments Brand
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
"""
Update the CPLD image for a ZBX daughterboard
"""
import sys
import os
import argparse
import subprocess
import pyudev
from usrp_mpm.mpmlog import get_logger
from usrp_mpm.mpmutils import check_fpga_state
from usrp_mpm.sys_utils.sysfs_gpio import GPIOBank
from usrp_mpm.periph_manager.x4xx_periphs import CtrlportRegs
from usrp_mpm.periph_manager.x4xx_mb_cpld import MboardCPLD
from usrp_mpm.chips.max10_cpld_flash_ctrl import Max10CpldFlashCtrl
from usrp_mpm.sys_utils.udev import dt_symbol_get_spidev
OPENOCD_DIR = "/usr/share/openocd/scripts"
CONFIGS = {
'axi_bitq' : {
'files' : ["fpga/altera-10m50.cfg"],
'cmd' : ["interface axi_bitq; axi_bitq_config %u %u %u; adapter_khz %u",
"init; svf -tap 10m50.tap %s -progress -quiet;exit"]
}
}
AXI_BITQ_ADAPTER_SPEED = 5000
AXI_BITQ_BUS_CLK = 50000000
#The offsets are for JTAG_DB0 and JTAG_DB1 on the motherboard CPLD
DAUGHTERBOARD0_OFFSET = CtrlportRegs.MB_PL_CPLD + 0x60
DAUGHTERBOARD1_OFFSET = CtrlportRegs.MB_PL_CPLD + 0x80
# ZBX flash reconfiguration engine specific offsets
RECONFIG_ENGINE_OFFSET = 0x20
CPLD_MIN_REVISION = 0x20052016
def check_openocd_files(files, logger=None):
"""
Check if all file required by OpenOCD exist
:param logger: logger object
"""
for ocd_file in files:
if not os.path.exists(os.path.join(OPENOCD_DIR, ocd_file)):
if logger is not None:
logger.error("Missing file %s" % os.path.join(OPENOCD_DIR, ocd_file))
return False
return True
def find_offset(dboard):
"""
Find the AXI Bitq UIO device
:param dboard: the dboard, can be either 0 or 1
"""
assert dboard in (0, 1)
return DAUGHTERBOARD0_OFFSET if dboard == 0 else DAUGHTERBOARD1_OFFSET
def find_axi_bitq_uio():
"""
Find the AXI Bitq UIO device
"""
label = 'ctrlport-mboard-regs'
logger = get_logger('update_cpld')
try:
context = pyudev.Context()
for uio in context.list_devices(subsystem="uio"):
uio_label = uio.attributes.asstring('maps/map0/name')
logger.trace("UIO label: {}, match: {} number: {}".format(
uio_label, uio_label == label, uio.sys_number))
if uio_label == label:
return int(uio.sys_number)
return None
except OSError as ex:
logger.error("Error while looking for axi_bitq uio nodes: {}".format(ex))
return None
def do_update_cpld(filename, daughterboards, updater_mode):
"""
Carry out update process for the CPLD
:param filename: path (on device) to the new CPLD image
:param daughterboards: iterable containing dboard numbers to update
:param updater_mode: the updater method to use- Either flash or legacy (JTAG)
:return: True on success, False otherwise
"""
assert updater_mode in ('flash', 'legacy'), \
f"Invalid updater method {updater_mode} given"
logger = get_logger('update_cpld')
logger.info("Programming CPLD of dboards {} with image {} using {} mode"
.format(daughterboards, filename, updater_mode))
if not daughterboards:
logger.error("Invalid daughterboard selection.")
return False
if not os.path.exists(filename):
logger.error("CPLD image file {} not found".format(filename))
return False
if not check_fpga_state(logger=logger):
logger.error("CPLD lines are routed through fabric, FPGA is not programmed, giving up")
return False
if updater_mode == 'legacy':
return jtag_cpld_update(filename, daughterboards, logger)
# updater_mode == flash:
for dboard in daughterboards:
dboard = int(dboard, 10)
logger.info("Updating daughterboard slot {}...".format(dboard))
# enable required daughterboard clock
cpld_spi_node = dt_symbol_get_spidev('mb_cpld')
cpld_control = MboardCPLD(cpld_spi_node, logger)
cpld_control.enable_daughterboard_support_clock(dboard, enable=True)
# setup flash configuration engine and required register access
label = "ctrlport-mboard-regs"
ctrlport_regs = CtrlportRegs(label, logger)
regs = ctrlport_regs.get_db_cpld_iface(dboard)
flash_control = Max10CpldFlashCtrl(
logger, regs, RECONFIG_ENGINE_OFFSET, CPLD_MIN_REVISION)
success = flash_control.update(filename)
# disable clock
cpld_control.enable_daughterboard_support_clock(dboard, enable=False)
if not success:
return success
return True
def jtag_cpld_update(filename, daughterboards, logger=None):
"""
Carry out update process for the CPLD
:param filename: path (on device) to the new CPLD image
:param daughterboards: iterable containing dboard numbers to update
:return: True on success, False otherwise
"""
mode = 'axi_bitq'
config = CONFIGS[mode]
if check_openocd_files(config['files'], logger=logger):
logger.trace("Found required OpenOCD files.")
else:
# check_openocd_files logs errors
return False
for dboard in daughterboards:
logger.info("Updating daughterboard slot {}...".format(dboard))
uio_id = find_axi_bitq_uio()
offset = find_offset(int(dboard, 10))
if uio_id is None or uio_id < 0:
logger.error('Failed to find axi_bitq uio devices. '\
'Make sure overlays are up to date')
return False
cmd = [
"openocd",
"-c", config['cmd'][0] % (uio_id, AXI_BITQ_BUS_CLK, offset, AXI_BITQ_ADAPTER_SPEED),
"-f", (config['files'][0]).strip(),
"-c", config['cmd'][1] % filename]
logger.trace("Update CPLD CMD: {}".format(" ".join(cmd)))
subprocess.call(cmd)
logger.trace("Done programming CPLD...")
return True
def main():
"""
Go, go, go!
"""
# Do some setup
def parse_args():
"""Parse the command-line arguments"""
parser = argparse.ArgumentParser(description='Update the CPLD image on ZBX daughterboard')
parser.add_argument("--file", help="Filename of CPLD image",
default="/lib/firmware/ni/cpld-zbx.rpd")
parser.add_argument("--dboards", help="Slot name to program", default="0,1")
parser.add_argument("--updater",
help="The image updater method to use, either "
" 'legacy' (uses openocd) or 'flash'",
default="flash")
parser.add_argument(
'-v',
'--verbose',
help="Increase verbosity level",
action="count",
default=1
)
parser.add_argument(
'-q',
'--quiet',
help="Decrease verbosity level",
action="count",
default=0
)
return parser.parse_args()
args = parse_args()
# We need to make a logger if we're running stand-alone
from usrp_mpm.mpmlog import get_main_logger
log = get_main_logger(log_default_delta=args.verbose-args.quiet)
dboards = args.dboards.split(",")
if any([x not in ('0', '1') for x in dboards]):
log.error("Unsupported dboards requested: %s", dboards)
return False
return do_update_cpld(args.file, dboards, args.updater)
if __name__ == "__main__":
sys.exit(not main())
|
