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
219
220
221
222
223
224
225
226
227
228
229
230
231
|
#
# Copyright 2018 Ettus Research, a National Instruments Company
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
"""
E320 dboard (RF and control) implementation module
"""
import threading
from usrp_mpm import lib # Pulls in everything from C++-land
from usrp_mpm.bfrfs import BufferFS
from usrp_mpm.chips import ADF400x
from usrp_mpm.dboard_manager import DboardManagerBase, AD936xDboard
from usrp_mpm.mpmlog import get_logger
from usrp_mpm.sys_utils.udev import get_eeprom_paths
from usrp_mpm.periph_manager.e320_periphs import MboardRegsControl
DEFAULT_MASTER_CLOCK_RATE = 16e6
###############################################################################
# Main dboard control class
###############################################################################
class Neon(DboardManagerBase, AD936xDboard):
"""
Holds all dboard specific information and methods of the neon dboard
"""
#########################################################################
# Overridables
#
# See DboardManagerBase for documentation on these fields
#########################################################################
pids = [0xe320]
rx_sensor_callback_map = {
'ad9361_temperature': 'get_catalina_temp_sensor',
'rssi' : 'get_rssi_sensor',
# For backward compatibility reasons we have the same sensor with two
# different names
'lo_lock' : 'get_rx_lo_lock_sensor',
'lo_locked' : 'get_rx_lo_lock_sensor',
}
tx_sensor_callback_map = {
'ad9361_temperature': 'get_catalina_temp_sensor',
# For backward compatibility reasons we have the same sensor with two
# different names
'lo_lock' : 'get_tx_lo_lock_sensor',
'lo_locked' : 'get_tx_lo_lock_sensor',
}
# Maps the chipselects to the corresponding devices:
spi_chipselect = {"catalina": 0,
"adf4002": 1}
### End of overridables #################################################
# MB regs label: Needed to access the lock bit
mboard_regs_label = "mboard-regs"
# This map describes how the user data is stored in EEPROM. If a dboard rev
# changes the way the EEPROM is used, we add a new entry. If a dboard rev
# is not found in the map, then we go backward until we find a suitable rev
user_eeprom = {
0: {
'label': "e0004000.i2c",
'offset': 1024,
'max_size': 32786 - 1024,
'alignment': 1024,
},
}
def __init__(self, slot_idx, **kwargs):
DboardManagerBase.__init__(self, slot_idx, **kwargs)
AD936xDboard.__init__(
self, lambda: MboardRegsControl(self.mboard_regs_label, self.log))
self.log = get_logger("Neon-{}".format(slot_idx))
self.log.trace("Initializing Neon 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.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 the ADF4002
adf4002_spi = lib.spi.make_spidev(
str(self._spi_nodes['adf4002']),
1000000, # Speed (Hz)
0 # SPI mode
)
self.log.trace("Initializing ADF4002.")
from usrp_mpm.periph_manager.e320 import E320_DEFAULT_INT_CLOCK_FREQ
self.adf4002 = ADF400x(adf4002_spi,
freq=E320_DEFAULT_INT_CLOCK_FREQ,
parent_log=self.log)
# Set up AD9361 / the Neon Manager
self._device = lib.dboards.neon_manager(self._spi_nodes['catalina'])
ad936x_rfic = self._device.get_radio_ctrl()
self.log.trace("Loaded C++ drivers.")
self._init_cat_api(ad936x_rfic)
self.eeprom_fs, self.eeprom_path = self._init_user_eeprom(
self._get_user_eeprom_info(self.rev)
)
def init(self, args):
"""
Initialize the RFIC portion of the E320 (rest happens in e320.init())
"""
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', DEFAULT_MASTER_CLOCK_RATE))
self.init_rfic(master_clock_rate)
return True
###########################################################################
# Clocking
###########################################################################
def update_ref_clock_freq(self, freq):
"""Update the reference clock frequency"""
self.adf4002.set_ref_freq(freq)
###########################################################################
# EEPROM Control
###########################################################################
def _get_user_eeprom_info(self, rev):
"""
Return an EEPROM access map (from self.user_eeprom) based on the rev.
"""
rev_for_lookup = rev
while rev_for_lookup not in self.user_eeprom:
if rev_for_lookup < 0:
raise RuntimeError(
f"Could not find a user EEPROM map for revision {rev}!")
rev_for_lookup -= 1
assert rev_for_lookup in self.user_eeprom, \
"Invalid EEPROM lookup rev!"
return self.user_eeprom[rev_for_lookup]
def _init_user_eeprom(self, eeprom_info):
"""
Reads out user-data EEPROM, and intializes a BufferFS object from that.
"""
self.log.trace("Initializing EEPROM user data...")
eeprom_paths = get_eeprom_paths(eeprom_info.get('label'))
self.log.trace("Found the following EEPROM paths: `{}'".format(
eeprom_paths))
eeprom_path = eeprom_paths[self.slot_idx]
self.log.trace("Selected EEPROM path: `{}'".format(eeprom_path))
user_eeprom_offset = eeprom_info.get('offset', 0)
self.log.trace("Selected EEPROM offset: %d", user_eeprom_offset)
user_eeprom_data = open(eeprom_path, 'rb').read()[user_eeprom_offset:]
self.log.trace("Total EEPROM size is: %d bytes", len(user_eeprom_data))
return BufferFS(
user_eeprom_data,
max_size=eeprom_info.get('max_size'),
alignment=eeprom_info.get('alignment', 1024),
log=self.log
), eeprom_path
def get_user_eeprom_data(self):
"""
Return a dict of blobs stored in the user data section of the EEPROM.
"""
return {
blob_id: self.eeprom_fs.get_blob(blob_id)
for blob_id in self.eeprom_fs.entries.keys()
}
def set_user_eeprom_data(self, eeprom_data):
"""
Update the local EEPROM with the data from eeprom_data.
The actual writing to EEPROM can take some time, and is thus kicked
into a background task. Don't call set_user_eeprom_data() quickly in
succession. Also, while the background task is running, reading the
EEPROM is unavailable and MPM won't be able to reboot until it's
completed.
However, get_user_eeprom_data() will immediately return the correct
data after this method returns.
"""
for blob_id, blob in eeprom_data.items():
self.eeprom_fs.set_blob(blob_id, blob)
self.log.trace("Writing EEPROM info to `{}'".format(self.eeprom_path))
eeprom_offset = self.user_eeprom[self.rev]['offset']
def _write_to_eeprom_task(path, offset, data, log):
" Writer task: Actually write to file "
# Note: This can be sped up by only writing sectors that actually
# changed. To do so, this function would need to read out the
# current state of the file, do some kind of diff, and then seek()
# to the different sectors. When very large blobs are being
# written, it doesn't actually help all that much, of course,
# because in that case, we'd anyway be changing most of the EEPROM.
with open(path, 'r+b') as eeprom_file:
log.trace("Seeking forward to `{}'".format(offset))
eeprom_file.seek(eeprom_offset)
log.trace("Writing a total of {} bytes.".format(
len(self.eeprom_fs.buffer)))
eeprom_file.write(data)
log.trace("EEPROM write complete.")
thread_id = "eeprom_writer_task_{}".format(self.slot_idx)
if any([x.name == thread_id for x in threading.enumerate()]):
# Should this be fatal?
self.log.warn("Another EEPROM writer thread is already active!")
writer_task = threading.Thread(
target=_write_to_eeprom_task,
args=(
self.eeprom_path,
eeprom_offset,
self.eeprom_fs.buffer,
self.log
),
name=thread_id,
)
writer_task.start()
# Now return and let the copy finish on its own. The thread will detach
# and MPM won't terminate this process until the thread is complete.
# This does not stop anyone from killing this process (and the thread)
# while the EEPROM write is happening, though.
|
