blob: c708bcded777424629f78f6b00c9c3afae9aedac [file] [log] [blame]
#!/usr/bin/env python3
# Copyright(c) 2022 Intel Corporation. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
import os
import sys
import logging
import time
import argparse
import socket
import struct
import hashlib
RET = 0
HOST = None
PORT_LOG = 9999
PORT_REQ = PORT_LOG + 1
BUF_SIZE = 4096
# Define the command and its
# possible max size
CMD_LOG_START = "start_log"
CMD_DOWNLOAD = "download"
MAX_CMD_SZ = 16
# Define the header format and size for
# transmiting the firmware
PACKET_HEADER_FORMAT_FW = 'I 42s 32s'
logging.basicConfig()
log = logging.getLogger("cavs-client")
log.setLevel(logging.INFO)
class cavstool_client():
def __init__(self, host, port, args):
self.host = host
self.port = port
self.args = args
self.sock = None
self.cmd = None
def send_cmd(self, cmd):
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
self.sock = sock
self.cmd = cmd
self.sock.connect((self.host, self.port))
self.sock.sendall(cmd.encode("utf-8"))
log.info(f"Sent: {cmd}")
ack = str(self.sock.recv(MAX_CMD_SZ), "utf-8")
log.info(f"Receive: {ack}")
if ack == CMD_LOG_START:
self.monitor_log()
elif ack == CMD_DOWNLOAD:
self.run()
else:
log.error(f"Receive incorrect msg:{ack} expect:{cmd}")
def uploading(self, filename):
# Send the FW to server
fname = os.path.basename(filename)
fsize = os.path.getsize(filename)
md5_tx = hashlib.md5(open(filename,'rb').read()).hexdigest()
# Pack the header and the expecting packed size is 78 bytes.
# The header by convention includes:
# size(4), filename(42), MD5(32)
values = (fsize, fname.encode('utf-8'), md5_tx.encode('utf-8'))
log.info(f'filename:{fname}, size:{fsize}, md5:{md5_tx}')
s = struct.Struct(PACKET_HEADER_FORMAT_FW)
header_data = s.pack(*values)
header_size = s.size
log.info(f'header size: {header_size}')
with open(filename,'rb') as f:
log.info(f'Sending...')
total = self.sock.send(header_data)
total += self.sock.sendfile(f)
log.info(f"Done Sending ({total}).")
rck = self.sock.recv(MAX_CMD_SZ).decode("utf-8")
log.info(f"RCK ({rck}).")
if not rck == "success":
global RET
RET = -1
log.error(f"Firmware uploading failed")
def run(self):
filename = str(self.args.fw_file)
self.uploading(filename)
def monitor_log(self):
log.info(f"Start to monitor log output...")
while True:
# Receive data from the server and print out
receive_log = str(self.sock.recv(BUF_SIZE).strip(), "utf-8")
if receive_log:
print(f"{receive_log}")
time.sleep(0.1)
def __del__(self):
self.sock.close()
def main():
if args.log_only:
log.info("Monitor process")
try:
client = cavstool_client(HOST, PORT_LOG, args)
client.send_cmd(CMD_LOG_START)
except KeyboardInterrupt:
pass
else:
log.info("Uploading process")
client = cavstool_client(HOST, PORT_REQ, args)
client.send_cmd(CMD_DOWNLOAD)
ap = argparse.ArgumentParser(description="DSP loader/logger client tool")
ap.add_argument("-q", "--quiet", action="store_true",
help="No loader output, just DSP logging")
ap.add_argument("-l", "--log-only", action="store_true",
help="Don't load firmware, just show log output")
ap.add_argument("-s", "--server-addr", default="localhost",
help="Specify the adsp server address")
ap.add_argument("fw_file", nargs="?", help="Firmware file")
args = ap.parse_args()
if args.quiet:
log.setLevel(logging.WARN)
HOST = args.server_addr
if __name__ == "__main__":
main()
sys.exit(RET)