def main():
""" Main Entry Point """
args = parse_args()
log_level = logging.INFO
if args.debug:
log_level = logging.DEBUG
logging.basicConfig(level=log_level, format="%(message)s")
dev = Device()
dev.open_device()
etrace = Etrace(dev)
etrace.print()
if args.hexdump:
etrace.hexdump()
if args.output_file:
etrace.save(args.output_file)
# Character passed in mailbox ID field
def mailbox_poll_char(dev):
while True:
if dev.dsp_hipct.value & regs.ADSP_IPC_HIPCT_BUSY:
# Use only id for passing character
character = dev.dsp_hipct.value & regs.ADSP_IPC_HIPCT_MSG
# Get readable character
character &= 0x10FFFF
print('{}'.format(chr(character)), end='')
# Clear interrupt
dev.dsp_hipct.value |= regs.ADSP_IPC_HIPCT_BUSY
else:
sleep(0.005)
if __name__ == "__main__":
# Clear Done if needed
#dev.dsp_hipct.value |= regs.ADSP_IPC_HIPCT_BUSY
# Use Device library for controlling registers
device = Device()
device.open_device()
mailbox_poll_mem(device)
class FirmwareLoader():
def __init__(self):
self._init_done = False
self.dma_id = None
self.dev = None
self.sdl = None
def init(self, dma_id):
if self._init_done:
logging.warning("Already initialized! Skip init")
return
self.dma_id = dma_id
self.dev = Device()
self.dev.open_device()
self.sdl = StreamDescList(self.dev)
self.ipc = Ipc(self.dev)
self._init_done = True
def close(self):
if not self._init_done:
logging.warning("Not initialized! Skip closing.")
return
self.sdl.close()
self.dev.close()
self._init_done = False
def reset_dsp(self):
logging.debug(">>> FirmwareLoader.reset_dsp()")
logging.debug("Recycling controller power...")
self.dev.power_cycle()
# This should be enabled prior to power down the cores.
self.dev.enable_proc_pipe_ctl()
logging.debug("Power down cores...")
self.dev.core_stall_reset(plat_def.CORE_MASK)
self.dev.core_power_down(plat_def.CORE_MASK)
logging.debug("<<< FirmwareLoader.reset_dsp()")
def boot_dsp(self):
logging.debug(">>> FirmwareLoader.boot_dsp()")
self.dev.enable_proc_pipe_ctl()
self.sdl.reset_all()
self.dev.core_power_up(0x1)
self.dev.dsp_hipct.value = self.dev.dsp_hipct.value
logging.debug("Purging pending FW request")
boot_config = plat_def.FW_IPC_PURGE | regs_def.ADSP_IPC_HIPCI_BUSY
boot_config = boot_config | ((self.dma_id - 7) << 9)
self.dev.dsp_hipci.value = boot_config
time.sleep(0.1)
logging.debug(" DSP_HIPCI=%s" % self.dev.dsp_hipci)
self.dev.core_power_up(plat_def.CORE_MASK)
self.dev.core_run(plat_def.CORE_0)
self.dev.core_run(plat_def.CORE_1)
logging.debug("Wait for IPC DONE bit from ROM")
while True:
ipc_ack = self.dev.dsp_hipcie.value
if (ipc_ack & (1 << regs_def.ADSP_IPC_HIPCIE_DONE_OFFSET)) != 0:
break
time.sleep(0.1)
logging.debug("<<< FirmwareLoader.boot_dsp()")
def check_fw_boot_status(self, expected):
logging.debug(">>> FirmwareLoader.check_fw_boot_status(0x%08X)" %
expected)
raw_status = self.dev.fw_status.value
FirmwareStatus(raw_status).print()
if (raw_status & plat_def.FW_STATUS_ERROR) != 0:
output = ("Firmware Status error:"
" Status: 0x%08X\n"
" Error Code 0x%08X" %
(raw_status, self.dev.fw_err_code.value))
raise RuntimeError(output)
status = raw_status & plat_def.FW_STATUS_BOOT_STATE
logging.debug("<<< FirmwareLoader.check_fw_boot_status()")
return status == expected
def wait_for_fw_boot_status(self, boot_status):
logging.debug("Waiting for FW Boot Status: 0x%08X (%s)" %
(boot_status, plat_def.BOOT_STATUS_STR(boot_status)))
for _ in range(10):
reg = self.dev.fw_status.value
bs = reg & plat_def.FW_STATUS_BOOT_STATE
if bs == boot_status:
logging.debug("Received Expected Boot Status")
return True
time.sleep(0.01)
logging.error("Failed to receive expected status")
return False
def wait_for_fw_wait_status(self, wait_status):
logging.debug("Waiting for FW Wait Status: 0x%08X (%s)" %
(wait_status, plat_def.WAIT_STATUS_STR(wait_status)))
for _ in range(10):
reg = self.dev.fw_status.value
ws = reg & plat_def.FW_STATUS_WAIT_STATE
if ws == (wait_status << plat_def.FW_STATUS_WAIT_STATE_OFFSET):
logging.debug("Received Expected Wait Status")
return True
time.sleep(0.01)
logging.error("Failed to receive expected status")
return False
def load_firmware(self, fw_file):
logging.debug(">>> FirmwareLoader.load_firmware()")
with open(fw_file, "rb") as fd:
data = array.array('B', fd.read())
sd = self.sdl.get_sd(self.dma_id)
sd.enable = True
sd.alloc_memory(len(data))
sd.buf.copy(data, len(data))
sd.config()
sd.set_stream_id(1)
sd.set_traffic_priority(1)
sd.set_bitrate(0x4)
time.sleep(0.1)
logging.debug("<<< FirmwareLoader.load_firmware()")
return sd
def download_firmware(self, fw_file):
logging.debug(">>> FirmwareLoader.download_firmware(fw_file=%s)" %
fw_file)
# Load firmware to DMA buffer and update SD and SDL
sd = self.load_firmware(fw_file)
try:
self.dev.hda_spibe.value |= (1 << self.dma_id)
self.wait_for_fw_wait_status(plat_def.WAIT_STATUS_DMA_BUFFER_FULL)
logging.info("Start firmware downloading...")
sd.start()
time.sleep(0.5)
self.wait_for_fw_boot_status(plat_def.BOOT_STATUS_FW_ENTERED)
finally:
sd.pause()
sd.reset()
self.sdl.release_sd(sd.idx)
self.dev.hda_spibe.value = 0
logging.debug("<<< FirmwareLoader.download_firmware()")
