You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
375 lines
16 KiB
375 lines
16 KiB
#!/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)
|
|
|