1 import c4m_jtag_svfgrammar
3 from cocotb
.binary
import BinaryValue
4 from functools
import singledispatch
6 def decodescanspec(node
):
7 length
= int(str(node
[2]))
8 fstr
= "{:0"+str(node
[2])+"b}"
18 tdi
= BinaryValue(fstr
.format(int(str(g_tdi
[2]),16)), length
)
23 tdo
= BinaryValue(fstr
.format(int(str(g_tdo
[3]),16)), length
)
28 mask
= BinaryValue(fstr
.format(int(str(g_mask
[3]),16)), length
)
33 smask
= BinaryValue(fstr
.format(int(str(g_smask
[3]),16)), length
)
35 return (length
, tdi
, tdo
, mask
, smask
)
38 class SVF_Executor(object):
40 def execute(self
, node
):
41 """This is the generic method"""
43 if False: # Make coroutine work
47 def _execute_NOP(self
, node
):
48 if False: # Make coroutine work
52 def _execute_EndDR(self
, node
):
53 self
._p
("EndDR ignored")
54 if False: # Make coroutine work
58 def _execute_EndIR(self
, node
):
59 self
._p
("EndIR ignored")
60 if False: # Make coroutine work
64 def _execute_Frequency(self
, node
):
65 self
._p
("Frequency ignored")
66 if False: # Make coroutine work
70 def _execute_HDR(self
, node
):
71 self
._p
("HDR ignored")
72 if False: # Make coroutine work
76 def _execute_HIR(self
, node
):
77 self
._p
("HIR ignored")
78 if False: # Make coroutine work
82 def _execute_SDR(self
, node
):
83 self
._p
("Executing SDR")
84 (length
, tdi
, tdo
, mask
, smask
) = decodescanspec(node
)
86 samelength
= length
== self
._d
_length
87 self
._d
_length
= length
91 raise(JTAGException("TDI needs to be specified when length of data changes"))
100 if smask
is not None:
101 self
._d
_smask
= smask
105 yield self
.master
.shift_data(self
._d
_tdi
)
107 if self
._d
_mask
is not None:
108 raise(JTAGException("MASK not supported for SDR"))
109 assert(self
.result
== tdo
)
112 def _execute_SIR(self
, node
):
113 (length
, tdi
, tdo
, mask
, smask
) = decodescanspec(node
)
115 samelength
= length
== self
._i
_length
116 self
._i
_length
= length
120 raise(JTAGException("TDI needs to be specified when length of data changes"))
129 if smask
is not None:
130 self
._i
_smask
= smask
134 self
._p
("Executing SIR ({})".format(self
._i
_tdi
.integer
))
136 yield self
.master
.load_ir(self
._i
_tdi
)
138 if self
._i
_mask
is not None:
139 raise(JTAGException("MASK not supported for SIR"))
140 assert(self
.result
== tdo
)
144 def _execute_State(self
, node
):
146 if False: # Make coroutine work
147 yield PythonTrigger()
150 def _execute_TDR(self
, node
):
152 if False: # Make coroutine work
153 yield PythonTrigger()
156 def _execute_TIR(self
, node
):
158 if False: # Make coroutine work
159 yield PythonTrigger()
162 def _execute_Trst(self
, node
):
163 self
._p
("TRST ignored")
164 if False: # Make coroutine work
165 yield PythonTrigger()
168 def _execute_Runtest(self
, node
):
169 if node
[1] is not None:
170 raise(JTAGException("State specification for RUNTEST not supported"))
171 # TODO: cycle the right number of clocks or wait the right time
172 yield(self
.master
.change_state([0]))
175 def _execute_SVFFile(self
, node
):
176 self
._p
("Executing SVFFile")
177 for statement
in node
.elements
[0]:
178 yield self
.execute(statement
)
180 def __init__(self
, master
):
181 # master is assumed to be a JTAG_Master class
182 # it needs to support methods load_ir() and shift_data()
185 # Due to bug in Grammar definition all possible classes have to have
186 # a dispatch entry otherwise an error will be raised.
187 self
.execute
= singledispatch(self
.execute
)
188 self
.execute
.register(c4m_jtag_svfgrammar
.EmptyLine
, self
._execute
_NOP
)
189 self
.execute
.register(c4m_jtag_svfgrammar
.Comment
, self
._execute
_NOP
)
190 self
.execute
.register(c4m_jtag_svfgrammar
.EndDR
, self
._execute
_EndDR
)
191 self
.execute
.register(c4m_jtag_svfgrammar
.EndIR
, self
._execute
_EndIR
)
192 self
.execute
.register(c4m_jtag_svfgrammar
.Frequency
, self
._execute
_Frequency
)
193 self
.execute
.register(c4m_jtag_svfgrammar
.HDR
, self
._execute
_HDR
)
194 self
.execute
.register(c4m_jtag_svfgrammar
.HIR
, self
._execute
_HIR
)
195 self
.execute
.register(c4m_jtag_svfgrammar
.Runtest
, self
._execute
_Runtest
)
196 self
.execute
.register(c4m_jtag_svfgrammar
.SDR
, self
._execute
_SDR
)
197 self
.execute
.register(c4m_jtag_svfgrammar
.SIR
, self
._execute
_SIR
)
198 self
.execute
.register(c4m_jtag_svfgrammar
.State
, self
._execute
_State
)
199 self
.execute
.register(c4m_jtag_svfgrammar
.TDR
, self
._execute
_TDR
)
200 self
.execute
.register(c4m_jtag_svfgrammar
.TIR
, self
._execute
_TIR
)
201 self
.execute
.register(c4m_jtag_svfgrammar
.Trst
, self
._execute
_Trst
)
202 self
.execute
.register(c4m_jtag_svfgrammar
.SVFFile
, self
._execute
_SVFFile
)
204 # Store the head and tail for the scan
205 self
._d
_tdi
= self
._d
_tdi
_h
= self
._d
_tdi
_t
= None
206 self
._d
_tdo
_h
= self
._d
_tdo
_t
= None
207 self
._i
_tdi
= self
._i
_tdi
_h
= self
._i
_tdi
_t
= None
208 self
._i
_tdo
_h
= self
._i
_tdo
_t
= None
210 # Remember the masks; smasks are ignored and bits always considered as care, e.g right
212 self
._d
_length
= self
._d
_length
_h
= self
._d
_length
_t
= None
213 self
._d
_mask
= self
._d
_mask
_h
= self
._d
_mask
_t
= None
214 self
._d
_smask
= self
._d
_smask
_h
= self
._d
_smask
_t
= None
215 self
._i
_length
= self
._i
_length
_h
= self
._i
_length
_t
= None
216 self
._i
_mask
= self
._i
_mask
_h
= self
._i
_mask
_t
= None
217 self
._i
_smask
= self
._i
_smask
_h
= self
._i
_smask
_t
= None
220 def run(self
, cmds
, p
=print):
222 if isinstance(cmds
, c4m_jtag_svfgrammar
.SVFFile
):
223 yield self
.execute(cmds
)
225 p
= c4m_jtag_svfgrammar
.SVFFile
.parser()
226 yield self
.execute(p
.parse_string(cmds
))