Updated HackRF firmware

SoftwareDefined/HackRF/hackrf-2021.03.1/firmware/tools/xsvf.py

@@ -0,0 +1,208 @@
+
+import struct
+
+class XSVFParser(object):
+	def __init__(self):
+		self._handlers = {
+			0x00: self.XCOMPLETE   ,
+			0x01: self.XTDOMASK    ,
+			0x02: self.XSIR        ,
+			0x03: self.XSDR        ,
+			0x04: self.XRUNTEST    ,
+			0x07: self.XREPEAT     ,
+			0x08: self.XSDRSIZE    ,
+			0x09: self.XSDRTDO     ,
+			0x0a: self.XSETSDRMASKS,
+			0x0b: self.XSDRINC     ,
+			0x0c: self.XSDRB       ,
+			0x0d: self.XSDRC       ,
+			0x0e: self.XSDRE       ,
+			0x0f: self.XSDRTDOB    ,
+			0x10: self.XSDRTDOC    ,
+			0x11: self.XSDRTDOE    ,
+			0x12: self.XSTATE      ,
+			0x13: self.XENDIR      ,
+			0x14: self.XENDDR      ,
+			0x15: self.XSIR2       ,
+			0x16: self.XCOMMENT    ,
+			0x17: self.XWAIT       ,
+		}
+
+	def tdomask(self):
+		return self._xtdomask
+		
+	def read_byte(self):
+		return self.read_bytes(1)[0]
+
+	def read_bytes(self, n):
+		c = self._f.read(n)
+		if len(c) == n:
+			return c
+		else:
+			raise RuntimeError('unexpected end of file')
+
+	def read_bits(self, n):
+		length_bytes = (n + 7) >> 3
+		return self.read_bytes(length_bytes)
+
+	def read_u32(self):
+		return struct.unpack('>I', self.read_bytes(4))[0]
+
+	def parse(self, f, debug=False):
+		self._f = f
+		self._debug = debug
+		self._xcomplete = False
+		self._xenddr = None
+		self._xendir = None
+		self._xruntest = 0
+		self._xsdrsize = None
+		self._xtdomask = None
+		self._commands = []
+
+		while self._xcomplete == False:
+			self.read_instruction()
+
+		self._f = None
+
+		return self._commands
+
+	def read_instruction(self):
+		instruction_id = self.read_byte()
+		if instruction_id in self._handlers:
+			instruction_handler = self._handlers[instruction_id]
+			result = instruction_handler()
+			if result is not None:
+				self._commands.append(result)
+		else:
+			raise RuntimeError('unexpected instruction 0x%02x' % instruction_id)
+
+	def XCOMPLETE(self):
+		self._xcomplete = True
+
+	def XTDOMASK(self):
+		length_bits = self._xsdrsize
+		self._xtdomask = self.read_bits(length_bits)
+
+	def XSIR(self):
+		length_bits = self.read_byte()
+		tdi = self.read_bits(length_bits)
+		if self._debug:
+			print('XSIR tdi=%d:%s' % (length_bits, tdi.hex()))
+		return {
+			'type': 'xsir',
+			'tdi': {
+				'length': length_bits,
+				'data': tdi
+			},
+		}
+
+	def XSDR(self):
+		length_bits = self._xsdrsize
+		tdi = self.read_bits(length_bits)
+		if self._debug:
+			print('XSDR tdi=%d:%s' % (length_bits, tdi.hex()))
+		return {
+			'type': 'xsdr',
+			'tdi': {
+				'length': length_bits,
+				'data': tdi,
+			},
+		}
+
+	def XRUNTEST(self):
+		self._xruntest = self.read_u32()
+		if self._debug:
+			print('XRUNTEST number=%d' % self._xruntest)
+
+	def XREPEAT(self):
+		repeat = self.read_byte()
+		# print('XREPEAT times=%d' % repeat)
+
+	def XSDRSIZE(self):
+		self._xsdrsize = self.read_u32()
+
+	def XSDRTDO(self):
+		length_bits = self._xsdrsize
+		tdi = self.read_bits(length_bits)
+		tdo_mask = self._xtdomask
+		self._tdo_expected = (length_bits, self.read_bits(length_bits))
+		wait = self._xruntest
+		if wait == 0:
+			end_state = self._xenddr
+		else:
+			end_state = 1 # Run-Test/Idle
+		if self._debug:
+			print('XSDRTDO tdi=%d:%s tdo_mask=%d:%s tdo_expected=%d:%s end_state=%u wait=%u' % (
+				length_bits, tdi.hex(),
+				length_bits, tdo_mask.hex(),
+				self._tdo_expected[0], self._tdo_expected[1].hex(),
+				end_state,
+				wait,
+			))
+		return {
+			'type': 'xsdrtdo',
+			'tdi': {
+				'length': length_bits,
+				'data': tdi
+			},
+			'tdo_mask': {
+				'length': length_bits,
+				'data': tdo_mask,
+			},
+			'tdo_expected': {
+				'length': self._tdo_expected[0],
+				'data': self._tdo_expected[1],
+			},
+			'end_state': end_state,
+			'wait': wait,
+		}
+
+	def XSETSDRMASKS(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRINC(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRB(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRC(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRE(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRTDOB(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRTDOC(self):
+		raise RuntimeError('unimplemented')
+
+	def XSDRTDOE(self):
+		raise RuntimeError('unimplemented')
+
+	def XSTATE(self):
+		state = self.read_byte()
+		if self._debug:
+			print('XSTATE %u' % state)
+		return {
+			'type': 'xstate',
+			'state': state,
+		}
+
+	def XENDIR(self):
+		self._xendir = self.read_byte()
+
+	def XENDDR(self):
+		self._xenddr = self.read_byte()
+
+	def XSIR2(self):
+		raise RuntimeError('unimplemented')
+
+	def XCOMMENT(self):
+		raise RuntimeError('unimplemented')
+
+	def XWAIT(self):
+		wait_state = self.read_byte()
+		end_state = self.read_byte()
+		wait_time = self.read_u32()