#!/usr/bin/env python3
#
# Copyright (c) 2017 Intel Corporation
# Copyright (c) 2018 Foundries.io
# Copyright (c) 2023 Nordic Semiconductor NA
#
# SPDX-License-Identifier: Apache-2.0
#

import struct

class gen_isr_parser:
    source_header = """
/* AUTO-GENERATED by gen_isr_tables.py, do not edit! */

#include <zephyr/toolchain.h>
#include <zephyr/linker/sections.h>
#include <zephyr/sw_isr_table.h>
#include <zephyr/arch/cpu.h>

"""

    shared_isr_table_header = """

/* For this parser to work, we have to be sure that shared interrupts table entry
 * and the normal isr table entry have exactly the same layout
 */
BUILD_ASSERT(sizeof(struct _isr_table_entry)
             ==
             sizeof(struct z_shared_isr_table_entry),
             "Shared ISR and ISR table entries layout do not match");
BUILD_ASSERT(offsetof(struct _isr_table_entry, arg)
             ==
             offsetof(struct z_shared_isr_table_entry, arg),
             "Shared ISR and ISR table entries layout do not match");
BUILD_ASSERT(offsetof(struct _isr_table_entry, isr)
             ==
             offsetof(struct z_shared_isr_table_entry, isr),
             "Shared ISR and ISR table entries layout do not match");

"""

    def __init__(self, intlist_data, config, log):
        """Initialize the parser.

        The function prepares parser to work.
        Parameters:
        - intlist_data: The binnary data from intlist section
        - config: The configuration object
        - log: The logging object, has to have error and debug methods
        """
        self.__config = config
        self.__log = log
        intlist = self.__read_intlist(intlist_data)
        self.__vt, self.__swt, self.__nv, header = self.__parse_intlist(intlist)
        self.__swi_table_entry_size = header["swi_table_entry_size"]
        self.__shared_isr_table_entry_size = header["shared_isr_table_entry_size"]
        self.__shared_isr_client_num_offset = header["shared_isr_client_num_offset"]

    def __read_intlist(self, intlist_data):
        """read an intList section from the elf file.
        This is version 2 of a header created by include/zephyr/linker/intlist.ld:

        struct {
            uint32_t num_vectors; <- typically CONFIG_NUM_IRQS
            uint8_t stream[];     <- the stream with the interrupt data
        };

        The stream is contained from variable length records in a form:

        struct _isr_list_sname {
           /** IRQ line number */
           int32_t irq;
           /** Flags for this IRQ, see ISR_FLAG_* definitions */
           int32_t flags;
           /** The section name */
           const char sname[];
        };

        The flexible array member here (sname) contains the name of the section where the structure
        with interrupt data is located.
        It is always Null-terminated string thus we have to search through the input data for the
        structure end.

        """
        intlist = {}
        prefix = self.__config.endian_prefix()

         # Extract header and the rest of the data
        intlist_header_fmt = prefix + "IIIII"
        header_sz = struct.calcsize(intlist_header_fmt)
        header_raw = struct.unpack_from(intlist_header_fmt, intlist_data, 0)
        self.__log.debug(str(header_raw))

        intlist["num_vectors"]                  = header_raw[0]
        intlist["offset"]                       = header_raw[1]
        intlist["swi_table_entry_size"]         = header_raw[2]
        intlist["shared_isr_table_entry_size"]  = header_raw[3]
        intlist["shared_isr_client_num_offset"] = header_raw[4]

        intdata = intlist_data[header_sz:]

        # Extract information about interrupts
        intlist_entry_fmt = prefix + "ii"
        entry_sz = struct.calcsize(intlist_entry_fmt)
        intlist["interrupts"] = []

        while len(intdata) > entry_sz:
            entry_raw = struct.unpack_from(intlist_entry_fmt, intdata, 0)
            intdata = intdata[entry_sz:]
            null_idx = intdata.find(0)
            if null_idx < 0:
                self.__log.error("Cannot find sname null termination at IRQ{}".format(entry_raw[0]))
            bname = intdata[:null_idx]
            # Next structure starts with 4B alignment
            next_idx = null_idx + 1
            next_idx = (next_idx + 3) & ~3
            intdata = intdata[next_idx:]
            sname = bname.decode()
            intlist["interrupts"].append([entry_raw[0], entry_raw[1], sname])
            self.__log.debug("Unpacked IRQ{}, flags: {}, sname: \"{}\"\n".format(
                entry_raw[0], entry_raw[1], sname))

        # If any data left at the end - it has to be all the way 0 - this is just a check
        if (len(intdata) and not all([d == 0 for d in intdata])):
            self.__log.error("Non-zero data found at the end of the intList data.\n")

        self.__log.debug("Configured interrupt routing with linker")
        self.__log.debug("irq flags sname")
        self.__log.debug("--------------------------")

        for irq in intlist["interrupts"]:
            self.__log.debug("{0:<3} {1:<5} {2}".format(
                hex(irq[0]), irq[1], irq[2]))

        return intlist

    def __parse_intlist(self, intlist):
        """All the intlist data are parsed into swt and vt arrays.

        The vt array is prepared for hardware interrupt table.
        Every entry in the selected position would contain None or the name of the function pointer
        (address or string).

        The swt is a little more complex. At every position it would contain an array of parameter and
        function pointer pairs. If CONFIG_SHARED_INTERRUPTS is enabled there may be more than 1 entry.
        If empty array is placed on selected position - it means that the application does not implement
        this interrupt.

        Parameters:
        - intlist: The preprocessed list of intlist section content (see read_intlist)

        Return:
        vt, swt - parsed vt and swt arrays (see function description above)
        """
        nvec = intlist["num_vectors"]
        offset = intlist["offset"]
        header = {
            "swi_table_entry_size":         intlist["swi_table_entry_size"],
            "shared_isr_table_entry_size":  intlist["shared_isr_table_entry_size"],
            "shared_isr_client_num_offset": intlist["shared_isr_client_num_offset"]
        }

        if nvec > pow(2, 15):
            raise ValueError('nvec is too large, check endianness.')

        self.__log.debug('offset is ' + str(offset))
        self.__log.debug('num_vectors is ' + str(nvec))

        # Set default entries in both tables
        if not(self.__config.args.sw_isr_table or self.__config.args.vector_table):
            self.__log.error("one or both of -s or -V needs to be specified on command line")
        if self.__config.args.vector_table:
            vt = [None for i in range(nvec)]
        else:
            vt = None
        if self.__config.args.sw_isr_table:
            swt = [[] for i in range(nvec)]
        else:
            swt = None

        # Process intlist and write to the tables created
        for irq, flags, sname in intlist["interrupts"]:
            if self.__config.test_isr_direct(flags):
                if not 0 <= irq - offset < len(vt):
                    self.__log.error("IRQ %d (offset=%d) exceeds the maximum of %d" %
                          (irq - offset, offset, len(vt) - 1))
                vt[irq - offset] = sname
            else:
                # Regular interrupt
                if not swt:
                    self.__log.error("Regular Interrupt %d declared with section name %s "
                                     "but no SW ISR_TABLE in use"
                                     % (irq, sname))

                table_index = self.__config.get_swt_table_index(offset, irq)

                if not 0 <= table_index < len(swt):
                    self.__log.error("IRQ %d (offset=%d) exceeds the maximum of %d" %
                                     (table_index, offset, len(swt) - 1))
                # Check if the given section name does not repeat outside of current interrupt
                for i in range(nvec):
                    if i == irq:
                        continue
                    if sname in swt[i]:
                        self.__log.error(("Attempting to register the same section name \"{}\"for" +
                                          "different interrupts: {} and {}").format(sname, i, irq))
                if self.__config.check_shared_interrupts():
                    lst = swt[table_index]
                    if len(lst) >= self.__config.get_sym("CONFIG_SHARED_IRQ_MAX_NUM_CLIENTS"):
                        self.__log.error(f"Reached shared interrupt client limit. Maybe increase"
                                         + f" CONFIG_SHARED_IRQ_MAX_NUM_CLIENTS?")
                else:
                    if len(swt[table_index]) > 0:
                        self.__log.error(f"multiple registrations at table_index {table_index} for irq {irq} (0x{irq:x})"
                                         + f"\nExisting section {swt[table_index]}, new section {sname}"
                                         + "\nHas IRQ_CONNECT or IRQ_DIRECT_CONNECT accidentally been invoked on the same irq multiple times?"
                        )
                swt[table_index].append(sname)

        return vt, swt, nvec, header

    @staticmethod
    def __irq_spurious_section(irq):
        return '.irq_spurious.0x{:x}'.format(irq)

    @staticmethod
    def __isr_generated_section(irq):
        return '.isr_generated.0x{:x}'.format(irq)

    @staticmethod
    def __shared_entry_section(irq, ent):
        return '.isr_shared.0x{:x}_0x{:x}'.format(irq, ent)

    @staticmethod
    def __shared_client_num_section(irq):
        return '.isr_shared.0x{:x}_client_num'.format(irq)

    def __isr_spurious_entry(self, irq):
        return '_Z_ISR_TABLE_ENTRY({irq}, {func}, NULL, "{sect}");'.format(
                irq = irq,
                func = self.__config.swt_spurious_handler,
                sect = self.__isr_generated_section(irq)
            )

    def __isr_shared_entry(self, irq):
        return '_Z_ISR_TABLE_ENTRY({irq}, {func}, {arg}, "{sect}");'.format(
                irq = irq,
                arg = '&{}[{}]'.format(self.__config.shared_array_name, irq),
                func = self.__config.swt_shared_handler,
                sect = self.__isr_generated_section(irq)
            )

    def __irq_spurious_entry(self, irq):
        return '_Z_ISR_DIRECT_TABLE_ENTRY({irq}, {func}, "{sect}");'.format(
                irq = irq,
                func = self.__config.vt_default_handler,
                sect = self.__irq_spurious_section(irq)
            )

    def __write_isr_handlers(self, fp):
        for i in range(self.__nv):
            if len(self.__swt[i]) <= 0:
                fp.write(self.__isr_spurious_entry(i) + '\n')
            elif len(self.__swt[i]) > 1:
                # Connect to shared handlers
                fp.write(self.__isr_shared_entry(i) + '\n')
            else:
                fp.write('/* ISR: {} implemented in app in "{}" section. */\n'.format(
                         i, self.__swt[i][0]))

    def __write_irq_handlers(self, fp):
        for i in range(self.__nv):
            if self.__vt[i] is None:
                fp.write(self.__irq_spurious_entry(i) + '\n')
            else:
                fp.write('/* ISR: {} implemented in app. */\n'.format(i))

    def __write_shared_handlers(self, fp):
        fp.write("extern struct z_shared_isr_table_entry "
                "{}[{}];\n".format(self.__config.shared_array_name, self.__nv))

        shared_cnt = self.__config.get_sym('CONFIG_SHARED_IRQ_MAX_NUM_CLIENTS')
        for i in range(self.__nv):
            swt_len = len(self.__swt[i])
            for j in range(shared_cnt):
                if (swt_len <= 1) or (swt_len <= j):
                    # Add all unused entry
                    fp.write('static Z_DECL_ALIGN(struct _isr_table_entry)\n' +
                             '\tZ_GENERIC_SECTION({})\n'.format(self.__shared_entry_section(i, j)) +
                             '\t__used isr_shared_empty_entry_0x{:x}_0x{:x} = {{\n'.format(i, j) +
                             '\t\t.arg = (const void *)NULL,\n' +
                             '\t\t.isr = (void (*)(const void *))(void *)0\n' +
                             '};\n'
                    )
                else:
                    # Add information about entry implemented by application
                    fp.write('/* Shared isr {} entry {} implemented in "{}" section*/\n'.format(
                             i, j, self.__swt[i][j]))

            # Add information about clients count
            fp.write(('static size_t Z_GENERIC_SECTION({}) __used\n' +
                      'isr_shared_client_num_0x{:x} = {};\n\n').format(
                         self.__shared_client_num_section(i),
                         i,
                         0 if swt_len < 2 else swt_len)
            )

    def write_source(self, fp):
        fp.write(self.source_header)

        if self.__vt:
            self.__write_irq_handlers(fp)

        if not self.__swt:
            return

        if self.__config.check_shared_interrupts():
            self.__write_shared_handlers(fp)

        self.__write_isr_handlers(fp)

    def __write_linker_irq(self, fp):
        fp.write('{} = .;\n'.format(self.__config.irq_vector_array_name))
        for i in range(self.__nv):
            if self.__vt[i] is None:
                sname = self.__irq_spurious_section(i)
            else:
                sname = self.__vt[i]
            fp.write('KEEP(*("{}"))\n'.format(sname))

    def __write_linker_shared(self, fp):
        fp.write(". = ALIGN({});\n".format(self.__shared_isr_table_entry_size))
        fp.write('{} = .;\n'.format(self.__config.shared_array_name))
        shared_cnt = self.__config.get_sym('CONFIG_SHARED_IRQ_MAX_NUM_CLIENTS')
        client_num_pads = self.__shared_isr_client_num_offset - \
            shared_cnt * self.__swi_table_entry_size
        if client_num_pads < 0:
            self.__log.error("Invalid __shared_isr_client_num_offset header value")
        for i in range(self.__nv):
            swt_len = len(self.__swt[i])
            # Add all entries
            for j in range(shared_cnt):
                if (swt_len <= 1) or (swt_len <= j):
                    fp.write('KEEP(*("{}"))\n'.format(self.__shared_entry_section(i, j)))
                else:
                    sname = self.__swt[i][j]
                    if (j != 0) and (sname in self.__swt[i][0:j]):
                        fp.write('/* Repetition of "{}" section */\n'.format(sname))
                    else:
                        fp.write('KEEP(*("{}"))\n'.format(sname))
            fp.write('. = . + {};\n'.format(client_num_pads))
            fp.write('KEEP(*("{}"))\n'.format(self.__shared_client_num_section(i)))
            fp.write(". = ALIGN({});\n".format(self.__shared_isr_table_entry_size))

    def __write_linker_isr(self, fp):
        fp.write(". = ALIGN({});\n".format(self.__swi_table_entry_size))
        fp.write('{} = .;\n'.format(self.__config.sw_isr_array_name))
        for i in range(self.__nv):
            if (len(self.__swt[i])) == 1:
                sname = self.__swt[i][0]
            else:
                sname = self.__isr_generated_section(i)
            fp.write('KEEP(*("{}"))\n'.format(sname))

    def write_linker_vt(self, fp):
        if self.__vt:
            self.__write_linker_irq(fp)

    def write_linker_swi(self, fp):
        if self.__swt:
            self.__write_linker_isr(fp)

            if self.__config.check_shared_interrupts():
                self.__write_linker_shared(fp)