-#!/usr/bin/python3.0\r
-\r
-# Copyright 2008, SoftPLC Corporation http://softplc.com\r
-# Dick Hollenbeck dick@softplc.com\r
-\r
-\r
-# This program is free software; you can redistribute it and/or\r
-# modify it under the terms of the GNU General Public License\r
-# as published by the Free Software Foundation; either version 2\r
-# of the License, or (at your option) any later version.\r
-#\r
-# This program is distributed in the hope that it will be useful,\r
-# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
-# GNU General Public License for more details.\r
-#\r
-# You should have received a copy of the GNU General Public License\r
-# along with this program; if not, you may find one here:\r
-# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html\r
-# or you may search the http://www.gnu.org website for the version 2 license,\r
-# or you may write to the Free Software Foundation, Inc.,\r
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\r
-\r
-\r
-# A python program to convert an SVF file to an XSVF file. There is an\r
-# option to include comments containing the source file line number from the origin\r
-# SVF file before each outputted XSVF statement.\r
-#\r
-# We deviate from the XSVF spec in that we introduce a new command called\r
-# XWAITSTATE which directly flows from the SVF RUNTEST command. Unfortunately\r
-# XRUNSTATE was ill conceived and is not used here. We also add support for the\r
-# three Lattice extensions to SVF: LCOUNT, LDELAY, and LSDR. The xsvf file\r
-# generated from this program is suitable for use with the xsvf player in\r
-# OpenOCD with my modifications to xsvf.c.\r
-#\r
-# This program is written for python 3.0, and it is not easy to change this\r
-# back to 2.x. You may find it easier to use python 3.x even if that means\r
-# building it.\r
-\r
-\r
-import re\r
-import sys\r
-import struct\r
-\r
-\r
-# There are both ---<Lexer>--- and ---<Parser>--- sections to this program\r
-\r
-\r
-if len( sys.argv ) < 3:\r
- print("usage %s <svf_filename> <xsvf_filename>" % sys.argv[0])\r
- exit(1)\r
-\r
-\r
-inputFilename = sys.argv[1]\r
-outputFilename = sys.argv[2]\r
-\r
-doCOMMENTs = True # Save XCOMMENTs in the output xsvf file\r
-#doCOMMENTs = False # Save XCOMMENTs in the output xsvf file\r
-\r
-xrepeat = 0 # argument to XREPEAT, gives retry count for masked compares\r
-\r
-\r
-#-----< Lexer >---------------------------------------------------------------\r
-\r
-StateBin = (RESET,IDLE,\r
- DRSELECT,DRCAPTURE,DRSHIFT,DREXIT1,DRPAUSE,DREXIT2,DRUPDATE,\r
- IRSELECT,IRCAPTURE,IRSHIFT,IREXIT1,IRPAUSE,IREXIT2,IRUPDATE) = range(16)\r
-\r
-# Any integer index into this tuple will be equal to its corresponding StateBin value\r
-StateTxt = ("RESET","IDLE",\r
- "DRSELECT","DRCAPTURE","DRSHIFT","DREXIT1","DRPAUSE","DREXIT2","DRUPDATE",\r
- "IRSELECT","IRCAPTURE","IRSHIFT","IREXIT1","IRPAUSE","IREXIT2","IRUPDATE")\r
-\r
-\r
-(XCOMPLETE,XTDOMASK,XSIR,XSDR,XRUNTEST,hole0,hole1,XREPEAT,XSDRSIZE,XSDRTDO,\r
- XSETSDRMASKS,XSDRINC,XSDRB,XSDRC,XSDRE,XSDRTDOB,XSDRTDOC,\r
- XSDRTDOE,XSTATE,XENDIR,XENDDR,XSIR2,XCOMMENT,XWAIT,XWAITSTATE,LCOUNT,LDELAY,LSDR) = range(28)\r
-\r
-#Note: LCOUNT, LDELAY, and LSDR are Lattice extensions to SVF and provide a way to loop back\r
-# and check a completion status, essentially waiting on a part until it signals that it is done.\r
-# For example below: loop 25 times, each time through the loop do a LDELAY (same as a true RUNTEST)\r
-# and exit loop when LSDR compares match.\r
-"""\r
-LCOUNT 25;\r
-! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.\r
-LDELAY DRPAUSE 5 TCK 1.00E-003 SEC;\r
-! Test for the completed status. Match means pass.\r
-! Loop back to LDELAY line if not match and loop count less than 25.\r
-LSDR 1 TDI (0)\r
- TDO (1);\r
-"""\r
-\r
-LineNumber = 1\r
-\r
-def s_ident(scanner, token): return ("ident", token.upper(), LineNumber)\r
-\r
-def s_hex(scanner, token):\r
- global LineNumber\r
- LineNumber = LineNumber + token.count('\n')\r
- token = ''.join(token.split())\r
- return ("hex", token[1:-1], LineNumber)\r
-\r
-def s_int(scanner, token): return ("int", int(token), LineNumber)\r
-def s_float(scanner, token): return ("float", float(token), LineNumber)\r
-#def s_comment(scanner, token): return ("comment", token, LineNumber)\r
-def s_semicolon(scanner, token): return ("semi", token, LineNumber)\r
-\r
-def s_nl(scanner,token):\r
- global LineNumber\r
- LineNumber = LineNumber + 1\r
- #print( 'LineNumber=', LineNumber, file=sys.stderr )\r
- return None\r
-\r
-#2.00E-002\r
-\r
-scanner = re.Scanner([\r
- (r"[a-zA-Z]\w*", s_ident),\r
-# (r"[-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?", s_float),\r
- (r"[-+]?[0-9]+(([.][0-9eE+-]*)|([eE]+[-+]?[0-9]+))", s_float),\r
- (r"\d+", s_int),\r
- (r"\(([0-9a-fA-F]|\s)*\)", s_hex),\r
- (r"(!|//).*$", None),\r
- (r";", s_semicolon),\r
- (r"\n",s_nl),\r
- (r"\s*", None),\r
- ],\r
- re.MULTILINE\r
- )\r
-\r
-# read all svf file input into string "input"\r
-input = open( sys.argv[1] ).read()\r
-\r
-# Lexer:\r
-# create a list of tuples containing (tokenType, tokenValue, LineNumber)\r
-tokens = scanner.scan( input )[0]\r
-\r
-input = None # allow gc to reclaim memory holding file\r
-\r
-#for tokenType, tokenValue, ln in tokens: print( "line %d: %s" % (ln, tokenType), tokenValue )\r
-\r
-\r
-#-----<parser>-----------------------------------------------------------------\r
-\r
-tokVal = tokType = tokLn = None\r
-\r
-tup = iter( tokens )\r
-\r
-def nextTok():\r
- """\r
- Function to read the next token from tup into tokType, tokVal, tokLn (linenumber)\r
- which are globals.\r
- """\r
- global tokType, tokVal, tokLn, tup\r
- tokType, tokVal, tokLn = tup.__next__()\r
-\r
-\r
-class ParseError(Exception):\r
- """A class to hold a parsing error message"""\r
- def __init__(self, linenumber, token, message):\r
- self.linenumber = linenumber\r
- self.token = token\r
- self.message = message\r
- def __str__(self):\r
- global inputFilename\r
- return "Error in file \'%s\' at line %d near token %s\n %s" % (\r
- inputFilename, self.linenumber, repr(self.token), self.message)\r
-\r
-\r
-class MASKSET(object):\r
- """\r
- Class MASKSET holds a set of bit vectors, all of which are related, will all\r
- have the same length, and are associated with one of the seven shiftOps:\r
- HIR, HDR, TIR, TDR, SIR, SDR, LSDR. One of these holds a mask, smask, tdi, tdo, and a\r
- size.\r
- """\r
- def __init__(self, name):\r
- self.empty()\r
- self.name = name\r
-\r
- def empty(self):\r
- self.mask = bytearray()\r
- self.smask = bytearray()\r
- self.tdi = bytearray()\r
- self.tdo = bytearray()\r
- self.size = 0\r
-\r
- def syncLengths( self, sawTDI, sawTDO, sawMASK, sawSMASK, newSize ):\r
- """\r
- Set all the lengths equal in the event some of the masks were\r
- not seen as part of the last change set.\r
- """\r
- if self.size == newSize:\r
- return\r
-\r
- if newSize == 0:\r
- self.empty()\r
- return\r
-\r
- # If an SIR was given without a MASK(), then use a mask of all zeros.\r
- # this is not consistent with the SVF spec, but it makes sense because\r
- # it would be odd to be testing an instruction register read out of a\r
- # tap without giving a mask for it. Also, lattice seems to agree and is\r
- # generating SVF files that comply with this philosophy.\r
- if self.name == 'SIR' and not sawMASK:\r
- self.mask = bytearray( newSize )\r
-\r
- if newSize != len(self.mask):\r
- self.mask = bytearray( newSize )\r
- if self.name == 'SDR': # leave mask for HIR,HDR,TIR,TDR,SIR zeros\r
- for i in range( newSize ):\r
- self.mask[i] = 1\r
-\r
- if newSize != len(self.tdo):\r
- self.tdo = bytearray( newSize )\r
-\r
- if newSize != len(self.tdi):\r
- self.tdi = bytearray( newSize )\r
-\r
- if newSize != len(self.smask):\r
- self.smask = bytearray( newSize )\r
-\r
- self.size = newSize\r
-#-----</MASKSET>-----\r
-\r
-\r
-def makeBitArray( hexString, bitCount ):\r
- """\r
- Converts a packed sequence of hex ascii characters into a bytearray where\r
- each element in the array holds exactly one bit. Only "bitCount" bits are\r
- scanned and these must be the least significant bits in the hex number. That\r
- is, it is legal to have some unused bits in the must significant hex nibble\r
- of the input "hexString". The string is scanned starting from the backend,\r
- then just before returning we reverse the array. This way the append()\r
- method can be used, which I assume is faster than an insert.\r
- """\r
- global tokLn\r
- a = bytearray()\r
- length = bitCount\r
- hexString = list(hexString)\r
- hexString.reverse()\r
- #print(hexString)\r
- for c in hexString:\r
- if length <= 0:\r
- break;\r
- c = int(c, 16)\r
- for mask in [1,2,4,8]:\r
- if length <= 0:\r
- break;\r
- length = length - 1\r
- a.append( (c & mask) != 0 )\r
- if length > 0:\r
- raise ParseError( tokLn, hexString, "Insufficient hex characters for given length of %d" % bitCount )\r
- a.reverse()\r
- #print(a)\r
- return a\r
-\r
-\r
-def makeXSVFbytes( bitarray ):\r
- """\r
- Make a bytearray which is contains the XSVF bits which will be written\r
- directly to disk. The number of bytes needed is calculated from the size\r
- of the argument bitarray.\r
- """\r
- bitCount = len(bitarray)\r
- byteCount = (bitCount+7)//8\r
- ba = bytearray( byteCount )\r
- firstBit = (bitCount % 8) - 1\r
- if firstBit == -1:\r
- firstBit = 7\r
- bitNdx = 0\r
- for byteNdx in range(byteCount):\r
- mask = 1<<firstBit\r
- byte = 0\r
- while mask:\r
- if bitarray[bitNdx]:\r
- byte |= mask;\r
- mask = mask >> 1\r
- bitNdx = bitNdx + 1\r
- ba[byteNdx] = byte\r
- firstBit = 7\r
- return ba\r
-\r
-\r
-def writeComment( outputFile, shiftOp_linenum, shiftOp ):\r
- """\r
- Write an XCOMMENT record to outputFile\r
- """\r
- comment = "%s @%d\0" % (shiftOp, shiftOp_linenum) # \0 is terminating nul\r
- ba = bytearray(1)\r
- ba[0] = XCOMMENT\r
- ba += comment.encode()\r
- outputFile.write( ba )\r
-\r
-\r
-def combineBitVectors( trailer, meat, header ):\r
- """\r
- Combine the 3 bit vectors comprizing a transmission. Since the least\r
- significant bits are sent first, the header is put onto the list last so\r
- they are sent first from that least significant position.\r
- """\r
- ret = bytearray()\r
- ret.extend( trailer )\r
- ret.extend( meat )\r
- ret.extend( header )\r
- return ret\r
-\r
-\r
-def writeRUNTEST( outputFile, run_state, end_state, run_count, min_time, tokenTxt ):\r
- """\r
- Write the output for the SVF RUNTEST command.\r
- run_count - the number of clocks\r
- min_time - the number of seconds\r
- tokenTxt - either RUNTEST or LDELAY\r
- """\r
- # convert from secs to usecs\r
- min_time = int( min_time * 1000000)\r
-\r
- # the SVF RUNTEST command does NOT map to the XSVF XRUNTEST command. Check the SVF spec, then\r
- # read the XSVF command. They are not the same. Use an XSVF XWAITSTATE to\r
- # implement the required behavior of the SVF RUNTEST command.\r
- if doCOMMENTs:\r
- writeComment( output, tokLn, tokenTxt )\r
-\r
- if tokenTxt == 'RUNTEST':\r
- obuf = bytearray(11)\r
- obuf[0] = XWAITSTATE\r
- obuf[1] = run_state\r
- obuf[2] = end_state\r
- struct.pack_into(">i", obuf, 3, run_count ) # big endian 4 byte int to obuf\r
- struct.pack_into(">i", obuf, 7, min_time ) # big endian 4 byte int to obuf\r
- outputFile.write( obuf )\r
- else: # == 'LDELAY'\r
- obuf = bytearray(10)\r
- obuf[0] = LDELAY\r
- obuf[1] = run_state\r
- # LDELAY has no end_state\r
- struct.pack_into(">i", obuf, 2, run_count ) # big endian 4 byte int to obuf\r
- struct.pack_into(">i", obuf, 6, min_time ) # big endian 4 byte int to obuf\r
- outputFile.write( obuf )\r
-\r
-\r
-output = open( outputFilename, mode='wb' )\r
-\r
-hir = MASKSET('HIR')\r
-hdr = MASKSET('HDR')\r
-tir = MASKSET('TIR')\r
-tdr = MASKSET('TDR')\r
-sir = MASKSET('SIR')\r
-sdr = MASKSET('SDR')\r
-\r
-\r
-expecting_eof = True\r
-\r
-\r
-# one of the commands that take the shiftParts after the length, the parse\r
-# template for all of these commands is identical\r
-shiftOps = ('SDR', 'SIR', 'LSDR', 'HDR', 'HIR', 'TDR', 'TIR')\r
-\r
-# the order must correspond to shiftOps, this holds the MASKSETS. 'LSDR' shares sdr with 'SDR'\r
-shiftSets = (sdr, sir, sdr, hdr, hir, tdr, tir )\r
-\r
-# what to expect as parameters to a shiftOp, i.e. after a SDR length or SIR length\r
-shiftParts = ('TDI', 'TDO', 'MASK', 'SMASK')\r
-\r
-# the set of legal states which can trail the RUNTEST command\r
-run_state_allowed = ('IRPAUSE', 'DRPAUSE', 'RESET', 'IDLE')\r
-\r
-enddr_state_allowed = ('DRPAUSE', 'IDLE', 'RESET')\r
-endir_state_allowed = ('IRPAUSE', 'IDLE', 'RESET')\r
-\r
-enddr_state = IDLE\r
-endir_state = IDLE\r
-\r
-frequency = 1.00e+006 # HZ;\r
-\r
-# change detection for xsdrsize and xtdomask\r
-xsdrsize = -1 # the last one sent, send only on change\r
-xtdomask = bytearray() # the last one sent, send only on change\r
-\r
-\r
-# we use a number of single byte writes for the XSVF command below\r
-cmdbuf = bytearray(1)\r
-\r
-\r
-# Save the XREPEAT setting into the file as first thing.\r
-obuf = bytearray(2)\r
-obuf[0] = XREPEAT\r
-obuf[1] = xrepeat\r
-output.write( obuf )\r
-\r
-\r
-try:\r
- while 1:\r
- expecting_eof = True\r
- nextTok()\r
- expecting_eof = False\r
- # print( tokType, tokVal, tokLn )\r
-\r
- if tokVal in shiftOps:\r
- shiftOp_linenum = tokLn\r
- shiftOp = tokVal\r
-\r
- set = shiftSets[shiftOps.index(shiftOp)]\r
-\r
- # set flags false, if we see one later, set that one true later\r
- sawTDI = sawTDO = sawMASK = sawSMASK = False\r
-\r
- nextTok()\r
- if tokType != 'int':\r
- raise ParseError( tokLn, tokVal, "Expecting 'int' giving %s length, got '%s'" % (shiftOp, tokType) )\r
- length = tokVal\r
-\r
- nextTok()\r
-\r
- while tokVal != ';':\r
- if tokVal not in shiftParts:\r
- raise ParseError( tokLn, tokVal, "Expecting TDI, TDO, MASK, SMASK, or ';'")\r
- shiftPart = tokVal\r
-\r
- nextTok()\r
-\r
- if tokType != 'hex':\r
- raise ParseError( tokLn, tokVal, "Expecting hex bits" )\r
- bits = makeBitArray( tokVal, length )\r
-\r
- if shiftPart == 'TDI':\r
- sawTDI = True\r
- set.tdi = bits\r
-\r
- elif shiftPart == 'TDO':\r
- sawTDO = True\r
- set.tdo = bits\r
-\r
- elif shiftPart == 'MASK':\r
- sawMASK = True\r
- set.mask = bits\r
-\r
- elif shiftPart == 'SMASK':\r
- sawSMASK = True\r
- set.smask = bits\r
-\r
- nextTok()\r
-\r
- set.syncLengths( sawTDI, sawTDO, sawMASK, sawSMASK, length )\r
-\r
- # process all the gathered parameters and generate outputs here\r
- if shiftOp == 'SIR':\r
- if doCOMMENTs:\r
- writeComment( output, shiftOp_linenum, 'SIR' )\r
-\r
- tdi = combineBitVectors( tir.tdi, sir.tdi, hir.tdi )\r
- if len(tdi) > 255:\r
- obuf = bytearray(3)\r
- obuf[0] = XSIR2\r
- struct.pack_into( ">h", obuf, 1, len(tdi) )\r
- else:\r
- obuf = bytearray(2)\r
- obuf[0] = XSIR\r
- obuf[1] = len(tdi)\r
- output.write( obuf )\r
- obuf = makeXSVFbytes( tdi )\r
- output.write( obuf )\r
-\r
- elif shiftOp == 'SDR':\r
- if doCOMMENTs:\r
- writeComment( output, shiftOp_linenum, shiftOp )\r
-\r
- if not sawTDO:\r
- # pass a zero filled bit vector for the sdr.mask\r
- mask = combineBitVectors( tdr.mask, bytearray(sdr.size), hdr.mask )\r
- tdi = combineBitVectors( tdr.tdi, sdr.tdi, hdr.tdi )\r
-\r
- if xsdrsize != len(tdi):\r
- xsdrsize = len(tdi)\r
- cmdbuf[0] = XSDRSIZE\r
- output.write( cmdbuf )\r
- obuf = bytearray(4)\r
- struct.pack_into( ">i", obuf, 0, xsdrsize ) # big endian 4 byte int to obuf\r
- output.write( obuf )\r
-\r
- if xtdomask != mask:\r
- xtdomask = mask\r
- cmdbuf[0] = XTDOMASK\r
- output.write( cmdbuf )\r
- obuf = makeXSVFbytes( mask )\r
- output.write( obuf )\r
-\r
- cmdbuf[0] = XSDR\r
- output.write( cmdbuf )\r
- obuf = makeXSVFbytes( tdi )\r
- output.write( obuf )\r
-\r
- else:\r
- mask = combineBitVectors( tdr.mask, sdr.mask, hdr.mask )\r
- tdi = combineBitVectors( tdr.tdi, sdr.tdi, hdr.tdi )\r
- tdo = combineBitVectors( tdr.tdo, sdr.tdo, hdr.tdo )\r
-\r
- if xsdrsize != len(tdi):\r
- xsdrsize = len(tdi)\r
- cmdbuf[0] = XSDRSIZE\r
- output.write( cmdbuf )\r
- obuf = bytearray(4)\r
- struct.pack_into(">i", obuf, 0, xsdrsize ) # big endian 4 byte int to obuf\r
- output.write( obuf )\r
-\r
- if xtdomask != mask:\r
- xtdomask = mask\r
- cmdbuf[0] = XTDOMASK\r
- output.write( cmdbuf )\r
- obuf = makeXSVFbytes( mask )\r
- output.write( obuf )\r
-\r
- cmdbuf[0] = XSDRTDO\r
- output.write( cmdbuf )\r
- obuf = makeXSVFbytes( tdi )\r
- output.write( obuf )\r
- obuf = makeXSVFbytes( tdo )\r
- output.write( obuf )\r
- #print( "len(tdo)=", len(tdo), "len(tdr.tdo)=", len(tdr.tdo), "len(sdr.tdo)=", len(sdr.tdo), "len(hdr.tdo)=", len(hdr.tdo) )\r
-\r
- elif shiftOp == 'LSDR':\r
- if doCOMMENTs:\r
- writeComment( output, shiftOp_linenum, shiftOp )\r
-\r
- mask = combineBitVectors( tdr.mask, sdr.mask, hdr.mask )\r
- tdi = combineBitVectors( tdr.tdi, sdr.tdi, hdr.tdi )\r
- tdo = combineBitVectors( tdr.tdo, sdr.tdo, hdr.tdo )\r
-\r
- if xsdrsize != len(tdi):\r
- xsdrsize = len(tdi)\r
- cmdbuf[0] = XSDRSIZE\r
- output.write( cmdbuf )\r
- obuf = bytearray(4)\r
- struct.pack_into(">i", obuf, 0, xsdrsize ) # big endian 4 byte int to obuf\r
- output.write( obuf )\r
-\r
- if xtdomask != mask:\r
- xtdomask = mask\r
- cmdbuf[0] = XTDOMASK\r
- output.write( cmdbuf )\r
- obuf = makeXSVFbytes( mask )\r
- output.write( obuf )\r
-\r
- cmdbuf[0] = LSDR\r
- output.write( cmdbuf )\r
- obuf = makeXSVFbytes( tdi )\r
- output.write( obuf )\r
- obuf = makeXSVFbytes( tdo )\r
- output.write( obuf )\r
- #print( "len(tdo)=", len(tdo), "len(tdr.tdo)=", len(tdr.tdo), "len(sdr.tdo)=", len(sdr.tdo), "len(hdr.tdo)=", len(hdr.tdo) )\r
-\r
- elif tokVal == 'RUNTEST' or tokVal == 'LDELAY':\r
- # e.g. from lattice tools:\r
- # "RUNTEST IDLE 5 TCK 1.00E-003 SEC;"\r
- saveTok = tokVal\r
- nextTok()\r
- min_time = 0\r
- run_count = 0\r
- max_time = 600 # ten minutes\r
- if tokVal in run_state_allowed:\r
- run_state = StateTxt.index(tokVal)\r
- end_state = run_state # bottom of page 17 of SVF spec\r
- nextTok()\r
- if tokType != 'int' and tokType != 'float':\r
- raise ParseError( tokLn, tokVal, "Expecting 'int' or 'float' after RUNTEST [run_state]")\r
- timeval = tokVal;\r
- nextTok()\r
- if tokVal != 'TCK' and tokVal != 'SEC' and tokVal != 'SCK':\r
- raise ParseError( tokLn, tokVal, "Expecting 'TCK' or 'SEC' or 'SCK' after RUNTEST [run_state] (run_count|min_time)")\r
- if tokVal == 'TCK' or tokVal == 'SCK':\r
- run_count = int( timeval )\r
- else:\r
- min_time = timeval\r
- nextTok()\r
- if tokType == 'int' or tokType == 'float':\r
- min_time = tokVal\r
- nextTok()\r
- if tokVal != 'SEC':\r
- raise ParseError( tokLn, tokVal, "Expecting 'SEC' after RUNTEST [run_state] run_count min_time")\r
- nextTok()\r
- if tokVal == 'MAXIMUM':\r
- nextTok()\r
- if tokType != 'int' and tokType != 'float':\r
- raise ParseError( tokLn, tokVal, "Expecting 'max_time' after RUNTEST [run_state] min_time SEC MAXIMUM")\r
- max_time = tokVal\r
- nextTok()\r
- if tokVal != 'SEC':\r
- raise ParseError( tokLn, tokVal, "Expecting 'max_time' after RUNTEST [run_state] min_time SEC MAXIMUM max_time")\r
- nextTok()\r
- if tokVal == 'ENDSTATE':\r
- nextTok()\r
- if tokVal not in run_state_allowed:\r
- raise ParseError( tokLn, tokVal, "Expecting 'run_state' after RUNTEST .... ENDSTATE")\r
- end_state = StateTxt.index(tokVal)\r
- nextTok()\r
- if tokVal != ';':\r
- raise ParseError( tokLn, tokVal, "Expecting ';' after RUNTEST ....")\r
- # print( "run_count=", run_count, "min_time=", min_time,\r
- # "max_time=", max_time, "run_state=", State[run_state], "end_state=", State[end_state] )\r
- writeRUNTEST( output, run_state, end_state, run_count, min_time, saveTok )\r
-\r
- elif tokVal == 'LCOUNT':\r
- nextTok()\r
- if tokType != 'int':\r
- raise ParseError( tokLn, tokVal, "Expecting integer 'count' after LCOUNT")\r
- loopCount = tokVal\r
- nextTok()\r
- if tokVal != ';':\r
- raise ParseError( tokLn, tokVal, "Expecting ';' after LCOUNT count")\r
- if doCOMMENTs:\r
- writeComment( output, tokLn, 'LCOUNT' )\r
- obuf = bytearray(5)\r
- obuf[0] = LCOUNT\r
- struct.pack_into(">i", obuf, 1, loopCount ) # big endian 4 byte int to obuf\r
- output.write( obuf )\r
-\r
- elif tokVal == 'ENDDR':\r
- nextTok()\r
- if tokVal not in enddr_state_allowed:\r
- raise ParseError( tokLn, tokVal, "Expecting 'stable_state' after ENDDR. (one of: DRPAUSE, IDLE, RESET)")\r
- enddr_state = StateTxt.index(tokVal)\r
- nextTok()\r
- if tokVal != ';':\r
- raise ParseError( tokLn, tokVal, "Expecting ';' after ENDDR stable_state")\r
- if doCOMMENTs:\r
- writeComment( output, tokLn, 'ENDDR' )\r
- obuf = bytearray(2)\r
- obuf[0] = XENDDR\r
- obuf[1] = enddr_state\r
- output.write( obuf )\r
-\r
- elif tokVal == 'ENDIR':\r
- nextTok()\r
- if tokVal not in endir_state_allowed:\r
- raise ParseError( tokLn, tokVal, "Expecting 'stable_state' after ENDIR. (one of: IRPAUSE, IDLE, RESET)")\r
- endir_state = StateTxt.index(tokVal)\r
- nextTok()\r
- if tokVal != ';':\r
- raise ParseError( tokLn, tokVal, "Expecting ';' after ENDIR stable_state")\r
- if doCOMMENTs:\r
- writeComment( output, tokLn, 'ENDIR' )\r
- obuf = bytearray(2)\r
- obuf[0] = XENDIR\r
- obuf[1] = endir_state\r
- output.write( obuf )\r
-\r
- elif tokVal == 'STATE':\r
- nextTok()\r
- ln = tokLn\r
- while tokVal != ';':\r
- if tokVal not in StateTxt:\r
- raise ParseError( tokLn, tokVal, "Expecting 'stable_state' after STATE")\r
- stable_state = StateTxt.index( tokVal )\r
-\r
- if doCOMMENTs and ln != -1:\r
- writeComment( output, ln, 'STATE' )\r
- ln = -1 # save comment only once\r
-\r
- obuf = bytearray(2)\r
- obuf[0] = XSTATE\r
- obuf[1] = stable_state\r
- output.write( obuf )\r
- nextTok()\r
-\r
- elif tokVal == 'FREQUENCY':\r
- nextTok()\r
- if tokVal != ';':\r
- if tokType != 'int' and tokType != 'float':\r
- raise ParseError( tokLn, tokVal, "Expecting 'cycles HZ' after FREQUENCY")\r
- frequency = tokVal\r
- nextTok()\r
- if tokVal != 'HZ':\r
- raise ParseError( tokLn, tokVal, "Expecting 'HZ' after FREQUENCY cycles")\r
- nextTok()\r
- if tokVal != ';':\r
- raise ParseError( tokLn, tokVal, "Expecting ';' after FREQUENCY cycles HZ")\r
-\r
- else:\r
- raise ParseError( tokLn, tokVal, "Unknown token '%s'" % tokVal)\r
-\r
-except StopIteration:\r
- if not expecting_eof:\r
- print( "Unexpected End of File at line ", tokLn )\r
-\r
-except ParseError as pe:\r
- print( "\n", pe )\r
-\r
-finally:\r
- # print( "closing file" )\r
- cmdbuf[0] = XCOMPLETE\r
- output.write( cmdbuf )\r
- output.close()\r
-\r
+#!/usr/bin/python3.0
+
+# Copyright 2008, SoftPLC Corporation http://softplc.com
+# Dick Hollenbeck dick@softplc.com
+
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, you may find one here:
+# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+# or you may search the http://www.gnu.org website for the version 2 license,
+# or you may write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+
+
+# A python program to convert an SVF file to an XSVF file. There is an
+# option to include comments containing the source file line number from the origin
+# SVF file before each outputted XSVF statement.
+#
+# We deviate from the XSVF spec in that we introduce a new command called
+# XWAITSTATE which directly flows from the SVF RUNTEST command. Unfortunately
+# XRUNSTATE was ill conceived and is not used here. We also add support for the
+# three Lattice extensions to SVF: LCOUNT, LDELAY, and LSDR. The xsvf file
+# generated from this program is suitable for use with the xsvf player in
+# OpenOCD with my modifications to xsvf.c.
+#
+# This program is written for python 3.0, and it is not easy to change this
+# back to 2.x. You may find it easier to use python 3.x even if that means
+# building it.
+
+
+import re
+import sys
+import struct
+
+
+# There are both ---<Lexer>--- and ---<Parser>--- sections to this program
+
+
+if len( sys.argv ) < 3:
+ print("usage %s <svf_filename> <xsvf_filename>" % sys.argv[0])
+ exit(1)
+
+
+inputFilename = sys.argv[1]
+outputFilename = sys.argv[2]
+
+doCOMMENTs = True # Save XCOMMENTs in the output xsvf file
+#doCOMMENTs = False # Save XCOMMENTs in the output xsvf file
+
+# pick your file encoding
+file_encoding = 'ISO-8859-1'
+#file_encoding = 'utf-8'
+
+
+xrepeat = 0 # argument to XREPEAT, gives retry count for masked compares
+
+
+#-----< Lexer >---------------------------------------------------------------
+
+StateBin = (RESET,IDLE,
+ DRSELECT,DRCAPTURE,DRSHIFT,DREXIT1,DRPAUSE,DREXIT2,DRUPDATE,
+ IRSELECT,IRCAPTURE,IRSHIFT,IREXIT1,IRPAUSE,IREXIT2,IRUPDATE) = range(16)
+
+# Any integer index into this tuple will be equal to its corresponding StateBin value
+StateTxt = ("RESET","IDLE",
+ "DRSELECT","DRCAPTURE","DRSHIFT","DREXIT1","DRPAUSE","DREXIT2","DRUPDATE",
+ "IRSELECT","IRCAPTURE","IRSHIFT","IREXIT1","IRPAUSE","IREXIT2","IRUPDATE")
+
+
+(XCOMPLETE,XTDOMASK,XSIR,XSDR,XRUNTEST,hole0,hole1,XREPEAT,XSDRSIZE,XSDRTDO,
+ XSETSDRMASKS,XSDRINC,XSDRB,XSDRC,XSDRE,XSDRTDOB,XSDRTDOC,
+ XSDRTDOE,XSTATE,XENDIR,XENDDR,XSIR2,XCOMMENT,XWAIT,XWAITSTATE,
+ LCOUNT,LDELAY,LSDR,XTRST) = range(29)
+
+#Note: LCOUNT, LDELAY, and LSDR are Lattice extensions to SVF and provide a way to loop back
+# and check a completion status, essentially waiting on a part until it signals that it is done.
+# For example below: loop 25 times, each time through the loop do a LDELAY (same as a true RUNTEST)
+# and exit loop when LSDR compares match.
+"""
+LCOUNT 25;
+! Step to DRPAUSE give 5 clocks and wait for 1.00e+000 SEC.
+LDELAY DRPAUSE 5 TCK 1.00E-003 SEC;
+! Test for the completed status. Match means pass.
+! Loop back to LDELAY line if not match and loop count less than 25.
+LSDR 1 TDI (0)
+ TDO (1);
+"""
+
+#XTRST is an opcode Xilinx seemed to have missed and it comes from the SVF TRST statement.
+
+LineNumber = 1
+
+def s_ident(scanner, token): return ("ident", token.upper(), LineNumber)
+
+def s_hex(scanner, token):
+ global LineNumber
+ LineNumber = LineNumber + token.count('\n')
+ token = ''.join(token.split())
+ return ("hex", token[1:-1], LineNumber)
+
+def s_int(scanner, token): return ("int", int(token), LineNumber)
+def s_float(scanner, token): return ("float", float(token), LineNumber)
+#def s_comment(scanner, token): return ("comment", token, LineNumber)
+def s_semicolon(scanner, token): return ("semi", token, LineNumber)
+
+def s_nl(scanner,token):
+ global LineNumber
+ LineNumber = LineNumber + 1
+ #print( 'LineNumber=', LineNumber, file=sys.stderr )
+ return None
+
+#2.00E-002
+
+scanner = re.Scanner([
+ (r"[a-zA-Z]\w*", s_ident),
+# (r"[-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?", s_float),
+ (r"[-+]?[0-9]+(([.][0-9eE+-]*)|([eE]+[-+]?[0-9]+))", s_float),
+ (r"\d+", s_int),
+ (r"\(([0-9a-fA-F]|\s)*\)", s_hex),
+ (r"(!|//).*$", None),
+ (r";", s_semicolon),
+ (r"\n",s_nl),
+ (r"\s*", None),
+ ],
+ re.MULTILINE
+ )
+
+# open the file using the given encoding
+file = open( sys.argv[1], encoding=file_encoding )
+
+# read all svf file input into string "input"
+input = file.read()
+
+file.close()
+
+# Lexer:
+# create a list of tuples containing (tokenType, tokenValue, LineNumber)
+tokens = scanner.scan( input )[0]
+
+input = None # allow gc to reclaim memory holding file
+
+#for tokenType, tokenValue, ln in tokens: print( "line %d: %s" % (ln, tokenType), tokenValue )
+
+
+#-----<parser>-----------------------------------------------------------------
+
+tokVal = tokType = tokLn = None
+
+tup = iter( tokens )
+
+def nextTok():
+ """
+ Function to read the next token from tup into tokType, tokVal, tokLn (linenumber)
+ which are globals.
+ """
+ global tokType, tokVal, tokLn, tup
+ tokType, tokVal, tokLn = tup.__next__()
+
+
+class ParseError(Exception):
+ """A class to hold a parsing error message"""
+ def __init__(self, linenumber, token, message):
+ self.linenumber = linenumber
+ self.token = token
+ self.message = message
+ def __str__(self):
+ global inputFilename
+ return "Error in file \'%s\' at line %d near token %s\n %s" % (
+ inputFilename, self.linenumber, repr(self.token), self.message)
+
+
+class MASKSET(object):
+ """
+ Class MASKSET holds a set of bit vectors, all of which are related, will all
+ have the same length, and are associated with one of the seven shiftOps:
+ HIR, HDR, TIR, TDR, SIR, SDR, LSDR. One of these holds a mask, smask, tdi, tdo, and a
+ size.
+ """
+ def __init__(self, name):
+ self.empty()
+ self.name = name
+
+ def empty(self):
+ self.mask = bytearray()
+ self.smask = bytearray()
+ self.tdi = bytearray()
+ self.tdo = bytearray()
+ self.size = 0
+
+ def syncLengths( self, sawTDI, sawTDO, sawMASK, sawSMASK, newSize ):
+ """
+ Set all the lengths equal in the event some of the masks were
+ not seen as part of the last change set.
+ """
+ if self.size == newSize:
+ return
+
+ if newSize == 0:
+ self.empty()
+ return
+
+ # If an SIR was given without a MASK(), then use a mask of all zeros.
+ # this is not consistent with the SVF spec, but it makes sense because
+ # it would be odd to be testing an instruction register read out of a
+ # tap without giving a mask for it. Also, lattice seems to agree and is
+ # generating SVF files that comply with this philosophy.
+ if self.name == 'SIR' and not sawMASK:
+ self.mask = bytearray( newSize )
+
+ if newSize != len(self.mask):
+ self.mask = bytearray( newSize )
+ if self.name == 'SDR': # leave mask for HIR,HDR,TIR,TDR,SIR zeros
+ for i in range( newSize ):
+ self.mask[i] = 1
+
+ if newSize != len(self.tdo):
+ self.tdo = bytearray( newSize )
+
+ if newSize != len(self.tdi):
+ self.tdi = bytearray( newSize )
+
+ if newSize != len(self.smask):
+ self.smask = bytearray( newSize )
+
+ self.size = newSize
+#-----</MASKSET>-----
+
+
+def makeBitArray( hexString, bitCount ):
+ """
+ Converts a packed sequence of hex ascii characters into a bytearray where
+ each element in the array holds exactly one bit. Only "bitCount" bits are
+ scanned and these must be the least significant bits in the hex number. That
+ is, it is legal to have some unused bits in the must significant hex nibble
+ of the input "hexString". The string is scanned starting from the backend,
+ then just before returning we reverse the array. This way the append()
+ method can be used, which I assume is faster than an insert.
+ """
+ global tokLn
+ a = bytearray()
+ length = bitCount
+ hexString = list(hexString)
+ hexString.reverse()
+ #print(hexString)
+ for c in hexString:
+ if length <= 0:
+ break;
+ c = int(c, 16)
+ for mask in [1,2,4,8]:
+ if length <= 0:
+ break;
+ length = length - 1
+ a.append( (c & mask) != 0 )
+ if length > 0:
+ raise ParseError( tokLn, hexString, "Insufficient hex characters for given length of %d" % bitCount )
+ a.reverse()
+ #print(a)
+ return a
+
+
+def makeXSVFbytes( bitarray ):
+ """
+ Make a bytearray which is contains the XSVF bits which will be written
+ directly to disk. The number of bytes needed is calculated from the size
+ of the argument bitarray.
+ """
+ bitCount = len(bitarray)
+ byteCount = (bitCount+7)//8
+ ba = bytearray( byteCount )
+ firstBit = (bitCount % 8) - 1
+ if firstBit == -1:
+ firstBit = 7
+ bitNdx = 0
+ for byteNdx in range(byteCount):
+ mask = 1<<firstBit
+ byte = 0
+ while mask:
+ if bitarray[bitNdx]:
+ byte |= mask;
+ mask = mask >> 1
+ bitNdx = bitNdx + 1
+ ba[byteNdx] = byte
+ firstBit = 7
+ return ba
+
+
+def writeComment( outputFile, shiftOp_linenum, shiftOp ):
+ """
+ Write an XCOMMENT record to outputFile
+ """
+ comment = "%s @%d\0" % (shiftOp, shiftOp_linenum) # \0 is terminating nul
+ ba = bytearray(1)
+ ba[0] = XCOMMENT
+ ba += comment.encode()
+ outputFile.write( ba )
+
+
+def combineBitVectors( trailer, meat, header ):
+ """
+ Combine the 3 bit vectors comprizing a transmission. Since the least
+ significant bits are sent first, the header is put onto the list last so
+ they are sent first from that least significant position.
+ """
+ ret = bytearray()
+ ret.extend( trailer )
+ ret.extend( meat )
+ ret.extend( header )
+ return ret
+
+
+def writeRUNTEST( outputFile, run_state, end_state, run_count, min_time, tokenTxt ):
+ """
+ Write the output for the SVF RUNTEST command.
+ run_count - the number of clocks
+ min_time - the number of seconds
+ tokenTxt - either RUNTEST or LDELAY
+ """
+ # convert from secs to usecs
+ min_time = int( min_time * 1000000)
+
+ # the SVF RUNTEST command does NOT map to the XSVF XRUNTEST command. Check the SVF spec, then
+ # read the XSVF command. They are not the same. Use an XSVF XWAITSTATE to
+ # implement the required behavior of the SVF RUNTEST command.
+ if doCOMMENTs:
+ writeComment( output, tokLn, tokenTxt )
+
+ if tokenTxt == 'RUNTEST':
+ obuf = bytearray(11)
+ obuf[0] = XWAITSTATE
+ obuf[1] = run_state
+ obuf[2] = end_state
+ struct.pack_into(">i", obuf, 3, run_count ) # big endian 4 byte int to obuf
+ struct.pack_into(">i", obuf, 7, min_time ) # big endian 4 byte int to obuf
+ outputFile.write( obuf )
+ else: # == 'LDELAY'
+ obuf = bytearray(10)
+ obuf[0] = LDELAY
+ obuf[1] = run_state
+ # LDELAY has no end_state
+ struct.pack_into(">i", obuf, 2, run_count ) # big endian 4 byte int to obuf
+ struct.pack_into(">i", obuf, 6, min_time ) # big endian 4 byte int to obuf
+ outputFile.write( obuf )
+
+
+output = open( outputFilename, mode='wb' )
+
+hir = MASKSET('HIR')
+hdr = MASKSET('HDR')
+tir = MASKSET('TIR')
+tdr = MASKSET('TDR')
+sir = MASKSET('SIR')
+sdr = MASKSET('SDR')
+
+
+expecting_eof = True
+
+
+# one of the commands that take the shiftParts after the length, the parse
+# template for all of these commands is identical
+shiftOps = ('SDR', 'SIR', 'LSDR', 'HDR', 'HIR', 'TDR', 'TIR')
+
+# the order must correspond to shiftOps, this holds the MASKSETS. 'LSDR' shares sdr with 'SDR'
+shiftSets = (sdr, sir, sdr, hdr, hir, tdr, tir )
+
+# what to expect as parameters to a shiftOp, i.e. after a SDR length or SIR length
+shiftParts = ('TDI', 'TDO', 'MASK', 'SMASK')
+
+# the set of legal states which can trail the RUNTEST command
+run_state_allowed = ('IRPAUSE', 'DRPAUSE', 'RESET', 'IDLE')
+
+enddr_state_allowed = ('DRPAUSE', 'IDLE')
+endir_state_allowed = ('IRPAUSE', 'IDLE')
+
+trst_mode_allowed = ('ON', 'OFF', 'Z', 'ABSENT')
+
+enddr_state = IDLE
+endir_state = IDLE
+
+frequency = 1.00e+006 # HZ;
+
+# change detection for xsdrsize and xtdomask
+xsdrsize = -1 # the last one sent, send only on change
+xtdomask = bytearray() # the last one sent, send only on change
+
+
+# we use a number of single byte writes for the XSVF command below
+cmdbuf = bytearray(1)
+
+
+# Save the XREPEAT setting into the file as first thing.
+obuf = bytearray(2)
+obuf[0] = XREPEAT
+obuf[1] = xrepeat
+output.write( obuf )
+
+
+try:
+ while 1:
+ expecting_eof = True
+ nextTok()
+ expecting_eof = False
+ # print( tokType, tokVal, tokLn )
+
+ if tokVal in shiftOps:
+ shiftOp_linenum = tokLn
+ shiftOp = tokVal
+
+ set = shiftSets[shiftOps.index(shiftOp)]
+
+ # set flags false, if we see one later, set that one true later
+ sawTDI = sawTDO = sawMASK = sawSMASK = False
+
+ nextTok()
+ if tokType != 'int':
+ raise ParseError( tokLn, tokVal, "Expecting 'int' giving %s length, got '%s'" % (shiftOp, tokType) )
+ length = tokVal
+
+ nextTok()
+
+ while tokVal != ';':
+ if tokVal not in shiftParts:
+ raise ParseError( tokLn, tokVal, "Expecting TDI, TDO, MASK, SMASK, or ';'")
+ shiftPart = tokVal
+
+ nextTok()
+
+ if tokType != 'hex':
+ raise ParseError( tokLn, tokVal, "Expecting hex bits" )
+ bits = makeBitArray( tokVal, length )
+
+ if shiftPart == 'TDI':
+ sawTDI = True
+ set.tdi = bits
+
+ elif shiftPart == 'TDO':
+ sawTDO = True
+ set.tdo = bits
+
+ elif shiftPart == 'MASK':
+ sawMASK = True
+ set.mask = bits
+
+ elif shiftPart == 'SMASK':
+ sawSMASK = True
+ set.smask = bits
+
+ nextTok()
+
+ set.syncLengths( sawTDI, sawTDO, sawMASK, sawSMASK, length )
+
+ # process all the gathered parameters and generate outputs here
+ if shiftOp == 'SIR':
+ if doCOMMENTs:
+ writeComment( output, shiftOp_linenum, 'SIR' )
+
+ tdi = combineBitVectors( tir.tdi, sir.tdi, hir.tdi )
+ if len(tdi) > 255:
+ obuf = bytearray(3)
+ obuf[0] = XSIR2
+ struct.pack_into( ">h", obuf, 1, len(tdi) )
+ else:
+ obuf = bytearray(2)
+ obuf[0] = XSIR
+ obuf[1] = len(tdi)
+ output.write( obuf )
+ obuf = makeXSVFbytes( tdi )
+ output.write( obuf )
+
+ elif shiftOp == 'SDR':
+ if doCOMMENTs:
+ writeComment( output, shiftOp_linenum, shiftOp )
+
+ if not sawTDO:
+ # pass a zero filled bit vector for the sdr.mask
+ mask = combineBitVectors( tdr.mask, bytearray(sdr.size), hdr.mask )
+ tdi = combineBitVectors( tdr.tdi, sdr.tdi, hdr.tdi )
+
+ if xsdrsize != len(tdi):
+ xsdrsize = len(tdi)
+ cmdbuf[0] = XSDRSIZE
+ output.write( cmdbuf )
+ obuf = bytearray(4)
+ struct.pack_into( ">i", obuf, 0, xsdrsize ) # big endian 4 byte int to obuf
+ output.write( obuf )
+
+ if xtdomask != mask:
+ xtdomask = mask
+ cmdbuf[0] = XTDOMASK
+ output.write( cmdbuf )
+ obuf = makeXSVFbytes( mask )
+ output.write( obuf )
+
+ cmdbuf[0] = XSDR
+ output.write( cmdbuf )
+ obuf = makeXSVFbytes( tdi )
+ output.write( obuf )
+
+ else:
+ mask = combineBitVectors( tdr.mask, sdr.mask, hdr.mask )
+ tdi = combineBitVectors( tdr.tdi, sdr.tdi, hdr.tdi )
+ tdo = combineBitVectors( tdr.tdo, sdr.tdo, hdr.tdo )
+
+ if xsdrsize != len(tdi):
+ xsdrsize = len(tdi)
+ cmdbuf[0] = XSDRSIZE
+ output.write( cmdbuf )
+ obuf = bytearray(4)
+ struct.pack_into(">i", obuf, 0, xsdrsize ) # big endian 4 byte int to obuf
+ output.write( obuf )
+
+ if xtdomask != mask:
+ xtdomask = mask
+ cmdbuf[0] = XTDOMASK
+ output.write( cmdbuf )
+ obuf = makeXSVFbytes( mask )
+ output.write( obuf )
+
+ cmdbuf[0] = XSDRTDO
+ output.write( cmdbuf )
+ obuf = makeXSVFbytes( tdi )
+ output.write( obuf )
+ obuf = makeXSVFbytes( tdo )
+ output.write( obuf )
+ #print( "len(tdo)=", len(tdo), "len(tdr.tdo)=", len(tdr.tdo), "len(sdr.tdo)=", len(sdr.tdo), "len(hdr.tdo)=", len(hdr.tdo) )
+
+ elif shiftOp == 'LSDR':
+ if doCOMMENTs:
+ writeComment( output, shiftOp_linenum, shiftOp )
+
+ mask = combineBitVectors( tdr.mask, sdr.mask, hdr.mask )
+ tdi = combineBitVectors( tdr.tdi, sdr.tdi, hdr.tdi )
+ tdo = combineBitVectors( tdr.tdo, sdr.tdo, hdr.tdo )
+
+ if xsdrsize != len(tdi):
+ xsdrsize = len(tdi)
+ cmdbuf[0] = XSDRSIZE
+ output.write( cmdbuf )
+ obuf = bytearray(4)
+ struct.pack_into(">i", obuf, 0, xsdrsize ) # big endian 4 byte int to obuf
+ output.write( obuf )
+
+ if xtdomask != mask:
+ xtdomask = mask
+ cmdbuf[0] = XTDOMASK
+ output.write( cmdbuf )
+ obuf = makeXSVFbytes( mask )
+ output.write( obuf )
+
+ cmdbuf[0] = LSDR
+ output.write( cmdbuf )
+ obuf = makeXSVFbytes( tdi )
+ output.write( obuf )
+ obuf = makeXSVFbytes( tdo )
+ output.write( obuf )
+ #print( "len(tdo)=", len(tdo), "len(tdr.tdo)=", len(tdr.tdo), "len(sdr.tdo)=", len(sdr.tdo), "len(hdr.tdo)=", len(hdr.tdo) )
+
+ elif tokVal == 'RUNTEST' or tokVal == 'LDELAY':
+ # e.g. from lattice tools:
+ # "RUNTEST IDLE 5 TCK 1.00E-003 SEC;"
+ saveTok = tokVal
+ nextTok()
+ min_time = 0
+ run_count = 0
+ max_time = 600 # ten minutes
+ if tokVal in run_state_allowed:
+ run_state = StateTxt.index(tokVal)
+ end_state = run_state # bottom of page 17 of SVF spec
+ nextTok()
+ if tokType != 'int' and tokType != 'float':
+ raise ParseError( tokLn, tokVal, "Expecting 'int' or 'float' after RUNTEST [run_state]")
+ timeval = tokVal;
+ nextTok()
+ if tokVal != 'TCK' and tokVal != 'SEC' and tokVal != 'SCK':
+ raise ParseError( tokLn, tokVal, "Expecting 'TCK' or 'SEC' or 'SCK' after RUNTEST [run_state] (run_count|min_time)")
+ if tokVal == 'TCK' or tokVal == 'SCK':
+ run_count = int( timeval )
+ else:
+ min_time = timeval
+ nextTok()
+ if tokType == 'int' or tokType == 'float':
+ min_time = tokVal
+ nextTok()
+ if tokVal != 'SEC':
+ raise ParseError( tokLn, tokVal, "Expecting 'SEC' after RUNTEST [run_state] run_count min_time")
+ nextTok()
+ if tokVal == 'MAXIMUM':
+ nextTok()
+ if tokType != 'int' and tokType != 'float':
+ raise ParseError( tokLn, tokVal, "Expecting 'max_time' after RUNTEST [run_state] min_time SEC MAXIMUM")
+ max_time = tokVal
+ nextTok()
+ if tokVal != 'SEC':
+ raise ParseError( tokLn, tokVal, "Expecting 'max_time' after RUNTEST [run_state] min_time SEC MAXIMUM max_time")
+ nextTok()
+ if tokVal == 'ENDSTATE':
+ nextTok()
+ if tokVal not in run_state_allowed:
+ raise ParseError( tokLn, tokVal, "Expecting 'run_state' after RUNTEST .... ENDSTATE")
+ end_state = StateTxt.index(tokVal)
+ nextTok()
+ if tokVal != ';':
+ raise ParseError( tokLn, tokVal, "Expecting ';' after RUNTEST ....")
+ # print( "run_count=", run_count, "min_time=", min_time,
+ # "max_time=", max_time, "run_state=", State[run_state], "end_state=", State[end_state] )
+ writeRUNTEST( output, run_state, end_state, run_count, min_time, saveTok )
+
+ elif tokVal == 'LCOUNT':
+ nextTok()
+ if tokType != 'int':
+ raise ParseError( tokLn, tokVal, "Expecting integer 'count' after LCOUNT")
+ loopCount = tokVal
+ nextTok()
+ if tokVal != ';':
+ raise ParseError( tokLn, tokVal, "Expecting ';' after LCOUNT count")
+ if doCOMMENTs:
+ writeComment( output, tokLn, 'LCOUNT' )
+ obuf = bytearray(5)
+ obuf[0] = LCOUNT
+ struct.pack_into(">i", obuf, 1, loopCount ) # big endian 4 byte int to obuf
+ output.write( obuf )
+
+ elif tokVal == 'ENDDR':
+ nextTok()
+ if tokVal not in enddr_state_allowed:
+ raise ParseError( tokLn, tokVal, "Expecting 'stable_state' after ENDDR. (one of: DRPAUSE, IDLE)")
+ enddr_state = StateTxt.index(tokVal)
+ nextTok()
+ if tokVal != ';':
+ raise ParseError( tokLn, tokVal, "Expecting ';' after ENDDR stable_state")
+ if doCOMMENTs:
+ writeComment( output, tokLn, 'ENDDR' )
+ obuf = bytearray(2)
+ obuf[0] = XENDDR
+ # Page 10 of the March 1999 SVF spec shows that RESET is also allowed here.
+ # Yet the XSVF spec has no provision for that, and uses a non-standard, i.e.
+ # boolean argument to XENDDR which only handles two of the 3 intended states.
+ obuf[1] = 1 if enddr_state == DRPAUSE else 0
+ output.write( obuf )
+
+ elif tokVal == 'ENDIR':
+ nextTok()
+ if tokVal not in endir_state_allowed:
+ raise ParseError( tokLn, tokVal, "Expecting 'stable_state' after ENDIR. (one of: IRPAUSE, IDLE)")
+ endir_state = StateTxt.index(tokVal)
+ nextTok()
+ if tokVal != ';':
+ raise ParseError( tokLn, tokVal, "Expecting ';' after ENDIR stable_state")
+ if doCOMMENTs:
+ writeComment( output, tokLn, 'ENDIR' )
+ obuf = bytearray(2)
+ obuf[0] = XENDIR
+ # Page 10 of the March 1999 SVF spec shows that RESET is also allowed here.
+ # Yet the XSVF spec has no provision for that, and uses a non-standard, i.e.
+ # boolean argument to XENDDR which only handles two of the 3 intended states.
+ obuf[1] = 1 if endir_state == IRPAUSE else 0
+ output.write( obuf )
+
+ elif tokVal == 'STATE':
+ nextTok()
+ ln = tokLn
+ while tokVal != ';':
+ if tokVal not in StateTxt:
+ raise ParseError( tokLn, tokVal, "Expecting 'stable_state' after STATE")
+ stable_state = StateTxt.index( tokVal )
+
+ if doCOMMENTs and ln != -1:
+ writeComment( output, ln, 'STATE' )
+ ln = -1 # save comment only once
+
+ obuf = bytearray(2)
+ obuf[0] = XSTATE
+ obuf[1] = stable_state
+ output.write( obuf )
+ nextTok()
+
+ elif tokVal == 'FREQUENCY':
+ nextTok()
+ if tokVal != ';':
+ if tokType != 'int' and tokType != 'float':
+ raise ParseError( tokLn, tokVal, "Expecting 'cycles HZ' after FREQUENCY")
+ frequency = tokVal
+ nextTok()
+ if tokVal != 'HZ':
+ raise ParseError( tokLn, tokVal, "Expecting 'HZ' after FREQUENCY cycles")
+ nextTok()
+ if tokVal != ';':
+ raise ParseError( tokLn, tokVal, "Expecting ';' after FREQUENCY cycles HZ")
+
+ elif tokVal == 'TRST':
+ nextTok()
+ if tokVal not in trst_mode_allowed:
+ raise ParseError( tokLn, tokVal, "Expecting 'ON|OFF|Z|ABSENT' after TRST")
+ trst_mode = tokVal
+ nextTok()
+ if tokVal != ';':
+ raise ParseError( tokLn, tokVal, "Expecting ';' after TRST trst_mode")
+ obuf = bytearray( 2 )
+ obuf[0] = XTRST
+ obuf[1] = trst_mode_allowed.index( trst_mode ) # use the index as the binary argument to XTRST opcode
+ output.write( obuf )
+
+ else:
+ raise ParseError( tokLn, tokVal, "Unknown token '%s'" % tokVal)
+
+except StopIteration:
+ if not expecting_eof:
+ print( "Unexpected End of File at line ", tokLn )
+
+except ParseError as pe:
+ print( "\n", pe )
+
+finally:
+ # print( "closing file" )
+ cmdbuf[0] = XCOMPLETE
+ output.write( cmdbuf )
+ output.close()
+
projects / fw / openocd / blobdiff