#!/usr/bin/env python3
#
# Copyright (c) 2019 Intel Corporation
#
# SPDX-License-Identifier: Apache-2.0

# This script will add specific headers and FW load message to tell
# intel_s1000 ROM bootloader to load the firmware
# Usage python3 ${ZEPHYR_BASE}/scripts/create_board_img.py
#                    -i in_file.bin -o out_file.bin -l zephyr_prebuilt.elf
#                    [-m|--no_sram] [-c|--no_l1cache] [-t|--no_tlb]
#                    [-x|--no_exec] [-s|--no_sha] [-k|--clk_sel]

import argparse
import os
import sys
import struct
from elftools.elf.elffile import ELFFile

help_text="""
The flash memory needs to have specific headers and fw load message to tell
the ROM bootloader to load firmware.

To run script use command:

create_board_img.py -i in_file.bin -o out_file.bin -l zephyr_prebuilt.elf
                    [-m|--no_sram] [-c|--no_l1cache] [-t|--no_tlb]
                    [-x|--no_exec] [-s|--no_sha] [-k|--clk_sel]
"""

FLASH_PART_TABLE_OFFSET	= (0x1000)
FLASH_SECTOR_SIZE	= (4 * 1024)
FLASH_MAGIC_WORD	= (0x30504353)

SRAM_SIZE		= (1024*1024*4)
MAX_FLASH_FILE_SIZE	= (1024*1024*2)
SIZEOF_IPC64		= (64)
ROM_CONTROL_MEMWRITE	= (0x11)
ROM_CONTROL_LOADFW	= (0x2)
ROM_CONTROL_EXEC	= (0x13)

FW_LOAD_NO_L1_CACHE	= (1 << 29)
FW_LOAD_NO_SRAM_FLAG	= (1 << 28)
FW_LOAD_NO_TLB_FLAG	= (1 << 27)
FW_LOAD_NO_EXEC_FLAG	= (1 << 26)
FW_LOAD_NO_SHA_FLAG	= (1 << 25)
FW_LOAD_CLK_SEL		= (1 << 21)

# File write buffer
flash_content = []
write_buf     = []

def debug(text):
    sys.stdout.write(os.path.basename(sys.argv[0]) + ": " + text + "\n")

def error(text):
    sys.exit(os.path.basename(sys.argv[0]) + ": " + text)

def set_magic_number(value):
    flash_content.append(value)

def set_partition_table_pointer(value):
    flash_content.append(value)

def ipc_load_fw(fw_size, fw_offset):
    dword_count = 3
    load_flags = 0
    clock_sel = 0

    dword_count = 0x3ff & dword_count

    debug("Creating flash image with following options:")

    if args.no_sram:
        load_flags |= FW_LOAD_NO_SRAM_FLAG
        debug("-m    no_sram")

    if args.no_l1cache:
        load_flags |= FW_LOAD_NO_L1_CACHE
        debug("-c    no_l1cache")

    if args.no_tlb:
        load_flags |= FW_LOAD_NO_TLB_FLAG
        debug("-t    no_tlb")

    if args.no_exec:
        load_flags |= FW_LOAD_NO_EXEC_FLAG
        debug("-x    no_exec")

    if args.no_sha:
        load_flags |= FW_LOAD_NO_SHA_FLAG
        debug("-s    no_sha")

    if args.clk_sel:
        clock_sel = FW_LOAD_CLK_SEL
        debug("-k    clk_sel")

    with open(args.kernel, "rb") as fp_kernel:
        kernel = ELFFile(fp_kernel)
        load_address = kernel.header['e_entry']
        debug("load address = 0x%X" % load_address)

    msg_header = 0x81000000 | ROM_CONTROL_LOADFW
    ext_header = 0x80000000 | dword_count | load_flags | clock_sel

    flash_content.append(msg_header)
    flash_content.append(ext_header)
    flash_content.append(load_address)
    flash_content.append(fw_offset)
    flash_content.append(fw_size)

def ipc_dbg_exec(address):
    dword_count = 1
    dword_count = 0x3ff & dword_count

    msg_header = 0x81000000 | ROM_CONTROL_EXEC
    ext_header = 0x0 | dword_count

    flash_content.append(msg_header)
    flash_content.append(ext_header)
    flash_content.append(address)

def ipc_dbg_memwrite(address, value):
    dword_count = 2
    dword_count = 0x3ff & dword_count

    msg_header = 0x81000000 | ROM_CONTROL_MEMWRITE
    ext_header = 0x0 | dword_count

    flash_content.append(msg_header)
    flash_content.append(ext_header)
    flash_content.append(address)
    flash_content.append(value)

def parse_args():
    global args
    parser = argparse.ArgumentParser(
        description=help_text,
        formatter_class=argparse.RawTextHelpFormatter)

    parser.add_argument("-i", "--in_file", required=True,
					help="Input FW Bin File")
    parser.add_argument("-o", "--out_file", required=True,
					help="Output Flash Bin File")
    parser.add_argument("-l", "--kernel", required=True,
                                        help="Zephyr kernel image")
    parser.add_argument("-m", "--no_sram", action="store_true",
					help="No SRAM")
    parser.add_argument("-c", "--no_l1cache", action="store_true",
					help="No L1 Cache")
    parser.add_argument("-t", "--no_tlb", action="store_true",
					help="No TLB")
    parser.add_argument("-x", "--no_exec", action="store_true",
					help="No Exec")
    parser.add_argument("-s", "--no_sha", action="store_true",
					help="No SHA")
    parser.add_argument("-k", "--clk_sel", action="store_true",
					help="Clock Select")

    args = parser.parse_args()

def main():
    global flash_content, write_buf
    parse_args()

    in_file_size = os.path.getsize(args.in_file)
    if in_file_size == 0:
        error("%s file has no content\n" % args.in_file)

    out_file_size = FLASH_PART_TABLE_OFFSET + in_file_size

    # round up the flash size to sector boundary
    zeropad_size = FLASH_SECTOR_SIZE - (out_file_size % FLASH_SECTOR_SIZE)
    out_file_size += zeropad_size
    if out_file_size > MAX_FLASH_FILE_SIZE:
        error("%s exceeds %d bytes\n" % (args.out_file, MAX_FLASH_FILE_SIZE))

    # pre-boot initialization commands
    set_magic_number(FLASH_MAGIC_WORD)
    set_partition_table_pointer(FLASH_PART_TABLE_OFFSET)
    ipc_dbg_memwrite(0x71d14, 0x0)
    ipc_dbg_memwrite(0x71d24, 0x0)
    ipc_dbg_memwrite(0x304628, 0xd)
    ipc_dbg_memwrite(0x71fd0, 0x3)

    # load the image at address FLASH_PART_TABLE_OFFSET in flash to SRAM
    # at load_address (determined by the entrypoint in the supplied elf)
    ipc_load_fw(SRAM_SIZE, FLASH_PART_TABLE_OFFSET)

    # pad zeros until FLASH_PART_TABLE_OFFSET
    num_zero_pad = FLASH_PART_TABLE_OFFSET // 4 - len(flash_content)
    flash_content += num_zero_pad * [0]

    # read contents of firmware input file and change the endianness
    with open(args.in_file, "rb") as in_fp:
        read_buf = in_fp.read()
        in_fp.close()
        for itr in range(int(in_file_size/4)):
            write_buf.append(read_buf[itr*4 + 3])
            write_buf.append(read_buf[itr*4 + 2])
            write_buf.append(read_buf[itr*4 + 1])
            write_buf.append(read_buf[itr*4 + 0])

        # pad zeros until the sector boundary
        write_buf += zeropad_size*[0]

    # Generate the file which should be downloaded to Flash
    with open(args.out_file, "wb") as out_fp:
        # write as a uint (4 bytes) with byte order swapped (big-endian)
        out_fp.write(struct.pack(">{}I".format(len(flash_content)),
                                                        *flash_content))

        # write as a byte
        out_fp.write(struct.pack("{}B".format(len(write_buf)),
                                                        *write_buf))

        out_fp.close()

    debug("Input %s = %ld bytes" % (os.path.basename(args.in_file), in_file_size))
    debug("Output %s = %ld bytes" % (os.path.basename(args.out_file), out_file_size))

if __name__ == "__main__":
    main()