def uninstall_board(name, debug):
from nysa.ibuilder.lib import utils
from nysa.common.status import Status
status = Status()
if debug:
status.set_level("Verbose")
utils.uninstall_local_board_package(name, status)
def __init__(self, dut, period=CLK_PERIOD):
self.status = Status()
self.status.set_level('verbose')
self.comm_lock = cocotb.triggers.Lock('comm')
self.dut = dut
dev_dict = json.load(open('test_dict.json'))
super(NysaSim, self).__init__(dev_dict, self.status)
self.timeout = 1000
self.response = Array('B')
self.dut.rst <= 0
self.dut.ih_reset <= 0
self.dut.in_ready <= 0
self.dut.in_command <= 0
self.dut.in_address <= 0
self.dut.in_data <= 0
self.dut.in_data_count <= 0
gd = GenSDB()
self.rom = gd.gen_rom(self.dev_dict, debug=False)
#yield ClockCycles(self.dut.clk, 10)
cocotb.fork(Clock(dut.clk, period).start())
def install_board(name, path, setup_platform, debug):
from nysa.ibuilder.lib import utils
from nysa.common.status import Status
status = Status()
if debug:
status.set_level("Verbose")
utils.install_local_board_package(name, path, setup_platform, status)
def __init__(self, dut, sim_config, period=CLK_PERIOD, user_paths=[]):
self.status = Status()
self.status.set_level('verbose')
self.user_paths = user_paths
self.comm_lock = cocotb.triggers.Lock('comm')
self.dut = dut
dev_dict = json.load(open(sim_config), object_pairs_hook=OrderedDict)
super(NysaSim, self).__init__(dev_dict, self.status)
self.timeout = 1000
self.response = Array('B')
self.dut.rst <= 0
self.dut.ih_reset <= 0
self.dut.in_ready <= 0
self.dut.in_command <= 0
self.dut.in_address <= 0
self.dut.in_data <= 0
self.dut.in_data_count <= 0
gd = GenSDB()
self.callbacks = {}
self.rom = gd.gen_rom(self.dev_dict,
user_paths=self.user_paths,
debug=False)
cocotb.fork(Clock(dut.clk, period).start())
cocotb.fork(self.interrupt_interface())
def setUp(self):
s = Status()
s.set_level("fatal")
print "Unit test!"
pass
'''
def __init__(self, status=None):
self.d = {}
self.s = status
if status is None:
self.s = Status()
for e in self.ELEMENTS:
self.d[e] = ""
def setUp(self):
self.s = Status()
plat = ["", None, None]
pscanner = PlatformScanner()
platform_dict = pscanner.get_platforms()
platform_names = platform_dict.keys()
if "sim" in platform_names:
#If sim is in the platforms, move it to the end
platform_names.remove("sim")
platform_names.append("sim")
urn = None
for platform_name in platform_names:
if plat[1] is not None:
break
self.s.Debug("Platform: %s" % str(platform_name))
platform_instance = platform_dict[platform_name](self.s)
#self.s.Verbose("Platform Instance: %s" % str(platform_instance))
instances_dict = platform_instance.scan()
for name in instances_dict:
#s.Verbose("Found Platform Item: %s" % str(platform_item))
n = instances_dict[name]
plat = ["", None, None]
if n is not None:
self.s.Important("Found a nysa instance: %s" % name)
n.read_sdb()
#import pdb; pdb.set_trace()
if n.is_device_in_platform(DRIVER):
plat = [platform_name, name, n]
break
continue
#self.s.Verbose("\t%s" % psi)
if plat[1] is None:
self.sata_drv = None
return
n = plat[2]
self.n = n
sata_urn = n.find_device(DRIVER)[0]
dma_urn = n.find_device(DMA)[0]
self.memory_urn = self.n.find_device(Memory)[0]
self.sata_drv = DRIVER(n, sata_urn)
self.dma = DMA(n, dma_urn)
self.s.set_level("verbose")
self.s.Info("Using Platform: %s" % plat[0])
self.s.Info("Instantiated a SATA Device: %s" % sata_urn)
self.s.Info("Instantiated a DMA Device: %s" % dma_urn)
def setUp(self):
self.dbg = False
name = "sim"
serial = "dionysus_uart_pmod"
s = Status()
s.set_level(StatusLevel.FATAL)
try:
self.board = find_board(name, serial, s)
except PlatformScannerException as ex:
print "Could not find platform :%s" % str(ex)
sys.exit(1)
self.board.read_sdb()
self.nsm = self.board.nsm
def setUp(self):
self.s = Status()
self.s.set_level("fatal")
plat = ["", None, None]
pscanner = PlatformScanner()
platform_dict = pscanner.get_platforms()
platform_names = platform_dict.keys()
if "sim" in platform_names:
#If sim is in the platforms, move it to the end
platform_names.remove("sim")
platform_names.append("sim")
urn = None
for platform_name in platform_names:
if plat[1] is not None:
break
self.s.Debug("Platform: %s" % str(platform_name))
platform_instance = platform_dict[platform_name](self.s)
#self.s.Verbose("Platform Instance: %s" % str(platform_instance))
instances_dict = platform_instance.scan()
for name in instances_dict:
#s.Verbose("Found Platform Item: %s" % str(platform_item))
n = instances_dict[name]
plat = ["", None, None]
if n is not None:
self.s.Important("Found a nysa instance: %s" % name)
n.read_sdb()
#import pdb; pdb.set_trace()
if n.is_device_in_platform(SFCamera):
plat = [platform_name, name, n]
break
continue
#self.s.Verbose("\t%s" % psi)
if plat[1] is None:
self.camera = None
return
n = plat[2]
urn = n.find_device(SFCamera)[0]
self.s.set_level("verbose")
self.s.Important("Using Platform: %s" % plat[0])
self.s.Important("Instantiated a SFCamera Device: %s" % urn)
self.camera = SFCamera(n, urn)
self.received_callback = False
def test_full_dionysus_read(self):
from nysa.host.platform_scanner import PlatformScanner
pscanner = PlatformScanner()
platform_dict = pscanner.get_platforms()
platform_names = platform_dict.keys()
if "dionysus" not in platform_names:
return
s = Status()
platform_instance = platform_dict["dionysus"](s)
platforms = platform_instance.scan()
if len(platforms) == 0:
return
dionysus = platforms[platforms.keys()[0]]
#print "Found Dionysus"
s.set_level("fatal")
s.Verbose("Read SDB")
dionysus.read_sdb()
def setUp(self):
name = "sim"
serial = "dionysus_dma_test"
s = Status()
s.set_level("fatal")
try:
self.n = find_board(name, serial, s)
except PlatformScannerException as ex:
print "Could not find platform :%s" % str(ex)
sys.exit(1)
self.n.read_sdb()
urns = self.n.find_device(MockGPIODriver)
#self.simple_dev = MockGPIODriver(self.n, urns[0], True)
self.simple_dev = MockGPIODriver(self.n, urns[0], False)
urns = self.n.find_device(MockDMAReaderDriver)
self.dmar = MockDMAReaderDriver(self.n, urns[0], False)
urns = self.n.find_device(MockDMAWriterDriver)
self.dmaw = MockDMAWriterDriver(self.n, urns[0], False)
s.set_level("error")
def __init__(self,
dut,
uart_if,
sim_config,
period=CLK_PERIOD,
user_paths=[],
status=None):
self.dev_dict = json.load(open(sim_config),
object_pairs_hook=OrderedDict)
Nysa.__init__(self, Status())
self.s.set_level('verbose')
self.user_paths = user_paths
self.comm_lock = cocotb.triggers.Lock('comm')
self.dut = dut
cocotb.fork(Clock(dut.clk, period).start())
gd = GenSDB()
self.rom = gd.gen_rom(self.dev_dict,
user_paths=self.user_paths,
debug=False)
self.uart = uart_if
self.response = Array('B')
def setUp(self):
self.s = Status()
plat = ["", None, None]
pscanner = PlatformScanner()
platform_dict = pscanner.get_platforms()
platform_names = platform_dict.keys()
if "sim" in platform_names:
platform_names.remove("sim")
platform_names.append("sim")
urn = None
for platform_name in platform_names:
if plat[1] is not None:
break
self.s.Debug("Platform: %s" % str(platform_name))
platform_instance = platform_dict[platform_name](self.s)
instances_dict = platform_instance.scan()
for name in instances_dict:
n = instances_dict[name]
plat = ["", None, None]
if n is not None:
self.s.Important("Found a nysa instance: %s" % name)
n.read_sdb()
if n.is_device_in_platform(DRIVER):
plat = [platform_name, name, n]
break
continue
if plat[1] is None:
self.sdio_drv = None
return
n = plat[2]
self.n = n
sdio_urn = n.find_device(DRIVER)[0]
self.sdio = DRIVER(n, sdio_urn)
self.s.set_level("verbose")
self.s.Info("Using Platform: %s" % plat[0])
self.s.Info("Instantiated a SDIO Device Device: %s" % sdio_urn)
def __init__(self, dut, sim_config, period = CLK_PERIOD, user_paths = []):
self.status = Status()
self.status.set_level('verbose')
self.user_paths = user_paths
self.comm_lock = cocotb.triggers.Lock('comm')
self.dut = dut
dev_dict = json.load(open(sim_config), object_pairs_hook = OrderedDict)
super (NysaSim, self).__init__(dev_dict, self.status)
self.timeout = 1000
self.response = Array('B')
self.dut.rst <= 0
#self.ft245 = FT245(dut, "ft245", dut.ft245_clk, buffer_size = 0x10)
self.ft245 = FT245(dut, "ft245", dut.ft245_clk, buffer_size = 0x11)
#self.ft245 = FT245(dut, "ft245", dut.ft245_clk, buffer_size = 0x200)
gd = GenSDB()
self.callbacks = {}
self.rom = gd.gen_rom(self.dev_dict, user_paths = self.user_paths, debug = False)
cocotb.fork(Clock(dut.clk, period).start())
setup_ft245_clk(dut)
cocotb.fork(self.interrupt_interface())
def setUp(self):
self.s = Status()
self.s.set_level("debug")
self.configure_device(i2s.I2S)
def __init__(self, name=None):
self.s = Status()
self.s.set_level("fatal")
plat = ["", None, None]
pscanner = PlatformScanner()
platform_dict = pscanner.get_platforms()
platform_names = platform_dict.keys()
if "sim" in platform_names:
#If sim is in the platforms, move it to the end
platform_names.remove("sim")
platform_names.append("sim")
urn = None
if name is not None and name in platform_names:
self.s.Debug("Platform: %s" % str(name))
platform_instance = platform_dict[name](self.s)
#self.s.Verbose("Platform Instance: %s" % str(platform_instance))
instances_dict = platform_instance.scan()
for iname in instances_dict:
#s.Verbose("Found Platform Item: %s" % str(platform_item))
n = instances_dict[iname]
plat = ["", None, None]
if n is not None:
self.s.Important("Found a nysa instance: %s" % iname)
n.read_sdb()
#import pdb; pdb.set_trace()
if n.is_device_in_platform(Memory):
plat = [name, iname, n]
break
continue
#self.s.Verbose("\t%s" % psi)
else:
for platform_name in platform_names:
if plat[1] is not None:
break
self.s.Debug("Platform: %s" % str(platform_name))
platform_instance = platform_dict[platform_name](self.s)
#self.s.Verbose("Platform Instance: %s" % str(platform_instance))
instances_dict = platform_instance.scan()
for name in instances_dict:
#s.Verbose("Found Platform Item: %s" % str(platform_item))
n = instances_dict[name]
plat = ["", None, None]
if n is not None:
self.s.Important("Found a nysa instance: %s" % name)
n.read_sdb()
#import pdb; pdb.set_trace()
if n.is_device_in_platform(Memory):
plat = [platform_name, name, n]
break
continue
#self.s.Verbose("\t%s" % psi)
if plat[1] is None:
return
self.n = plat[2]
self.urn = self.n.find_device(Memory)[0]
self.s.set_level("verbose")
self.s.Important("Using Platform: %s" % plat[0])
self.s.Important("Instantiated a Memory Device: %s" % self.urn)
self.memory = Memory(self.n, self.urn)
def setUp(self):
self.status = Status()
self.status.set_level("error")
self.som = som.SOM()
def setUp(self):
self.status = Status()
