__author__ = "Gabriele Sorrenti"
import time
from ska_low_sps_tpm_api.base.definitions import *
from ska_low_sps_tpm_api.base.utils import *
from ska_low_sps_tpm_api.plugins.firmwareblock import FirmwareBlock
FIFOSIZE = 1024
PAGESIZE = 256
SPICLK = 13000000
[docs]
class FlasdhDev:
[docs]
def __init__(
self,
name="",
description="",
jedecID=0,
pageSize=0,
sectorSize=0,
sectorCount=0,
slaveID=0,
):
self.name = name
self.description = description
self.jedecID = jedecID
self.pageSize = pageSize
self.sectorSize = sectorSize
self.sectorCount = sectorCount
self.slaveID = slaveID
FlashDevice_CPLD = FlasdhDev(
name="Flash_CPLD",
description="macronix,mx25r32",
jedecID=0xC22816,
pageSize=256,
sectorSize=64 * 1024,
sectorCount=64,
slaveID=0x00000000,
)
FlashDevice_FPGA1 = FlasdhDev(
name="Flash_FPGA1",
description="micron,n25q256a",
jedecID=0x20BA19,
pageSize=256,
sectorSize=64 * 1024,
sectorCount=512,
slaveID=0x00000001,
)
FlashDevice_FPGA2 = FlasdhDev(
name="Flash_FPGA2",
description="micron,n25q256a",
jedecID=0x20BA19,
pageSize=256,
sectorSize=64 * 1024,
sectorCount=512,
slaveID=0x00000002,
)
FlashDevices = [FlashDevice_CPLD, FlashDevice_FPGA1, FlashDevice_FPGA2]
[docs]
class TpmProgFlash(FirmwareBlock):
"""TPM Plugin for CPLD and FPGA SPI Flash bitfile storage/access class"""
[docs]
@compatibleboards(BoardMake.TpmBoard)
@friendlyname("tpm_progflash")
@maxinstances(1)
def __init__(self, board, logger=None, **kwargs):
"""
SPI4Flash initialiser.
:param board: Pointer to board instance
"""
super(TpmProgFlash, self).__init__(board, logger=logger)
self._board_type = kwargs.get("board_type", "XTPM")
self.add4bytemode = False
#######################################################################################
# ##################### SPI METHODS SECTION ###############################
[docs]
def spi_chipselect(self, isactive):
self.board["board.regfile.spi_cs.cs0"] = 1
[docs]
def spi_resetfifo(self):
self.board["board.regfile.spi_fifo_addr"] = 0
[docs]
def spi_trigger(self, length):
self.board["board.regfile.spi_tx_byte"] = length
[docs]
def spi_config(self, spi_cs_ow):
self.board["board.regfile.spi_cs.ow"] = spi_cs_ow
[docs]
def spi_rx_available(self):
tmp = self.board["board.regfile.spi_rx_byte"]
return tmp
[docs]
def spi_tx_remaining(self):
tmp = self.board["board.regfile.spi_rx_byte"]
return tmp
[docs]
def spi_sync(self, slaveid, tx_buffer, cmd, length):
_length = length
self.spi_chipselect(False)
if length >= 256:
formatted_cmd = list(struct.unpack_from("I" * int(len(cmd) // 4), cmd))
tx_buffer = formatted_cmd + tx_buffer
self.board["board.confspi.rxtx_buffer"] = tx_buffer[0 : (260 // 4)]
self.spi_trigger(260)
while True:
remaining = self.spi_tx_remaining()
if remaining <= 0:
break
self.spi_resetfifo()
ba = self.board.memory_map["board.confspi.rxtx_buffer"].address
rxbuffer = self.board.read_address(ba, (260 // 4))
self.spi_chipselect(True)
self.spi_resetfifo()
return rxbuffer[1:]
elif length < 4:
formatted_cmd = list(struct.unpack_from("I" * int(len(cmd) // 4), cmd))
tx_buffer = formatted_cmd + tx_buffer
self.board["board.confspi.rxtx_buffer"] = tx_buffer[0 : length * 4]
self.spi_trigger(length)
while True:
remaining = self.spi_tx_remaining()
if remaining <= 0:
break
self.spi_resetfifo()
ba = self.board.memory_map["board.confspi.rxtx_buffer"].address
rxbuffer = self.board.read_address(ba, 2)
self.spi_chipselect(True)
self.spi_resetfifo()
return rxbuffer[0]
else:
formatted_cmd = list(struct.unpack_from("I" * int(len(cmd) // 4), cmd))
tx_buffer = formatted_cmd + tx_buffer
self.board["board.confspi.rxtx_buffer"] = tx_buffer[0 : length // 4]
self.spi_trigger(length)
while True:
remaining = self.spi_tx_remaining()
if remaining <= 0:
break
self.spi_resetfifo()
ba = self.board.memory_map["board.confspi.rxtx_buffer"].address
rxbuffer = self.board.read_address(ba, length // 4)
self.spi_chipselect(True)
self.spi_resetfifo()
if (cmd[0] & 0xFF) == 0x9F:
return rxbuffer
[docs]
def spi_mux_selection(self, slaveid):
self.board["board.regfile.spi_mux"] = slaveid
# ########## FLASH COMMAND METHODS SECTION ####################################
[docs]
def SPITransaction(self, device, TxBuffer, cmd, size):
return self.spi_sync(device.slaveID, TxBuffer, cmd, size)
[docs]
def FlashDevice_readReg(self, device, reg):
cmd = bytearray(4)
tx_buffer = [0] * 4
cmd[0] = reg
cmd[1] = 0
rx_buffer = self.SPITransaction(device, tx_buffer, cmd, 2)
return (rx_buffer & 0xFF00) >> 8
[docs]
def FlashDevice_writeReg(self, device, reg, value=None):
cmd = bytearray(4)
tx_buffer = [0] * 4
cmd[0] = reg
if value is None:
self.SPITransaction(device, tx_buffer, cmd, 1)
else:
cmd[1] = value
self.SPITransaction(device, tx_buffer, cmd, 2)
[docs]
def FlashDevice_prepareCommand(self, command, address, device):
tx_buffer = bytearray(4)
tx_buffer[0] = command
tx_buffer[1] = (address >> 16) & 0xFF
tx_buffer[2] = (address >> 8) & 0xFF
tx_buffer[3] = address & 0xFF
return tx_buffer
[docs]
def FlashDevice_Enter4byteAddMode(self, device):
self.add4bytemode = True
self.FlashDevice_writeReg(device, 0x06) # write enable command
self.FlashDevice_writeReg(device, 0xC5, 0xF)
while True:
sr = self.FlashDevice_readReg(device, 0xC8)
if (sr & 0x01) == 1:
break
self.FlashDevice_writeReg(device, 0x06) # write enable command
[docs]
def FlashDevice_Exit4byteAddMode(self, device):
self.add4bytemode = False
self.FlashDevice_writeReg(device, 0x06) # write enable command
self.FlashDevice_writeReg(device, 0xC5, 0x0)
while True:
sr = self.FlashDevice_readReg(device, 0xC8)
if (sr & 0x01) == 0:
break
self.FlashDevice_writeReg(device, 0x06) # write enable command
[docs]
def FlashDevice_writeEnable(self, device):
self.FlashDevice_writeReg(device, 0x06)
[docs]
def FlashDevice_writeDisable(self, device):
self.FlashDevice_writeReg(device, 0x04)
[docs]
def FlashDevice_waitTillReady(self, device):
while True:
sr = self.FlashDevice_readReg(device, 0x05)
if (sr & 0x01) == 0:
break
[docs]
def FlashDevice_readIdentification(self, device):
tx_buffer = [0] * 32
cmd = bytearray(4)
cmd[0] = 0x9F
rx_buffer = self.SPITransaction(device, tx_buffer, cmd, 12)
id = (
((rx_buffer[0] & 0xFF000000) >> 24)
| ((rx_buffer[0] & 0xFF0000) >> 8)
| ((rx_buffer[0] & 0xFF00) << 8)
)
return id
[docs]
def FlashDevice_readPage(self, device, address, size):
tx_buffer = [0] * 512
if size > device.pageSize:
print("FlashDevice_readPage size > pageSize!")
return -1
buffer = self.FlashDevice_prepareCommand(0x03, address, device)
rx_buffer = self.SPITransaction(device, tx_buffer, buffer, size + 4)
return rx_buffer
[docs]
def FlashDevice_readsector(self, device, address):
rxbuffer = []
page_size = device.pageSize
num_of_pages = device.sectorSize // page_size
for i in range(0, num_of_pages):
rxbuff = self.FlashDevice_readPage(
device, address + i * page_size, page_size
)
rxbuffer = rxbuffer + rxbuff
return rxbuffer
[docs]
def FlashDevice_eraseSector(self, device, address):
self.FlashDevice_writeEnable(device)
self.FlashDevice_waitTillReady(device)
txBuffer = [0] * 4
buff = self.FlashDevice_prepareCommand(0xD8, address, device)
if device.slaveID != 0 and address >= 0x01000000:
self.FlashDevice_Enter4byteAddMode(device)
self.SPITransaction(device, txBuffer, buff, 4)
self.FlashDevice_Exit4byteAddMode(device)
else:
self.SPITransaction(device, txBuffer, buff, 4)
self.FlashDevice_waitTillReady(device)
[docs]
def FlashDevice_erase(self, device, address, size):
stop = address + size
while True:
self.FlashDevice_eraseSector(device, address)
address += device.sectorSize
if address >= stop:
break
self.FlashDevice_writeDisable(device)
[docs]
def FlashDevice_chiperase(self, device):
self.FlashDevice_writeEnable(device)
self.FlashDevice_waitTillReady(device)
self.FlashDevice_writeReg(device, 0xC7)
self.FlashDevice_waitTillReady(device)
[docs]
def FlashDevice_writePage(self, device, address, size, buffer):
if size > device.pageSize:
print("FlashDevice_writePage size > pageSize!")
return -1
buff = self.FlashDevice_prepareCommand(0x02, address, device)
self.FlashDevice_writeEnable(device)
rxBuffer = self.SPITransaction(device, buffer, buff, size + 4)
self.FlashDevice_waitTillReady(device)
[docs]
def FlashDevice_writesector(self, device, address, buffer):
page_size = device.pageSize
page_offset = address & (device.pageSize - 1)
num_of_pages = device.sectorSize // page_size
for i in range(0, num_of_pages):
self.FlashDevice_writePage(
device,
address + i * page_size,
page_size,
buffer[i * page_size // 4 : i * page_size // 4 + page_size // 4],
)
# ########## BITSTREAM MANAGE METHODS SECTION ####################################
[docs]
def loadBitstream(self, filename, sectorSize):
print("Open Bistream file %s" % filename)
with open(filename, "rb") as f:
dump = bytearray(f.read())
bitstreamSize = len(dump)
sc = bitstreamSize // sectorSize
if (sc * sectorSize) != bitstreamSize:
sc = sc + 1
print(
"Loading %s (%d bytes) = %d * %d bytes sectors"
% (filename, bitstreamSize, sc, sectorSize)
)
s = sc * sectorSize
tmp = bytearray(s)
for i in range(0, bitstreamSize):
tmp[i] = dump[i]
for i in range(0, s - bitstreamSize):
tmp[i + bitstreamSize] = 0xFF
return tmp, bitstreamSize, s
[docs]
def saveBitstream(self, filename, memblock, bitstreamSize):
f = open(filename, "wb")
print("Writing %d bytes to %s" % (bitstreamSize, filename))
l = len(memblock)
data = bytearray(l * 4)
print("lenght of array to be written: %d, in byte %d" % (l, l * 4))
bytecount = 0
for i in range(0, l):
data[bytecount + 0] = memblock[i] & 0xFF
data[bytecount + 1] = (memblock[i] & 0xFF00) >> 8
data[bytecount + 2] = (memblock[i] & 0xFF0000) >> 16
data[bytecount + 3] = (memblock[i] & 0xFF000000) >> 24
bytecount += 4
f.write(data[0:bitstreamSize])
f.close()
[docs]
def firmwareProgram(
self,
flashdeviceindedx,
bitstreamFilename,
address,
dumpFilename=None,
erase_all=False,
erase_size=None,
add_len=False,
):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
sectorSize = device.sectorSize
sectorSize_w = sectorSize // 4
sectorOffset = address // sectorSize
memblock1, bitstreamSize, size = self.loadBitstream(
bitstreamFilename, sectorSize
)
if add_len:
self.logger.debug("Prepending bitsream size in flash writing")
lght = bytearray(4)
lght[0] = (size & 0xFF000000) >> 24
lght[1] = (size & 0xFF0000) >> 16
lght[2] = (size & 0xFF00) >> 8
lght[3] = size & 0xFF
memblock = lght + memblock1
size = size + 4
else:
memblock = memblock1
sector_num = size // sectorSize
if erase_size != None:
sector_erase_num = erase_size // sectorSize
else:
sector_erase_num = sector_num
end_sector_offset = sector_num + sectorOffset
# Read bitfile and cast as a list of unsigned integers
formatted_bitstream = list(
struct.unpack_from("I" * (len(memblock) // 4), memblock)
)
bufferD = []
remaining = size
i = sectorOffset
j = 0
ec = 0
if not erase_all:
self.logger.info("Starting Erase from sector %d" % sector_erase_num)
self.logger.info(
"--- ERASING ------------------------------------------------------------------------------------"
)
sect = sector_erase_num
while True:
print("Sector %03d @ %08X: Erasing" % (sect, sect * sectorSize))
self.FlashDevice_erase(device, sect * sectorSize, sectorSize)
sect -= 1
if sect == 0:
break
else:
self.logger.info("Starting Chip Erase ")
self.logger.info(
"--- ERASING ------------------------------------------------------------------------------------"
)
self.FlashDevice_chiperase(device)
self.logger.debug("Starting programming from sector %d" % (sectorOffset))
self.logger.debug(
"--- PROGRAMMING ------------------------------------------------------------------------------------"
)
sect = 0
upper_flash = False
while 1:
off = j * sectorSize
self.logger.debug(
"Sector %03d @ %08X - bitstream offset %08X: "
% (i, i * sectorSize, off)
)
# print "E ",
# self.FlashDevice_erase(device, i * sectorSize, sectorSize)
c = 0
# for k in range (0,sectorSize):
# bufferO[k]=memblock[k+off]
if upper_flash is False and (i * sectorSize) >= 0x1000000:
upper_flash = True
self.FlashDevice_Enter4byteAddMode(device)
self.logger.info(
"W ",
)
b = formatted_bitstream[
(j * sectorSize_w) : ((j * sectorSize_w) + sectorSize_w)
]
self.FlashDevice_writesector(device, i * sectorSize, b)
self.logger.info("V")
bufferI = self.FlashDevice_readsector(device, i * sectorSize)
# bufferI=self.FlashDevice_read(device, i * sectorSize, sectorSize)
bufferD = bufferD + bufferI
# for k in range (0,sectorSize):
# bufferD[k+off]=bufferI[k]
c = 0
# formatted_data=list(struct.unpack_from('I' * (sectorSize / 4), bufferO))
for k in range(0, sectorSize // 4):
if b[k] != bufferI[k]:
c += 1
print(
"Error detected in verify @ offset %x: expected %x, read %x"
% (k, b[k], bufferI[k])
)
break
if c != 0:
retry = 2
counterr = 0
while retry > 0:
self.logger.info("Error detected, retring to write sector")
print("Sector %03d @ %08X: Erasing" % (i, i * sectorSize))
self.FlashDevice_erase(device, i * sectorSize, sectorSize)
self.logger.info("W ")
# b=formatted_bitstream[(j * sectorSize_w):((j * sectorSize_w) +sectorSize_w)]
self.FlashDevice_writesector(device, i * sectorSize, b)
self.logger.info("V")
bufferI = self.FlashDevice_readsector(device, i * sectorSize)
# bufferI=self.FlashDevice_read(device, i * sectorSize, sectorSize)
bufferD = bufferD + bufferI
counterr = 0
for k in range(0, sectorSize // 4):
if b[k] != bufferI[k]:
counterr += 1
self.logger.info(
"Error detected in verify @ offset %x: expected %x, read %x"
% (
k,
formatted_bitstream[(j * sectorSize_w) + k],
bufferI[k],
)
)
retry -= 1
break
if counterr == 0:
break
if counterr != 0 and retry == 0:
self.logger.info(
"Impossible to write bitstream in flash device %d"
% flashdeviceindedx
)
exit()
ec += c
j += 1
i += 1
sect += 1
if sect == sector_num:
break
self.logger.info(
"----------------------------------------------------------------------------------------------------"
)
if self.add4bytemode:
upper_flash = False
self.FlashDevice_Exit4byteAddMode(device)
if dumpFilename is not None:
self.saveBitstream(dumpFilename, bufferD, bitstreamSize)
return ec
"""
def firmwareVerify(self,flashdeviceindedx,bitstreamFilename,address,dumpFilename=None):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
sectorSize=device.sectorSize
sectorOffset = address/sectorSize
memblock,bitstreamSize,size = self.loadBitstream(bitstreamFilename, sectorSize)
bufferO = bytearray(sectorSize)
bufferD = []#bytearray(size)
remaining = size
i = sectorOffset
j = 0
ec = 0
print("Starting verify from sector %d" %sectorOffset)
print("--- VERIFYING ------------------------------------------------------------------------------------\n")
while (remaining > 0):
off = j * sectorSize
print("Sector %03d @ %08X - bitstream offset %08X: " %(i, i * sectorSize, off))
c = 0
for k in range(0,sectorSize):
bufferO[k]=memblock[k+off]
print"V",
bufferI=self.FlashDevice_read_sector(device, i * sectorSize, sectorSize)
bufferD=bufferD+bufferI
formatted_data=list(struct.unpack_from('I' * (sectorSize / 4), bufferO))
for k in range (0, sectorSize/4):
if formatted_data[k] != bufferI[k]:
c+=1
print("Error detected in verify @ offset %x: expected %x, read %x" %(k,formatted_data[k]),bufferI[k])
ec+=c
remaining -= sectorSize
j+=1
i+=1
print("----------------------------------------------------------------------------------------------------\n");
errorCount = ec
if (dumpFilename!= None):
self.saveBitstream(dumpFilename, bufferD, bitstreamSize)
return errorCount
"""
[docs]
def firmwareRead(self, flashdeviceindedx, address, size, dumpFilename):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
sectorSize = device.sectorSize
sectorOffset = address // device.sectorSize
remaining = 0
bitstream_sectorsize = size // sectorSize
bitstream_sectorsize += 1
bufferD = [] # bytearray(bitstream_sectorsize*sectorSize)
# remaining = size
remaining = bitstream_sectorsize * sectorSize
i = sectorOffset
j = 0
ec = 0
upper_flash = False
self.logger.info("Starting Reading from sector %d" % sectorOffset)
self.logger.info(
"--- READING ------------------------------------------------------------------------------------"
)
while remaining > 0:
off = j * sectorSize
print(
"Sector %03d @ %08X - bitstream offset %08X: R"
% (i, i * sectorSize, off)
)
c = 0
if upper_flash is False and address >= 0x1000000:
upper_flash = True
self.FlashDevice_Enter4byteAddMode(device)
bufferI = self.FlashDevice_readsector(device, i * sectorSize)
# for k in range (0,sectorSize):
# bufferD[k+off]=bufferI[k]
bufferD = bufferD + bufferI
remaining -= sectorSize
j += 1
i += 1
self.logger.info(
"----------------------------------------------------------------------------------------------------"
)
if self.add4bytemode is True:
self.FlashDevice_Exit4byteAddMode(device)
if dumpFilename is not None:
self.saveBitstream(dumpFilename, bufferD, size)
[docs]
def DeviceGetInfo(self, flashdeviceindedx):
device = FlashDevices[flashdeviceindedx]
return device
[docs]
def DeviceGetID(self, flashdeviceindedx):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
id = self.FlashDevice_readIdentification(device)
return id
[docs]
def DeviceErase(self, flashdeviceindedx, address, size):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
self.FlashDevice_erase(device, address, size)
[docs]
def DeviceEraseChip(self, flashdeviceindedx):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
self.FlashDevice_chiperase(device)
[docs]
def DeviceWrite(self, flashdeviceindedx, address, txbuff, size):
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
data_size = len(txbuff)
sectorSize = 64 * 1024
sectorOffset = address // sectorSize
sc = data_size // sectorSize
if (sc * sectorSize) != data_size:
sc = sc + 1
s = sc * sectorSize
tmp = bytearray(s)
for i in range(0, data_size):
tmp[i] = txbuff[i]
for i in range(0, s - data_size):
tmp[i + data_size] = 0xFF
formatted_bitstream = list(struct.unpack_from("I" * (len(tmp) // 4), tmp))
i = sectorOffset
j = 0
sector_num = sc
sect = 0
while True:
self.FlashDevice_writesector(
device,
i * sectorSize,
formatted_bitstream[
j * sectorSize // 4 : (j * sectorSize // 4 + sectorSize // 4)
],
)
i = i + 1
j += 1
sect += 1
if sect == sector_num:
break
[docs]
def Prog_FPGA_From_flash(self, flashdeviceindedx, fpga):
# Check if connected
if self.board.status[Device.Board] != Status.OK:
raise LibraryError("TPM needs to be connected in order to program FPGAs")
# Check if enabled (hw_ver >= 1.5)
if self.board.hw_rev >= self.board.tpm_hw_rev_1_5:
if self.board["board.regfile.enable.fpga"] == 0:
self.logger.info("FPGAs power disabled. Enabling")
self.board["board.regfile.enable.fpga"] = 1
time.sleep(0.1)
else:
self.logger.info("FPGAs power already enabled.")
if self.board.hw_rev >= self.board.tpm_hw_rev_1_5:
required_cpld_version = 0 # @TODO 0x17041801
else:
required_cpld_version = 0x17041801
cpld_version = self.board["board.regfile.date_code"]
if cpld_version < required_cpld_version or cpld_version & 0xF0 == 0xB0:
self.logger.error(
"CPLD firmware version is too old. Required version is "
+ hex(required_cpld_version)
)
raise LibraryError(
"CPLD firmware version is too old. Required version is "
+ hex(required_cpld_version)
)
# Disable C2C stream
# self.board['board.regfile.c2c_stream_enable'] = 0x0
# Select FPGAs to program
self.board.smap_deselect_fpga([0, 1])
self.board["board.smap.global"] = 0x3
# Erase FPGAs SRAM
self.board.erase_fpga()
device = FlashDevices[flashdeviceindedx]
self.spi_mux_selection(device.slaveID)
self.FlashDevice_writeReg(device, 0x06) # write enable command
txBuffer = bytearray(16)
address = 0x00000000
txBuffer[1] = (address >> 16) & 0xFF
txBuffer[2] = (address >> 8) & 0xFF
txBuffer[3] = address & 0xFF
# read from flash
self.logger.debug("Read from flash")
self.board["board.regfile.spi_fifo_addr"] = 0
txBuffer[0] = 0x03
for i in range(5, 16):
txBuffer[i] = i & 0x00
formatted_cmd = list(struct.unpack_from("I" * (len(txBuffer) // 4), txBuffer))
self.board["board.confspi.rxtx_buffer"] = formatted_cmd[0 : len(formatted_cmd)]
self.spi_trigger(8)
while True:
remaining = self.spi_tx_remaining()
if remaining <= 0:
break
self.spi_resetfifo()
ba = self.board.memory_map["board.confspi.rxtx_buffer"].address
rxbuffer_rd = self.board.read_address(ba, 2)
# self.spi_chipselect(True)
self.spi_resetfifo()
lenght = (
((rxbuffer_rd[1] & 0xFF) << 24)
| ((rxbuffer_rd[1] & 0xFF00) << 8)
| ((rxbuffer_rd[1] & 0xFF0000) >> 16)
| ((rxbuffer_rd[1] & 0xFF000000) >> 24)
)
self.logger.debug("Bitstream lenght" + hex(lenght))
txBuffer[0] = 0x0B
formatted_cmd = list(
struct.unpack_from("I" * int(len(txBuffer) // 4), txBuffer)
)
self.board["board.confspi.rxtx_buffer"] = formatted_cmd[0 : len(formatted_cmd)]
self.spi_config(0)
self.spi_trigger(4)
self.board["board.regfile.spi_route"] = 1
start = time.time()
self.spi_trigger(lenght)
timeout = lenght * 8 // SPICLK + 5
while True:
if self.board.is_programmed():
break
now = time.time()
if now - start > timeout:
break
self.board["board.regfile.spi_route"] = 1
self.spi_config(1)
if self.board.is_programmed():
return 0
else:
return -1
"""
def FlashDevice_read(self,device,address,size):
page_size = 0
rxBuffer=[]
#rxBuffer=bytearray(size+4)
page_offset = address & (device.pageSize - 1)
#/* do all the bytes fit onto one page? */
if (page_offset + size <= device.pageSize):
rxBuffer=self.FlashDevice_readPage(device, address, size)
return rxBuffer
else:
bytecount=0
#/* the size of data remaining on the first page */
page_size = device.pageSize - page_offset
bytecount=bytecount+page_size
rxbuff1=self.FlashDevice_readPage(device, address, page_size)
#for k in range(0,bytecount):
rxBuffer=rxbuff1
#/* write everything in nor->page_size chunks */
for i in range(page_size,size,page_size):
page_size = size - i
if (page_size > device.pageSize):
page_size = device.pageSize
rxbuff2=self.FlashDevice_readPage(device, address + i, page_size)
rxBuffer=rxBuffer+rxbuff2
return rxBuffer
"""
# #################### Superclass method implementations #################################
[docs]
def initialise(self):
"""Initialise TpmMcu"""
self.logger.info("TpmMcu has been initialised")
return True
[docs]
def status_check(self):
"""Perform status check.
:return: Status
"""
self.logger.info("TpmMcu : Checking status")
return Status.OK
[docs]
def clean_up(self):
"""Perform cleanup.
:return: Success
"""
self.logger.info("TpmMcu : Cleaning up")
return True