2 ## This file is part of the libsigrokdecode project.
4 ## Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
6 ## This program is free software; you can redistribute it and/or modify
7 ## it under the terms of the GNU General Public License as published by
8 ## the Free Software Foundation; either version 3 of the License, or
9 ## (at your option) any later version.
11 ## This program is distributed in the hope that it will be useful,
12 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ## GNU General Public License for more details.
16 ## You should have received a copy of the GNU General Public License
17 ## along with this program; if not, see <http://www.gnu.org/licenses/>.
20 import sigrokdecode as srd
21 from common.plugtrx import (MODULE_ID, ALARM_THRESHOLDS, AD_READOUTS, GCS_BITS,
22 CONNECTOR, TRANSCEIVER, SERIAL_ENCODING, XMIT_TECH, CDR, DEVICE_TECH,
23 ENHANCED_OPTS, AUX_TYPES)
25 class Decoder(srd.Decoder):
29 longname = '10 Gigabit Small Form Factor Pluggable Module (XFP)'
30 desc = 'XFP I²C management interface structures/protocol'
36 ('field-name-and-val', 'Field name and value'),
37 ('field-val', 'Field value'),
40 ('field-names-and-vals', 'Field names and values', (0,)),
41 ('field-vals', 'Field values', (1,)),
48 # Received data items, used as an index into samplenum/data
50 # Start/end sample numbers per data item
52 # Multi-byte structure buffer
54 # Filled in by address 0x7f in low memory
55 self.cur_highmem_page = 0
56 # Filled in by extended ID value in table 2
57 self.have_clei = False
58 # Handlers for each field in the structure, keyed by the end
59 # index of that field. Each handler is fed all unhandled bytes
60 # up until that point, so mark unused space with the dummy
61 # handler self.ignore().
62 self.MAP_LOWER_MEMORY = {
65 57: self.alarm_warnings,
69 75: self.wavelength_cr,
78 127: self.page_select,
80 self.MAP_HIGH_TABLE_1 = {
82 129: self.ext_module_id,
84 138: self.transceiver,
85 139: self.serial_encoding,
88 142: self.link_length_smf,
89 143: self.link_length_e50,
90 144: self.link_length_50um,
91 145: self.link_length_625um,
92 146: self.link_length_copper,
93 147: self.device_tech,
100 189: self.wavelength_tolerance,
101 190: self.max_case_temp,
103 195: self.power_supply,
105 219: self.manuf_date,
107 221: self.enhanced_opts,
110 255: self.maybe_ascii,
114 self.out_ann = self.register(srd.OUTPUT_ANN)
116 def decode(self, ss, es, data):
119 # We only care about actual data bytes that are read (for now).
120 if cmd != 'DATA READ':
124 self.sn.append([ss, es])
126 self.buf.append(data)
128 if self.cnt in self.MAP_LOWER_MEMORY:
129 self.MAP_LOWER_MEMORY[self.cnt](self.buf)
131 elif self.cnt < 0x0100 and self.cur_highmem_page == 0x01:
132 # Serial ID memory map
133 if self.cnt in self.MAP_HIGH_TABLE_1:
134 self.MAP_HIGH_TABLE_1[self.cnt](self.buf)
138 def annotate(self, key, value, start_cnt=None, end_cnt=None):
139 if start_cnt is None:
140 start_cnt = self.cnt - len(self.buf) + 1
143 self.put(self.sn[start_cnt][0], self.sn[end_cnt][1],
144 self.out_ann, [0, [key + ": " + value]])
145 self.put(self.sn[start_cnt][0], self.sn[end_cnt][1],
146 self.out_ann, [1, [value]])
148 # Placeholder handler, needed to advance the buffer past unused or
149 # reserved space in the structures.
150 def ignore(self, data):
153 # Show as ASCII if possible
154 def maybe_ascii(self, data):
155 for i in range(len(data)):
156 if data[i] >= 0x20 and data[i] < 0x7f:
157 cnt = self.cnt - len(data) + 1
158 self.annotate("Vendor ID", chr(data[i]), cnt, cnt)
160 # Convert 16-bit two's complement values, with each increment
161 # representing 1/256C, to degrees Celsius.
162 def to_temp(self, value):
164 value = -((value ^ 0xffff) + 1)
166 return "%.1f C" % temp
168 # TX bias current in uA. Each increment represents 0.2uA
169 def to_current(self, value):
170 current = value / 500000.0
171 return "%.1f mA" % current
173 # Power in mW, with each increment representing 0.1uW
174 def to_power(self, value):
175 power = value / 10000.0
176 return "%.2f mW" % power
178 # Wavelength in increments of 0.05nm
179 def to_wavelength(self, value):
183 # Wavelength in increments of 0.005nm
184 def to_wavelength_tolerance(self, value):
186 return "%.1f nm" % wl
188 def module_id(self, data):
189 self.annotate("Module identifier", MODULE_ID.get(data[0], "Unknown"))
191 def signal_cc(self, data):
192 # No good data available.
193 if (data[0] != 0x00):
194 self.annotate("Signal Conditioner Control", "%.2x" % data[0])
196 def alarm_warnings(self, data):
197 cnt_idx = self.cnt - len(data)
201 # Skip over reserved A/D flag thresholds
203 value = (data[idx] << 8) | data[idx + 1]
205 name = ALARM_THRESHOLDS.get(idx, "...")
206 if idx in (0, 2, 4, 6):
207 self.annotate(name, self.to_temp(value),
208 cnt_idx + idx, cnt_idx + idx + 1)
209 elif idx in (16, 18, 20, 22):
210 self.annotate(name, self.to_current(value),
211 cnt_idx + idx, cnt_idx + idx + 1)
212 elif idx in (24, 26, 28, 30, 32, 34, 36, 38):
213 self.annotate(name, self.to_power(value),
214 cnt_idx + idx, cnt_idx + idx + 1)
216 self.annotate(name, "%d" % name, value, cnt_idx + idx,
221 # No good data available.
223 self.annotate("VPS", "%.2x%.2x" % (data[0], data[1]))
226 # No good data available.
228 self.annotate("BER", str(data))
230 def wavelength_cr(self, data):
231 # No good data available.
232 if (data != [0, 0, 0, 0]):
233 self.annotate("WCR", str(data))
235 def fec_cr(self, data):
236 if (data != [0, 0, 0, 0]):
237 self.annotate("FEC", str(data))
239 def int_ctrl(self, data):
240 # No good data available. Also boring.
243 out.append("%.2x" % d)
244 self.annotate("Interrupt bits", ' '.join(out))
246 def ad_readout(self, data):
247 cnt_idx = self.cnt - len(data) + 1
251 # Skip over reserved field
253 value = (data[idx] << 8) | data[idx + 1]
254 name = AD_READOUTS.get(idx, "...")
257 self.annotate(name, self.to_temp(value),
258 cnt_idx + idx, cnt_idx + idx + 1)
260 self.annotate(name, self.to_current(value),
261 cnt_idx + idx, cnt_idx + idx + 1)
263 self.annotate(name, self.to_power(value),
264 cnt_idx + idx, cnt_idx + idx + 1)
266 self.annotate(name, str(value), cnt_idx + idx,
271 allbits = (data[0] << 8) | data[1]
275 out.append(GCS_BITS[b])
277 self.annotate("General Control/Status", ', '.join(out))
279 def page_select(self, data):
280 self.cur_highmem_page = data[0]
282 def ext_module_id(self, data):
283 out = ["Power level %d module" % ((data[0] >> 6) + 1)]
284 if data[0] & 0x20 == 0:
286 if data[0] & 0x10 == 0:
287 out.append("TX ref clock input required")
288 if data[0] & 0x08 == 0:
289 self.have_clei = True
290 self.annotate("Extended id", ', '.join(out))
292 def connector(self, data):
293 if data[0] in CONNECTOR:
294 self.annotate("Connector", CONNECTOR[data[0]])
296 def transceiver(self, data):
304 if len(TRANSCEIVER[t]) < b + 1:
305 out.append("(unknown)")
307 out.append(TRANSCEIVER[t][b])
309 self.annotate("Transceiver compliance", ', '.join(out))
311 def serial_encoding(self, data):
316 if len(SERIAL_ENCODING) < b + 1:
317 out.append("(unknown)")
319 out.append(SERIAL_ENCODING[b])
321 self.annotate("Serial encoding support", ', '.join(out))
323 def br_min(self, data):
324 # Increments represent 100Mb/s
325 rate = data[0] / 10.0
326 self.annotate("Minimum bit rate", "%.3f GB/s" % rate)
328 def br_max(self, data):
329 # Increments represent 100Mb/s
330 rate = data[0] / 10.0
331 self.annotate("Maximum bit rate", "%.3f GB/s" % rate)
333 def link_length_smf(self, data):
335 length = "(standard)"
339 length = "%d km" % data[0]
340 self.annotate("Link length (SMF)", length)
342 def link_length_e50(self, data):
344 length = "(standard)"
348 length = "%d m" % (data[0] * 2)
349 self.annotate("Link length (extended, 50μm MMF)", length)
351 def link_length_50um(self, data):
353 length = "(standard)"
357 length = "%d m" % data[0]
358 self.annotate("Link length (50μm MMF)", length)
360 def link_length_625um(self, data):
362 length = "(standard)"
366 length = "%d m" % (data[0])
367 self.annotate("Link length (62.5μm MMF)", length)
369 def link_length_copper(self, data):
375 length = "%d m" % (data[0] * 2)
376 self.annotate("Link length (copper)", length)
378 def device_tech(self, data):
381 if xmit <= len(XMIT_TECH) - 1:
382 out.append("%s transmitter" % XMIT_TECH[xmit])
385 out.append(DEVICE_TECH[b][(dev >> (3 - b)) & 0x01])
386 self.annotate("Device technology", ', '.join(out))
388 def vendor(self, data):
389 name = bytes(data).strip().decode('ascii').strip('\x00')
391 self.annotate("Vendor", name)
400 self.annotate("CDR support", ', '.join(out))
402 def vendor_oui(self, data):
403 if data != [0, 0, 0]:
404 self.annotate("Vendor OUI", "%.2X-%.2X-%.2X" % tuple(data))
406 def vendor_pn(self, data):
407 name = bytes(data).strip().decode('ascii').strip('\x00')
409 self.annotate("Vendor part number", name)
411 def vendor_rev(self, data):
412 name = bytes(data).strip().decode('ascii').strip('\x00')
414 self.annotate("Vendor revision", name)
416 def wavelength(self, data):
417 value = (data[0] << 8) | data[1]
418 self.annotate("Wavelength", self.to_wavelength(value))
420 def wavelength_tolerance(self, data):
421 value = (data[0] << 8) | data[1]
422 self.annotate("Wavelength tolerance", self.to_wavelength_tolerance(value))
424 def max_case_temp(self, data):
425 self.annotate("Maximum case temperature", "%d C" % data[0])
427 def power_supply(self, data):
429 self.annotate("Max power dissipation",
430 "%.3f W" % (data[0] * 0.02), self.cnt - 3, self.cnt - 3)
431 self.annotate("Max power dissipation (powered down)",
432 "%.3f W" % (data[1] * 0.01), self.cnt - 2, self.cnt - 2)
433 value = (data[2] >> 4) * 0.050
434 self.annotate("Max current required (5V supply)",
435 "%.3f A" % value, self.cnt - 1, self.cnt - 1)
436 value = (data[2] & 0x0f) * 0.100
437 self.annotate("Max current required (3.3V supply)",
438 "%.3f A" % value, self.cnt - 1, self.cnt - 1)
439 value = (data[3] >> 4) * 0.100
440 self.annotate("Max current required (1.8V supply)",
441 "%.3f A" % value, self.cnt, self.cnt)
442 value = (data[3] & 0x0f) * 0.050
443 self.annotate("Max current required (-5.2V supply)",
444 "%.3f A" % value, self.cnt, self.cnt)
446 def vendor_sn(self, data):
447 name = bytes(data).strip().decode('ascii').strip('\x00')
449 self.annotate("Vendor serial number", name)
451 def manuf_date(self, data):
452 y = int(bytes(data[0:2])) + 2000
453 m = int(bytes(data[2:4]))
454 d = int(bytes(data[4:6]))
455 mnf = "%.4d-%.2d-%.2d" % (y, m, d)
456 lot = bytes(data[6:]).strip().decode('ascii').strip('\x00')
459 self.annotate("Manufacturing date", mnf)
461 def diag_mon(self, data):
464 out.append("BER support")
466 out.append("no BER support")
468 out.append("average power measurement")
470 out.append("OMA power measurement")
471 self.annotate("Diagnostic monitoring", ', '.join(out))
473 def enhanced_opts(self, data):
478 out.append(ENHANCED_OPTS[b])
480 self.annotate("Enhanced option support", ', '.join(out))
482 def aux_mon(self, data):
483 aux = AUX_TYPES[data[0] >> 4]
484 self.annotate("AUX1 monitoring", aux)
485 aux = AUX_TYPES[data[0] & 0x0f]
486 self.annotate("AUX2 monitoring", aux)