def resp_handler(self, rvf: RVF):
self.logger.debug("TAP.resp_handler(uid={:d}, command={:s}, payload={:s})\n".format(rvf.uid, rvf.command,
str(rvf.payload)))
uid = rvf.uid
resp = RVF()
self.response_mutex.acquire()
resp.payload = rvf.payload
self.response_mutex.release()
if rvf.command == "SIR":
resp.uid = self.depth().uid
resp.command = "CAPSCAN"
self.host_interface.response(resp)
elif rvf.command == "SIRNC":
resp.uid = self.depth().uid
resp.command = "SCAN"
self.host_interface.response(resp)
elif rvf.command == "SDR":
resp.uid = self.depth().breadth().uid
resp.command = "CAPSCAN"
self.host_interface.response(resp)
elif rvf.command == "SDRNC":
resp.uid = self.depth().breadth().uid
resp.command = "SCAN"
self.host_interface.response(resp)
else:
raise SchedulerError("Invalid command received.")
self.request_count -= 1
if self.request_count == 0:
pass # Notify all requests have been satisfied
SchedulerFactory.get_scheduler().clear_pending()
def resp_handler(self, rvf: RVF):
self.logger.debug(
"JTAGNetwork.resp_handler(uid={:d}, command={:s}, payload={:s})\n".
format(rvf.uid, rvf.command, str(rvf.payload)))
self.response_mutex.acquire()
self.response = rvf.payload
self.response_mutex.release()
i = 0
start = 0
end = 0
seg = self.depth()
while seg is not None:
end = len(self.segments[i]) + end
resp = RVF()
resp.uid = seg.uid
resp.payload = intbv(self.response[start:end])
resp.command = rvf.command
seg.client_interface.response(rvf)
start = end
i += 1
seg = seg.breadth()
self.request_count -= 1
if self.request_count == 0:
self.response_cv.notify(
) # Notify all requests have been satisfied
SchedulerFactory.get_scheduler().clear_pending()
def resp_handler(self, rvf: RVF):
self.logger.debug(
"ScanMux.resp_handler(uid={:d}, command={:s}, payload={:s})\n".
format(rvf.uid, rvf.command, str(rvf.payload)))
uid = rvf.uid
resp = RVF()
self.response_mutex.acquire()
resp.payload = rvf.payload
resp.command = rvf.command
self.response_mutex.release()
found = False
seg = self.depth()
while seg is not None:
if seg == self.selected_seg:
resp.uid = seg.uid
seg.client_interface.response(resp)
found = True
break
seg = seg.breadth()
if not found:
raise SchedulerError("Unable to locate selected_uid assembly.")
self.request_count -= 1
if self.request_count == 0:
pass # Notify all requests have been satisfied
SchedulerFactory.get_scheduler().clear_pending()
def write_read(self, value):
if not isinstance(value, intbv):
raise SchedulerError("val is not of type intbv.")
if len(value) != self.reg_length:
raise SchedulerError("Size of value does not match register size.")
self.local_access_mutex.acquire()
self.__value = value
self.__read_value = None
self.pending = True
self.capture = True
self.local_access_mutex.release()
self.logger.debug("ScanRegister.write_read({:s})\n".format(str(value)))
from p2654model.scheduler.Scheduler import SchedulerFactory
SchedulerFactory.get_scheduler().mark_pending()
def hcb_scan(self, rvf: RVF):
# if not self.pending:
self.logger.debug("TAP.hcb_scan(uid={:d}, command={:s}, payload={:s})\n".format(rvf.uid, rvf.command,
str(rvf.payload)))
self.local_access_mutex.acquire()
self.pending_count += 1
self.value = rvf.payload
if rvf.uid == self.depth().uid: # This rvf is from the IR register
self.command = "SIRNC"
else:
self.command = "SDRNC"
self.pending = True
self.local_access_mutex.release()
SchedulerFactory.get_scheduler().mark_pending()
def hcb_write_read(self, rvf: RVF):
self.logger.debug(
"PortalRegister.hcb_write_read(uid={:d}, command={:s}, payload={:s})\n"
.format(rvf.uid, rvf.command, str(rvf.payload)))
self.local_access_mutex.acquire()
self.rvf = rvf
self.current_uid = rvf.uid
self.local_access_mutex.release()
self.pending = True
self.capture = True
self.update = True
self.pending_count += 1
from p2654model.scheduler.Scheduler import SchedulerFactory
SchedulerFactory.get_scheduler().mark_pending()
def hcb_scan(self, rvf: RVF):
self.logger.debug(
"ScanMux.hcb_scan(uid={:d}, command={:s}, payload={:s})\n".format(
rvf.uid, rvf.command, str(rvf.payload)))
uid = rvf.uid
if uid != self.selected_seg.uid:
if self.selected_seg.uid is not None:
self._deselect(self.selected_seg.uid)
self._select(uid)
self.local_access_mutex.acquire()
self.value = rvf.payload
self.pending = True
self.pending_count += 1
self.local_access_mutex.release()
SchedulerFactory.get_scheduler().mark_pending()
def resp_handler(self, rvf: RVF):
self.logger.debug("DataRegister.resp_handler(uid={:d}, command={:s}, payload={:s})\n".format(rvf.uid, rvf.command,
str(rvf.payload)))
if rvf.command == "WRITE":
self.__read_value = None
elif rvf.command == "READ" or rvf.command == "WRITE_READ":
self.response_mutex.acquire()
self.__read_value = rvf.payload
self.response_mutex.release()
else:
raise SchedulerError("Invalid command received.")
self.request_count -= 1
if self.request_count == 0:
pass # Notify all requests have been satisfied
from p2654model.scheduler.Scheduler import SchedulerFactory
SchedulerFactory.get_scheduler().clear_pending()
def write(self, value):
if self.direction == DataRegister.Direction.READ_ONLY:
raise SchedulerError("Write attempted on a READ_ONLY register!")
if not isinstance(value, intbv):
raise SchedulerError("val is not of type intbv.")
if len(value) != self.reg_length:
raise SchedulerError("Size of value does not match register size.")
self.logger.debug("DataRegister.write({:s})\n".format(str(value)))
self.local_access_mutex.acquire()
self.__value = value
self.__read_value = None
self.pending = True
self.capture = False
self.local_access_mutex.release()
from p2654model.scheduler.Scheduler import SchedulerFactory
SchedulerFactory.get_scheduler().mark_pending()
def hcb_scan(self, rvf: RVF):
if not self.cached:
self.__init_segments()
self.cached = True
self.pending = True
self.logger.debug(
"IJTAGNetwork.hcb_scan(uid={:d}, command={:s}, payload={:s})\n".
format(rvf.uid, rvf.command, str(rvf.payload)))
uid = rvf.uid
seg = self.depth()
i = 0
while seg is not None:
if seg.uid == uid:
self.segments[
i] = rvf.payload # fill in the appropriate subsegment with intbv value
break
seg = seg.breadth()
i += 1
if not self.pending:
SchedulerFactory.get_scheduler().mark_pending()
def resp_handler(self, rvf: RVF):
self.logger.debug(
"PortalRegister.resp_handler(uid={:d}, command={:s}, payload={:s})\n"
.format(rvf.uid, rvf.command, str(rvf.payload)))
resp = RVF()
self.local_access_mutex.acquire()
resp.uid = self.current_uid
self.local_access_mutex.release()
resp.payload = rvf.payload
if rvf.command == "WRITE" or rvf.command == "READ" or rvf.command == "WRITE_READ":
resp.command = rvf.command
elif rvf.command == "ADDRESS":
self.response_cv.notify()
else:
raise SchedulerError("Invalid command received.")
self.host_interface.response(resp)
self.request_count -= 1
if self.request_count == 0:
pass # Notify all requests have been satisfied
from p2654model.scheduler.Scheduler import SchedulerFactory
SchedulerFactory.get_scheduler().clear_pending()
def hcb_sdrnc(self, rvf: RVF):
if self.data_mode is not None and not self.data_mode:
raise SchedulerError("Conflict in scan mode!")
if not self.cached:
self.__init_segments()
self.cached = True
self.pending = True
self.logger.debug(
"JTAGNetwork.hcb_sdrnc(uid={:d}, command={:s}, payload={:s})\n".
format(rvf.uid, rvf.command, str(rvf.payload)))
uid = rvf.uid
seg = self.depth()
i = 0
while seg is not None:
if seg.uid == uid:
self.segments[
i] = rvf.payload # fill in the appropriate subsegment with intbv value
break
seg = seg.breadth()
i += 1
self.data_mode = True
SchedulerFactory.get_scheduler().mark_pending()
def test_JTAGBoard1Board(self):
ip = "127.0.0.1"
port = 5023
self.ate_inst = ATE(ip=ip, port=port)
sleep(0.05)
self.ate_inst.connect("P2654Board1")
# self.ate_inst.connect("SPITest")
sleep(0.05)
self.jc = JTAGController(self.ate_inst)
sleep(1)
self.scheduler = SchedulerFactory.get_scheduler(max_aging=2)
self.configure_model()
self.scheduler.topology.show()
self.scheduler.start()
self.scheduler.write("JC1.U1.IR", intbv('11111111'))
self.scheduler.apply()
self.scheduler.write("JC1.U1.IR", intbv('00000010'))
self.scheduler.apply()
self.scheduler.write("JC1.U1.BSR", intbv('000101010101010101'))
self.scheduler.apply()
self.scheduler.write("JC1.U1.IR", intbv('00000000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000101010101010101'))
self.scheduler.apply()
value = self.scheduler.read("JC1.U1.BSR")
print("value = {:s}\n".format(str(value)))
# self.assertTrue(value == intbv('000101010101010101'))
self.assertTrue(value == intbv('000000000000000000'))
self.scheduler.write_read("JC1.U1.BSR", intbv('000000000000000000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('001000000010000000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000100000001000000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000010000000100000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000001000000010000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000000100000001000'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000000010000000100'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000000001000000010'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000000000100000001'))
self.scheduler.apply()
self.scheduler.write_read("JC1.U1.BSR", intbv('000000000000000000'))
self.scheduler.apply()
self.scheduler.stop()
self.ate_inst.close()
def hcb_isactive(self, rvf: RVF):
if self.keyreg is None:
raise SchedulerError("keyreg must be defined before use.")
uid = rvf.uid
code = self.keyreg.read()
seldr = self.description.get_addr_dr(code)
scheduler = SchedulerFactory.get_scheduler()
assembly = scheduler.topology.getAssembly(uid)
if seldr is not None:
if assembly.entity_name == seldr.entity_name:
self.__send_response(uid, "ISACTIVE", "FALSE")
else:
self.__send_response(uid, "ISACTIVE", "TRUE")
else:
self.__send_response(uid, "ISACTIVE", "FALSE")