a0148a8544
Gets rid of the Python file extension, since the fact the code is written in this language could conceivably change someday (and doesn't really need to be advertised to anyone invoking it). Change-Id: I0d01a89fd25e4a0f033099a4bcea674bc302c658 Signed-off-by: Allan Stephens <allan.stephens@windriver.com>
1201 lines
38 KiB
Python
Executable File
1201 lines
38 KiB
Python
Executable File
#! /usr/bin/env python
|
|
#
|
|
# sysgen - System Generator
|
|
#
|
|
#
|
|
# Copyright (c) 2015, Wind River Systems, Inc.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
#
|
|
# 1) Redistributions of source code must retain the above copyright notice,
|
|
# this list of conditions and the following disclaimer.
|
|
#
|
|
# 2) Redistributions in binary form must reproduce the above copyright notice,
|
|
# this list of conditions and the following disclaimer in the documentation
|
|
# and/or other materials provided with the distribution.
|
|
#
|
|
# 3) Neither the name of Wind River Systems nor the names of its contributors
|
|
# may be used to endorse or promote products derived from this software without
|
|
# specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
|
|
# Arguments:
|
|
# - name of MDEF file
|
|
# - name of directory for output files (optional)
|
|
|
|
# Generates:
|
|
# - kernel_main.c file
|
|
# - kernel_main.h file (local copy)
|
|
# - kernel_struct.h file (local copy)
|
|
# - zephyr.h file
|
|
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
|
|
# global variables describing system
|
|
|
|
num_kargs = 0
|
|
num_timers = 0
|
|
num_prios = 0
|
|
|
|
task_list = []
|
|
event_list = []
|
|
mutex_list = []
|
|
sema_list = []
|
|
fifo_list = []
|
|
pipe_list = []
|
|
mbx_list = []
|
|
map_list = []
|
|
pool_list = []
|
|
|
|
driver_list = []
|
|
|
|
group_dictionary = {}
|
|
group_key_list = []
|
|
|
|
# global variables used during generation of output files
|
|
|
|
do_not_edit_warning = \
|
|
"\n\n\n/* THIS FILE IS AUTOGENERATED -- DO NOT MODIFY! */\n\n\n"
|
|
|
|
copyright = \
|
|
"/*\n" + \
|
|
" * Copyright (c) 2015 Wind River Systems, Inc.\n" + \
|
|
" *\n" + \
|
|
" * Redistribution and use in source and binary forms," + \
|
|
" with or without\n" + \
|
|
" * modification, are permitted provided that the following conditions" + \
|
|
" are met:\n" + \
|
|
" *\n" + \
|
|
" * 1) Redistributions of source code must retain" + \
|
|
" the above copyright notice,\n" + \
|
|
" * this list of conditions and the following disclaimer.\n" + \
|
|
" *\n" + \
|
|
" * 2) Redistributions in binary form must reproduce" + \
|
|
" the above copyright notice,\n" + \
|
|
" * this list of conditions and the following disclaimer" + \
|
|
" in the documentation\n" + \
|
|
" * and/or other materials provided with the distribution.\n" + \
|
|
" *\n" + \
|
|
" * 3) Neither the name of Wind River Systems nor the names" + \
|
|
" of its contributors\n" + \
|
|
" * may be used to endorse or promote products derived" + \
|
|
" from this software without\n" + \
|
|
" * specific prior written permission.\n" + \
|
|
" *\n" + \
|
|
" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS" + \
|
|
" AND CONTRIBUTORS \"AS IS\"\n" + \
|
|
" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING," + \
|
|
" BUT NOT LIMITED TO, THE\n" + \
|
|
" * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS" + \
|
|
" FOR A PARTICULAR PURPOSE\n" + \
|
|
" * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER" + \
|
|
" OR CONTRIBUTORS BE\n" + \
|
|
" * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL," + \
|
|
" EXEMPLARY, OR\n" + \
|
|
" * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO," + \
|
|
" PROCUREMENT OF\n" + \
|
|
" * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;" + \
|
|
" OR BUSINESS\n" + \
|
|
" * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY," + \
|
|
" WHETHER IN\n" + \
|
|
" * CONTRACT, STRICT LIABILITY, OR TORT" + \
|
|
" (INCLUDING NEGLIGENCE OR OTHERWISE)\n" + \
|
|
" * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE," + \
|
|
" EVEN IF ADVISED OF THE\n" + \
|
|
" * POSSIBILITY OF SUCH DAMAGE.\n" + \
|
|
" */\n"
|
|
|
|
output_dir = ""
|
|
|
|
|
|
def get_output_dir():
|
|
""" Handle optional output directory argument """
|
|
|
|
global output_dir
|
|
if len(sys.argv) > 2:
|
|
output_dir = sys.argv[2]
|
|
|
|
|
|
def write_file(filename, contents):
|
|
""" Create file using specified name and contents """
|
|
|
|
f = open(filename, 'w') # overwrites file if it already exists
|
|
f.write(contents)
|
|
f.close()
|
|
|
|
|
|
#
|
|
# ERROR HANDLING
|
|
#
|
|
|
|
|
|
def sysgen_error(msg):
|
|
print("\n*** sysgen error: " + msg + "\n")
|
|
sys.exit(1)
|
|
|
|
|
|
def error_arg_count(line):
|
|
sysgen_error("invalid number of arguments on following line\n" + line)
|
|
|
|
|
|
#
|
|
# CREATE INTERNAL REPRESENTATION OF SYSTEM
|
|
#
|
|
|
|
|
|
def mdef_parse():
|
|
""" Parse MDEF file """
|
|
|
|
global num_kargs
|
|
global num_timers
|
|
global num_prios
|
|
|
|
# read file contents in a single shot
|
|
with open(sys.argv[1], 'r') as infile:
|
|
data = infile.read()
|
|
|
|
# create list of the lines, breaking at line boundaries
|
|
my_list = data.splitlines()
|
|
|
|
# process each line
|
|
for line in my_list:
|
|
words = line.split()
|
|
|
|
if (len(words) == 0):
|
|
continue # ignore blank line
|
|
|
|
if (words[0][0] == "%"):
|
|
continue # ignore comment line
|
|
|
|
if (words[0] == "CONFIG"):
|
|
if (len(words) != 4):
|
|
error_arg_count(line)
|
|
num_kargs = int(words[1])
|
|
num_timers = int(words[2])
|
|
num_prios = int(words[3])
|
|
continue
|
|
|
|
if (words[0] == "TASK"):
|
|
if (len(words) != 6):
|
|
error_arg_count(line)
|
|
task_list.append((words[1], int(words[2]), words[3],
|
|
int(words[4]), words[5]))
|
|
continue
|
|
|
|
if (words[0] == "TASKGROUP"):
|
|
if (len(words) != 2):
|
|
error_arg_count(line)
|
|
if words[1] in group_dictionary:
|
|
continue # ignore re-definition of a task group
|
|
group_bitmask = 1 << len(group_dictionary)
|
|
group_dictionary[words[1]] = group_bitmask
|
|
group_key_list.append(words[1])
|
|
continue
|
|
|
|
if (words[0] == "EVENT"):
|
|
if (len(words) != 3):
|
|
error_arg_count(line)
|
|
event_list.append((words[1], words[2]))
|
|
continue
|
|
|
|
if (words[0] == "SEMA"):
|
|
if (len(words) != 2):
|
|
error_arg_count(line)
|
|
sema_list.append((words[1],))
|
|
continue
|
|
|
|
if (words[0] == "MUTEX"):
|
|
if (len(words) != 2):
|
|
error_arg_count(line)
|
|
mutex_list.append((words[1],))
|
|
continue
|
|
|
|
if (words[0] == "FIFO"):
|
|
if (len(words) != 4):
|
|
error_arg_count(line)
|
|
fifo_list.append((words[1], int(words[2]), int(words[3])))
|
|
continue
|
|
|
|
if (words[0] == "PIPE"):
|
|
if (len(words) != 3):
|
|
error_arg_count(line)
|
|
pipe_list.append((words[1], int(words[2])))
|
|
continue
|
|
|
|
if (words[0] == "MAILBOX"):
|
|
if (len(words) != 2):
|
|
error_arg_count(line)
|
|
mbx_list.append((words[1],))
|
|
continue
|
|
|
|
if (words[0] == "MAP"):
|
|
if (len(words) != 4):
|
|
error_arg_count(line)
|
|
map_list.append((words[1], int(words[2]), int(words[3])))
|
|
continue
|
|
|
|
if (words[0] == "POOL"):
|
|
if (len(words) != 5):
|
|
error_arg_count(line)
|
|
pool_list.append((words[1], int(words[2]), int(words[3]),
|
|
int(words[4])))
|
|
continue
|
|
|
|
if (words[0] == "TIMERDRIVER"):
|
|
if (len(words) == 1):
|
|
error_arg_count(line)
|
|
if (num_timers == 0):
|
|
continue # ignore timer driver for a tickless microkernel
|
|
start_quote = line.find("'")
|
|
end_quote = line.rfind("'")
|
|
driver_list.append(line[start_quote + 1:end_quote])
|
|
continue
|
|
|
|
if (words[0] == "USERDRIVER"):
|
|
if (len(words) == 1):
|
|
error_arg_count(line)
|
|
start_quote = line.find("'")
|
|
end_quote = line.rfind("'")
|
|
driver_list.append(line[start_quote + 1:end_quote])
|
|
continue
|
|
|
|
sysgen_error("unrecognized keyword %s on following line\n%s" %
|
|
(words[0], line))
|
|
|
|
|
|
#
|
|
# GENERATE kernel_main.c FILE
|
|
#
|
|
|
|
|
|
kernel_main_c_data = ""
|
|
|
|
kernel_main_c_filename_str = \
|
|
"/* kernel_main.c - microkernel mainline and kernel objects */\n\n"
|
|
|
|
|
|
def kernel_main_c_out(string):
|
|
""" Append a string to kernel_main.c """
|
|
|
|
global kernel_main_c_data
|
|
kernel_main_c_data += string
|
|
|
|
|
|
def kernel_main_c_header():
|
|
""" Generate initial portion of kernel_main.c """
|
|
|
|
kernel_main_c_out(
|
|
kernel_main_c_filename_str +
|
|
copyright +
|
|
do_not_edit_warning +
|
|
"\n" +
|
|
"#include <zephyr.h>\n" +
|
|
"#include <drivers/system_timer.h>\n" +
|
|
"#include <kernel_struct.h>\n" +
|
|
"#include <kernel_main.h>\n" +
|
|
"#include <toolchain.h>\n" +
|
|
"#include <sections.h>\n")
|
|
|
|
|
|
def kernel_main_c_kargs():
|
|
""" Generate command packet variables """
|
|
|
|
# command packets
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_args _k_server_command_packets[%s] =\n" % (num_kargs) +
|
|
"{\n" +
|
|
" {NULL, NULL, 0, 0, (K_COMM) UNDEFINED},\n")
|
|
for i in range(1, num_kargs - 1):
|
|
kernel_main_c_out(
|
|
" {&_k_server_command_packets[%d], " % (i - 1) +
|
|
"NULL, 0, 0, (K_COMM) UNDEFINED},\n")
|
|
kernel_main_c_out(
|
|
" {&_k_server_command_packets[%d], " % (num_kargs - 2) +
|
|
"NULL, 0, 0, (K_COMM) UNDEFINED}\n" +
|
|
"};\n")
|
|
|
|
# linked list of free command packets
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct nano_lifo _k_server_command_packet_free = " +
|
|
"{{NULL, &_k_server_command_packet_free.wait_q.head}, " +
|
|
"(void *) &_k_server_command_packets[%d]};\n" % (num_kargs - 1))
|
|
|
|
|
|
def kernel_main_c_timers():
|
|
""" Generate timer system variables """
|
|
|
|
if (num_timers == 0):
|
|
return
|
|
|
|
# timer descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_timer _k_timer_blocks[%d] =\n" % (num_timers) +
|
|
"{\n" +
|
|
" {NULL, NULL, 0, 0, (struct k_args *)0xffffffff},\n")
|
|
for i in range(1, num_timers - 1):
|
|
kernel_main_c_out(
|
|
" {&_k_timer_blocks[%d], " % (i - 1) +
|
|
"NULL, 0, 0, (struct k_args *)0xffffffff},\n")
|
|
kernel_main_c_out(
|
|
" {&_k_timer_blocks[%d], " % (num_timers - 2) +
|
|
"NULL, 0, 0, (struct k_args *)0xffffffff}\n" +
|
|
"};\n")
|
|
|
|
# linked list of free timers
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct nano_lifo _k_timer_free = " +
|
|
"{{NULL, &_k_timer_free.wait_q.head}, " +
|
|
"(void *) &_k_timer_blocks[%d]};\n" % (num_timers - 1))
|
|
|
|
|
|
def kernel_main_c_tasks():
|
|
""" Generate task variables """
|
|
|
|
global num_prios
|
|
|
|
total_tasks = len(task_list) + 1
|
|
|
|
# task global variables
|
|
|
|
kernel_main_c_out("\nint _k_task_count = %d;\n" % (total_tasks - 1))
|
|
|
|
# task stack areas
|
|
|
|
kernel_main_c_out("\n")
|
|
for task in task_list:
|
|
kernel_main_c_out("char __noinit __stack __%s_stack[%d];\n" %
|
|
(task[0], task[3]))
|
|
|
|
kernel_main_c_out("extern char main_task_stack[CONFIG_MAIN_STACK_SIZE];\n")
|
|
|
|
# declare task entry points
|
|
|
|
kernel_main_c_out("\n")
|
|
for task in task_list:
|
|
kernel_main_c_out("extern void %s(void);\n" % task[2])
|
|
|
|
# task descriptors (including one for idle task)
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_proc _k_task_list[%d] =\n" % (total_tasks) +
|
|
"{\n")
|
|
ident = 0x00010000
|
|
for task in task_list:
|
|
prio = task[1]
|
|
entry = task[2]
|
|
size = task[3]
|
|
|
|
stack = "__" + task[0] + "_stack"
|
|
|
|
# create bitmask of group(s) task belongs to
|
|
group_bitmask = 0
|
|
group_set = task[4][1:len(task[4]) - 1] # drop [] surrounding groups
|
|
if (group_set != ""):
|
|
group_list = group_set.split(',')
|
|
for group in group_list:
|
|
group_bitmask |= group_dictionary[group]
|
|
|
|
# invert bitmask to convert SYS indication to non-SYS indication
|
|
#
|
|
# NOTE: There actually is no SYS group; instead, there is a non-SYS
|
|
# group that all tasks belong to unless they specify the 'SYS' name.
|
|
# This approach allows the kernel to easily suspend all non-SYS tasks
|
|
# during debugging, while minimizing the number of task entries that
|
|
# have to explicitly indicate their SYS/non-SYS status.
|
|
group_bitmask ^= group_dictionary['SYS']
|
|
|
|
kernel_main_c_out(
|
|
" {NULL, NULL, %d, %#010x, " % (prio, ident) +
|
|
"0x00000001, %#010x,\n" % (group_bitmask) +
|
|
"%s, %s, %d, (taskabortfunction)NULL},\n" % (entry, stack, size))
|
|
ident += 1
|
|
|
|
kernel_main_c_out(" {NULL, NULL, %d, 0x00000000, " % (num_prios - 1) +
|
|
"0x00000000, 0x00000000,\n" +
|
|
"(taskstartfunction)NULL, main_task_stack, CONFIG_MAIN_STACK_SIZE, " +
|
|
"(taskabortfunction)NULL}\n")
|
|
kernel_main_c_out("};\n")
|
|
|
|
# currently scheduled task (idle task)
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_proc * _k_current_task = &_k_task_list[%d];\n" %
|
|
(total_tasks - 1))
|
|
|
|
|
|
def kernel_main_c_priorities():
|
|
""" Generate task scheduling variables """
|
|
|
|
global num_prios
|
|
|
|
total_tasks = len(task_list) + 1
|
|
|
|
# priority queue descriptors (lowest priority queue contains idle task)
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_tqhd _k_task_priority_list[%d] =\n" % (num_prios) +
|
|
"{\n")
|
|
for i in range(1, num_prios):
|
|
kernel_main_c_out(
|
|
" {NULL, (struct k_proc *)&_k_task_priority_list[%d]},\n" %
|
|
(i - 1))
|
|
kernel_main_c_out(
|
|
" {&_k_task_list[%d], &_k_task_list[%d]}\n" %
|
|
(total_tasks - 1, total_tasks - 1) +
|
|
"};\n")
|
|
|
|
# active priority queue (idle task's queue)
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_tqhd * K_Prio = &_k_task_priority_list[%d];\n" %
|
|
(num_prios - 1))
|
|
|
|
# priority queue bit map (indicates which priority queues are non-empty;
|
|
# initially only the idle task's queue has a runnable task)
|
|
|
|
num_bit_maps = ((num_prios + 31) // 32)
|
|
|
|
kernel_main_c_out("\n" +
|
|
"uint32_t _k_task_priority_bitmap[%d] = {" % (num_bit_maps))
|
|
for i in range(1, num_bit_maps):
|
|
kernel_main_c_out("0, ")
|
|
kernel_main_c_out("(1u << %d)};\n" % ((num_prios - 1) & 0x1f))
|
|
|
|
|
|
def kernel_main_c_events():
|
|
""" Generate event variables """
|
|
|
|
total_events = 4 + len(event_list)
|
|
|
|
# event descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct evstr _k_event_list[%d] =\n" % (total_events) +
|
|
"{\n")
|
|
# pre-defined events
|
|
if (num_timers > 0):
|
|
kernel_main_c_out(
|
|
" {0, (kevent_handler_t)_k_ticker, " +
|
|
"(struct k_args *)NULL, 0},\n")
|
|
else:
|
|
kernel_main_c_out(
|
|
" {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n")
|
|
kernel_main_c_out(
|
|
" {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n" +
|
|
" {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n" +
|
|
" {0, (kevent_handler_t)NULL, (struct k_args *)NULL, 0},\n"
|
|
)
|
|
# project-specific events
|
|
for event in event_list:
|
|
kernel_main_c_out(
|
|
" {0, (kevent_handler_t)%s, (struct k_args *)NULL, 0},\n" %
|
|
(event[1]))
|
|
kernel_main_c_out("};\n")
|
|
|
|
# number of events
|
|
|
|
kernel_main_c_out("\n" +
|
|
"const int _k_num_events = %d;\n" % (total_events))
|
|
|
|
# event object identifiers (for project-defined events only)
|
|
|
|
if (len(event_list) > 0):
|
|
kernel_main_c_out("\n")
|
|
|
|
for event_name in event_list:
|
|
kernel_main_c_out(
|
|
"const kevent_t %s_objId = %s;\n" %
|
|
(event_name[0], event_name[0]))
|
|
|
|
|
|
def kernel_main_c_mutexes():
|
|
""" Generate mutex variables """
|
|
|
|
total_mutexes = len(mutex_list)
|
|
|
|
if (total_mutexes == 0):
|
|
kernel_main_c_out("\nstruct mutex_struct * _k_mutex_list = NULL;\n")
|
|
return
|
|
|
|
# mutex descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct mutex_struct _k_mutex_list[%s] =\n" % (total_mutexes) +
|
|
"{\n")
|
|
for mutex in mutex_list:
|
|
kernel_main_c_out(" {ANYTASK, 64, 64, 0, NULL, 0, 0},\n")
|
|
kernel_main_c_out("};\n")
|
|
kernel_main_c_out("\n")
|
|
|
|
# mutex object identifiers
|
|
|
|
for mutex in mutex_list:
|
|
name = mutex[0]
|
|
kernel_main_c_out("const kmutex_t %s_objId = %s;\n" % (name, name))
|
|
|
|
|
|
def kernel_main_c_semas():
|
|
""" Generate semaphore variables """
|
|
|
|
total_semas = len(sema_list)
|
|
|
|
if (total_semas == 0):
|
|
kernel_main_c_out("\nstruct sem_struct * _k_sem_list = NULL;\n")
|
|
return
|
|
|
|
# semaphore descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct sem_struct _k_sem_list[%s] =\n" % (total_semas) +
|
|
"{\n")
|
|
for semaphore in sema_list:
|
|
kernel_main_c_out(" {NULL, 0, 0},\n")
|
|
kernel_main_c_out("};\n")
|
|
|
|
|
|
def kernel_main_c_fifos():
|
|
""" Generate FIFO variables """
|
|
|
|
total_fifos = len(fifo_list)
|
|
|
|
if (total_fifos == 0):
|
|
kernel_main_c_out("\nstruct que_struct * _k_fifo_list = NULL;\n")
|
|
return
|
|
|
|
# FIFO buffers
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
for fifo in fifo_list:
|
|
kernel_main_c_out(
|
|
"char __noinit __%s_buffer[%d];\n" % (fifo[0], fifo[1] * fifo[2]))
|
|
|
|
# FIFO descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct que_struct _k_fifo_list[%s] =\n" % (total_fifos) +
|
|
"{\n"
|
|
)
|
|
for fifo in fifo_list:
|
|
depth = fifo[1]
|
|
width = fifo[2]
|
|
buffer = "__" + fifo[0] + "_buffer"
|
|
kernel_main_c_out(
|
|
" {%d, %d, %s, %s + (%d * %d),\n" %
|
|
(depth, width, buffer, buffer, depth, width) +
|
|
"%s, %s, NULL, 0, 0, 0},\n" %
|
|
(buffer, buffer))
|
|
kernel_main_c_out("};\n")
|
|
|
|
|
|
def kernel_main_c_pipes():
|
|
""" Generate pipe variables """
|
|
|
|
total_pipes = len(pipe_list)
|
|
|
|
# pipe global variables
|
|
|
|
kernel_main_c_out("\nint _k_pipe_count = %d;\n" % (total_pipes))
|
|
|
|
if (total_pipes == 0):
|
|
kernel_main_c_out("\nstruct pipe_struct * _k_pipe_list = NULL;\n")
|
|
return
|
|
|
|
# pipe buffers
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
for pipe in pipe_list:
|
|
kernel_main_c_out(
|
|
"char __noinit __%s_buffer[%d];\n" % (pipe[0], pipe[1]))
|
|
|
|
# pipe descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct pipe_struct _k_pipe_list[%d] =\n" % (total_pipes) +
|
|
"{\n")
|
|
for pipe in pipe_list:
|
|
size = pipe[1]
|
|
buffer = "__" + pipe[0] + "_buffer"
|
|
kernel_main_c_out(" {%d, %s},\n" % (size, buffer))
|
|
kernel_main_c_out("};\n")
|
|
|
|
|
|
def kernel_main_c_mailboxes():
|
|
""" Generate mailbox variables """
|
|
|
|
total_mbxs = len(mbx_list)
|
|
|
|
if (total_mbxs == 0):
|
|
kernel_main_c_out("\nstruct mbx_struct * _k_mbox_list = NULL;\n")
|
|
return
|
|
|
|
# mailbox descriptors
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct mbx_struct _k_mbox_list[%d] =\n" % (total_mbxs) +
|
|
"{\n")
|
|
for mbx in mbx_list:
|
|
kernel_main_c_out(" {NULL, NULL, 0},\n")
|
|
kernel_main_c_out("};\n")
|
|
|
|
|
|
def kernel_main_c_maps():
|
|
""" Generate memory map variables """
|
|
|
|
total_maps = len(map_list)
|
|
|
|
# map global variables
|
|
|
|
kernel_main_c_out("\nint _k_mem_map_count = %d;\n" % (total_maps))
|
|
|
|
if (total_maps == 0):
|
|
kernel_main_c_out("\nstruct map_struct * _k_mem_map_list = NULL;\n")
|
|
return
|
|
|
|
# memory map buffers
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
for map in map_list:
|
|
blocks = map[1]
|
|
block_size = map[2]
|
|
kernel_main_c_out("char __noinit __MAP_%s_buffer[%d];\n" %
|
|
(map[0], blocks * block_size))
|
|
|
|
# memory map descriptors
|
|
|
|
kernel_main_c_out(
|
|
"\nstruct map_struct _k_mem_map_list[%d] =\n{\n" % (total_maps))
|
|
for map in map_list:
|
|
blocks = map[1]
|
|
block_size = map[2]
|
|
kernel_main_c_out(" { %d, %d, __MAP_%s_buffer },\n" %
|
|
(blocks, block_size, map[0]))
|
|
kernel_main_c_out("};\n")
|
|
|
|
|
|
def kernel_main_c_pools():
|
|
""" Generate memory pool variables """
|
|
|
|
total_pools = len(pool_list)
|
|
|
|
# pool global variables
|
|
|
|
kernel_main_c_out("\nint _k_mem_pool_count = %d;\n" % (total_pools))
|
|
|
|
if (total_pools == 0):
|
|
kernel_main_c_out("\nstruct pool_struct * _k_mem_pool_list = NULL;\n")
|
|
return
|
|
|
|
# start accumulating memory pool descriptor info
|
|
|
|
pool_descriptors = "\nstruct pool_struct _k_mem_pool_list[%d] =\n{\n" % \
|
|
(total_pools)
|
|
ident = 0x00010000
|
|
|
|
for pool in pool_list:
|
|
|
|
kernel_main_c_out("\n")
|
|
|
|
# create local variables relating to current pool
|
|
|
|
min_block_size = pool[1]
|
|
max_block_size = pool[2]
|
|
num_maximal_blocks = pool[3]
|
|
total_memory = max_block_size * num_maximal_blocks
|
|
buffer = "__" + pool[0] + "_buffer"
|
|
frag_table = "fragtab_%#010x" % ident
|
|
|
|
# determine block sizes used by pool (including actual minimum size)
|
|
|
|
frag_size_list = [max_block_size]
|
|
while (ident != 0): # loop forever
|
|
min_block_size_actual = frag_size_list[len(frag_size_list) - 1]
|
|
min_block_size_proposed = min_block_size_actual / 4
|
|
if (min_block_size_proposed < min_block_size):
|
|
break
|
|
frag_size_list.append(min_block_size_proposed)
|
|
frag_levels = len(frag_size_list)
|
|
|
|
# determine size of block status arrays
|
|
# - largest size gets special handling
|
|
# - remainder of algorithm is a complete mystery ...
|
|
|
|
block_status_sizes = [(num_maximal_blocks + 3) / 4]
|
|
block_status_size_to_use = num_maximal_blocks
|
|
for index in range(1, frag_levels):
|
|
block_status_sizes.append(block_status_size_to_use)
|
|
block_status_size_to_use *= 4
|
|
|
|
# generate block status areas
|
|
|
|
for index in range(0, frag_levels):
|
|
kernel_main_c_out(
|
|
"struct block_stat blockstatus_%#010x_%d[%d];\n" %
|
|
(ident, index, block_status_sizes[index]))
|
|
|
|
# generate memory pool fragmentation descriptor
|
|
|
|
kernel_main_c_out("\nstruct pool_block %s[%d] =\n{\n" %
|
|
(frag_table, frag_levels))
|
|
for index in range(0, frag_levels):
|
|
kernel_main_c_out(" { %d, %d, blockstatus_%#010x_%d},\n" %
|
|
(frag_size_list[index], block_status_sizes[index],
|
|
ident, index))
|
|
kernel_main_c_out("};\n")
|
|
|
|
# generate memory pool buffer
|
|
|
|
kernel_main_c_out("\nchar __noinit %s[%d];\n" % (buffer, total_memory))
|
|
|
|
# append memory pool descriptor info
|
|
|
|
pool_descriptors += " {%d, %d, 2, %d, %d, %d, NULL, %s, %s},\n" % \
|
|
(max_block_size, min_block_size_actual, total_memory,
|
|
num_maximal_blocks, frag_levels, frag_table, buffer)
|
|
|
|
ident += 1
|
|
|
|
# generate memory pool descriptor info
|
|
|
|
pool_descriptors += "};\n"
|
|
kernel_main_c_out(pool_descriptors)
|
|
|
|
|
|
def kernel_main_c_kernel_services():
|
|
""" Generate kernel services function table """
|
|
|
|
# initialize table with info for all possible kernel services
|
|
|
|
func_table = [
|
|
"/* 0 */ _k_nop,", # required
|
|
"/* 1 */ _k_movedata_request,", # required
|
|
"/* 2 */ (kernelfunc) NULL,", # unused
|
|
"/* 3 */ (kernelfunc) NULL,", # unused
|
|
"/* 4 */ _k_offload_to_fiber,", # required
|
|
"/* 5 */ _k_workload_get,", # required
|
|
"/* 6 */ _k_sem_signal,", # depends on semaphores
|
|
"/* 7 */ _k_sem_group_signal,", # depends on semaphores
|
|
"/* 8 */ _k_sem_reset,", # depends on semaphores
|
|
"/* 9 */ _k_sem_group_reset,", # depends on semaphores
|
|
"/* 10 */ _k_sem_wait_request,", # depends on semaphores
|
|
"/* 11 */ _k_sem_wait_reply,", # depends on semaphores
|
|
"/* 12 */ _k_sem_wait_reply,", # depends on semaphores and
|
|
# timers
|
|
"/* 13 */ _k_sem_group_wait_any,", # depends on semaphores
|
|
"/* 14 */ _k_sem_group_wait_request,", # depends on semaphores
|
|
"/* 15 */ _k_sem_group_ready,", # depends on semaphores
|
|
"/* 16 */ _k_sem_group_wait_cancel,", # depends on semaphores
|
|
"/* 17 */ _k_sem_group_wait_accept,", # depends on semaphores
|
|
"/* 18 */ _k_sem_group_wait,", # depends on semaphores
|
|
"/* 19 */ _k_sem_group_wait_timeout,", # depends on semaphores
|
|
# (but not timers)
|
|
"/* 20 */ _k_sem_inquiry,", # depends on semaphores
|
|
"/* 21 */ _k_mutex_lock_request,", # depends on mutexes
|
|
"/* 22 */ _k_mutex_lock_reply,", # depends on mutexes
|
|
"/* 23 */ _k_mutex_lock_reply,", # depends on mutexes and
|
|
# timers
|
|
"/* 24 */ _k_mutex_unlock,", # depends on mutexes
|
|
"/* 25 */ _k_fifo_enque_request,", # depends on FIFOs
|
|
"/* 26 */ _k_fifo_enque_reply,", # depends on FIFOs
|
|
"/* 27 */ _k_fifo_enque_reply,", # depends on FIFOs and timers
|
|
"/* 28 */ _k_fifo_deque_request,", # depends on FIFOs
|
|
"/* 29 */ _k_fifo_deque_reply,", # depends on FIFOs
|
|
"/* 30 */ _k_fifo_deque_reply,", # depends on FIFOs and timers
|
|
"/* 31 */ _k_fifo_ioctl,", # depends on FIFOs
|
|
"/* 32 */ _k_mbox_send_request,", # depends on mailboxes
|
|
"/* 33 */ _k_mbox_send_reply,", # depends on mailboxes and
|
|
# timers
|
|
"/* 34 */ _k_mbox_send_ack,", # depends on mailboxes
|
|
"/* 35 */ _k_mbox_send_data,", # depends on mailboxes
|
|
"/* 36 */ _k_mbox_receive_request,", # depends on mailboxes
|
|
"/* 37 */ _k_mbox_receive_reply,", # depends on mailboxes and
|
|
# timers
|
|
"/* 38 */ _k_mbox_receive_ack,", # depends on mailboxes
|
|
"/* 39 */ _k_mbox_receive_data,", # depends on mailboxes
|
|
"/* 40 */ _k_time_elapse,", # depends on timers
|
|
"/* 41 */ _k_task_sleep,", # depends on timers
|
|
"/* 42 */ _k_task_wakeup,", # depends on timers
|
|
"/* 43 */ _k_task_op,", # required
|
|
"/* 44 */ _k_task_group_op,", # required
|
|
"/* 45 */ _k_task_priority_set,", # required
|
|
"/* 46 */ _k_task_yield,", # required
|
|
"/* 47 */ _k_mem_map_alloc,", # depends on memory maps
|
|
"/* 48 */ _k_mem_map_dealloc,", # depends on memory maps
|
|
"/* 49 */ _k_timer_alloc,", # depends on timers
|
|
"/* 50 */ _k_timer_dealloc,", # depends on timers
|
|
"/* 51 */ _k_timer_start,", # depends on timers
|
|
"/* 52 */ _k_timer_stop,", # depends on timers
|
|
"/* 53 */ _k_mem_map_alloc_timeout,", # depends on memory maps and
|
|
# timers
|
|
"/* 54 */ (kernelfunc) NULL,", # unused
|
|
"/* 55 */ (kernelfunc) NULL,", # unused
|
|
"/* 56 */ (kernelfunc) NULL,", # unused
|
|
"/* 57 */ (kernelfunc) NULL,", # unused
|
|
"/* 58 */ _k_event_test,", # required
|
|
"/* 59 */ _k_event_handler_set,", # required
|
|
"/* 60 */ _k_event_signal,", # required
|
|
"/* 61 */ _k_mem_pool_block_get,", # depends on memory pools
|
|
"/* 62 */ _k_mem_pool_block_release,", # depends on memory pools
|
|
"/* 63 */ _k_block_waiters_get,", # depends on memory pools
|
|
"/* 64 */ _k_mem_pool_block_get_timeout_handle,", # depends on memory pools
|
|
# and timers
|
|
"/* 65 */ _k_defrag,", # depends on memory pools
|
|
"/* 66 */ (kernelfunc) NULL,", # unused
|
|
"/* 67 */ (kernelfunc) NULL,", # unused
|
|
"/* 68 */ (kernelfunc) NULL,", # unused
|
|
"/* 69 */ (kernelfunc) NULL,", # unused
|
|
"/* 70 */ (kernelfunc) NULL,", # unused
|
|
"/* 71 */ (kernelfunc) NULL,", # unused
|
|
"/* 72 */ K_ChSendReq,", # depends on pipes
|
|
"/* 73 */ K_ChSendTmo,", # depends on pipes and timers
|
|
"/* 74 */ K_ChSendRpl,", # depends on pipes
|
|
"/* 75 */ K_ChSendAck,", # depends on pipes
|
|
"/* 76 */ K_ChRecvReq,", # depends on pipes
|
|
"/* 77 */ K_ChRecvTmo,", # depends on pipes and timers
|
|
"/* 78 */ K_ChRecvRpl,", # depends on pipes
|
|
"/* 79 */ K_ChRecvAck,", # depends on pipes
|
|
"/* 80 */ K_ChMovedAck,", # depends on pipes
|
|
"/* 81 */ _k_event_test_timeout" # depends on timers
|
|
]
|
|
|
|
# eliminate table entries for kernel services that project doesn't utilize
|
|
# (note: some entries can be eliminated for more than one reason)
|
|
|
|
if (len(sema_list) == 0):
|
|
func_table[6] = "/* 6 */ (kernelfunc) NULL,"
|
|
func_table[7] = "/* 7 */ (kernelfunc) NULL,"
|
|
func_table[8] = "/* 8 */ (kernelfunc) NULL,"
|
|
func_table[9] = "/* 9 */ (kernelfunc) NULL,"
|
|
func_table[10] = "/* 10 */ (kernelfunc) NULL,"
|
|
func_table[11] = "/* 11 */ (kernelfunc) NULL,"
|
|
func_table[12] = "/* 12 */ (kernelfunc) NULL,"
|
|
func_table[13] = "/* 13 */ (kernelfunc) NULL,"
|
|
func_table[14] = "/* 14 */ (kernelfunc) NULL,"
|
|
func_table[15] = "/* 15 */ (kernelfunc) NULL,"
|
|
func_table[16] = "/* 16 */ (kernelfunc) NULL,"
|
|
func_table[17] = "/* 17 */ (kernelfunc) NULL,"
|
|
func_table[18] = "/* 18 */ (kernelfunc) NULL,"
|
|
func_table[19] = "/* 19 */ (kernelfunc) NULL,"
|
|
func_table[20] = "/* 20 */ (kernelfunc) NULL,"
|
|
|
|
if (len(mutex_list) == 0):
|
|
func_table[21] = "/* 21 */ (kernelfunc) NULL,"
|
|
func_table[22] = "/* 22 */ (kernelfunc) NULL,"
|
|
func_table[23] = "/* 23 */ (kernelfunc) NULL,"
|
|
func_table[24] = "/* 24 */ (kernelfunc) NULL,"
|
|
|
|
if (len(fifo_list) == 0):
|
|
func_table[25] = "/* 25 */ (kernelfunc) NULL,"
|
|
func_table[26] = "/* 26 */ (kernelfunc) NULL,"
|
|
func_table[27] = "/* 27 */ (kernelfunc) NULL,"
|
|
func_table[28] = "/* 28 */ (kernelfunc) NULL,"
|
|
func_table[29] = "/* 29 */ (kernelfunc) NULL,"
|
|
func_table[30] = "/* 30 */ (kernelfunc) NULL,"
|
|
func_table[31] = "/* 31 */ (kernelfunc) NULL,"
|
|
|
|
if (len(mbx_list) == 0):
|
|
func_table[32] = "/* 32 */ (kernelfunc) NULL,"
|
|
func_table[33] = "/* 33 */ (kernelfunc) NULL,"
|
|
func_table[34] = "/* 34 */ (kernelfunc) NULL,"
|
|
func_table[35] = "/* 35 */ (kernelfunc) NULL,"
|
|
func_table[36] = "/* 36 */ (kernelfunc) NULL,"
|
|
func_table[37] = "/* 37 */ (kernelfunc) NULL,"
|
|
func_table[38] = "/* 38 */ (kernelfunc) NULL,"
|
|
func_table[39] = "/* 39 */ (kernelfunc) NULL,"
|
|
|
|
if (len(map_list) == 0):
|
|
func_table[47] = "/* 47 */ (kernelfunc) NULL,"
|
|
func_table[48] = "/* 48 */ (kernelfunc) NULL,"
|
|
func_table[53] = "/* 53 */ (kernelfunc) NULL,"
|
|
|
|
if (len(pool_list) == 0):
|
|
func_table[61] = "/* 61 */ (kernelfunc) NULL,"
|
|
func_table[62] = "/* 62 */ (kernelfunc) NULL,"
|
|
func_table[63] = "/* 63 */ (kernelfunc) NULL,"
|
|
func_table[64] = "/* 64 */ (kernelfunc) NULL,"
|
|
func_table[65] = "/* 65 */ (kernelfunc) NULL,"
|
|
|
|
if (len(pipe_list) == 0):
|
|
func_table[72] = "/* 72 */ (kernelfunc) NULL,"
|
|
func_table[73] = "/* 73 */ (kernelfunc) NULL,"
|
|
func_table[74] = "/* 74 */ (kernelfunc) NULL,"
|
|
func_table[75] = "/* 75 */ (kernelfunc) NULL,"
|
|
func_table[76] = "/* 76 */ (kernelfunc) NULL,"
|
|
func_table[77] = "/* 77 */ (kernelfunc) NULL,"
|
|
func_table[78] = "/* 78 */ (kernelfunc) NULL,"
|
|
func_table[79] = "/* 79 */ (kernelfunc) NULL,"
|
|
func_table[80] = "/* 80 */ (kernelfunc) NULL,"
|
|
|
|
if (num_timers == 0):
|
|
func_table[12] = "/* 12 */ (kernelfunc) NULL,"
|
|
func_table[23] = "/* 23 */ (kernelfunc) NULL,"
|
|
func_table[27] = "/* 27 */ (kernelfunc) NULL,"
|
|
func_table[30] = "/* 30 */ (kernelfunc) NULL,"
|
|
func_table[33] = "/* 33 */ (kernelfunc) NULL,"
|
|
func_table[37] = "/* 37 */ (kernelfunc) NULL,"
|
|
func_table[40] = "/* 40 */ (kernelfunc) NULL,"
|
|
func_table[41] = "/* 41 */ (kernelfunc) NULL,"
|
|
func_table[42] = "/* 42 */ (kernelfunc) NULL,"
|
|
func_table[49] = "/* 49 */ (kernelfunc) NULL,"
|
|
func_table[50] = "/* 50 */ (kernelfunc) NULL,"
|
|
func_table[51] = "/* 51 */ (kernelfunc) NULL,"
|
|
func_table[52] = "/* 52 */ (kernelfunc) NULL,"
|
|
func_table[53] = "/* 53 */ (kernelfunc) NULL,"
|
|
func_table[64] = "/* 64 */ (kernelfunc) NULL,"
|
|
func_table[73] = "/* 73 */ (kernelfunc) NULL,"
|
|
func_table[77] = "/* 77 */ (kernelfunc) NULL,"
|
|
func_table[81] = "/* 81 */ (kernelfunc) NULL,"
|
|
|
|
# generate function table
|
|
|
|
kernel_main_c_out("\n" +
|
|
"const kernelfunc _k_server_dispatch_table[82] =\n" +
|
|
"{\n")
|
|
for func in func_table:
|
|
kernel_main_c_out(" " + func + "\n")
|
|
kernel_main_c_out("};\n")
|
|
|
|
|
|
def kernel_main_c_driver_init():
|
|
""" Generate driver initialization routine """
|
|
|
|
kernel_main_c_out("\n" +
|
|
"void _k_init_drivers(void)\n" +
|
|
"{\n")
|
|
for driver_call in driver_list:
|
|
kernel_main_c_out(" " + driver_call + ";\n")
|
|
kernel_main_c_out("}\n")
|
|
|
|
|
|
def kernel_main_c_node_init():
|
|
""" Generate node initialization routine """
|
|
|
|
kernel_main_c_out("\n" +
|
|
"void _k_init_node(void)\n{\n")
|
|
if (len(pipe_list) > 0):
|
|
kernel_main_c_out(" _k_pipe_init();\n")
|
|
if (len(map_list) > 0):
|
|
kernel_main_c_out(" _k_mem_map_init();\n")
|
|
if (len(pool_list) > 0):
|
|
kernel_main_c_out(" _k_mem_pool_init();\n")
|
|
kernel_main_c_out("}\n")
|
|
|
|
|
|
def kernel_main_c_main():
|
|
""" Generate main() routine """
|
|
|
|
kernel_main_c_out("\n" +
|
|
"void main(void)\n" +
|
|
"{\n" +
|
|
" _k_kernel_init();\n" +
|
|
" task_group_start(EXE);\n" +
|
|
" _k_kernel_idle();\n" +
|
|
"}\n")
|
|
|
|
|
|
def kernel_main_c_generate():
|
|
""" Generate kernel_main.c file """
|
|
|
|
global kernel_main_c_data
|
|
|
|
kernel_main_c_header()
|
|
kernel_main_c_kargs()
|
|
kernel_main_c_timers()
|
|
kernel_main_c_tasks()
|
|
kernel_main_c_priorities()
|
|
kernel_main_c_events()
|
|
kernel_main_c_mutexes()
|
|
kernel_main_c_semas()
|
|
kernel_main_c_fifos()
|
|
kernel_main_c_pipes()
|
|
kernel_main_c_mailboxes()
|
|
kernel_main_c_maps()
|
|
kernel_main_c_pools()
|
|
kernel_main_c_kernel_services()
|
|
kernel_main_c_driver_init()
|
|
kernel_main_c_node_init()
|
|
kernel_main_c_main()
|
|
|
|
write_file(output_dir + 'kernel_main.c', kernel_main_c_data)
|
|
|
|
|
|
#
|
|
# GENERATE kernel_main.h FILE
|
|
#
|
|
|
|
|
|
def kernel_main_h_generate():
|
|
""" Generate kernel_main.h file """
|
|
|
|
global output_dir
|
|
|
|
subprocess.check_call([
|
|
"cp",
|
|
"-f",
|
|
os.environ["ZEPHYR_BASE"] +
|
|
"/kernel/microkernel/include/kernel_main.h",
|
|
output_dir])
|
|
|
|
|
|
#
|
|
# GENERATE kernel_struct.h FILE
|
|
#
|
|
|
|
|
|
def kernel_struct_h_generate():
|
|
""" Generate kernel_struct.h file """
|
|
|
|
global output_dir
|
|
|
|
subprocess.check_call([
|
|
"cp",
|
|
"-f",
|
|
os.environ["ZEPHYR_BASE"] +
|
|
"/kernel/microkernel/include/kernel_struct.h",
|
|
output_dir])
|
|
|
|
|
|
#
|
|
# GENERATE zephyr.h FILE
|
|
#
|
|
|
|
|
|
zephyr_h_data = ""
|
|
|
|
zephyr_h_filename_str = \
|
|
"/* zephyr.h - microkernel master header file */\n\n"
|
|
|
|
zephyr_h_include_guard = "_ZEPHYR__H_"
|
|
|
|
zephyr_h_header_include_guard_str = \
|
|
"#ifndef " + zephyr_h_include_guard + "\n" \
|
|
"#define " + zephyr_h_include_guard + "\n\n"
|
|
|
|
|
|
def generate_zephyr_h_header():
|
|
|
|
global zephyr_h_data
|
|
zephyr_h_data += \
|
|
zephyr_h_filename_str + \
|
|
copyright + \
|
|
do_not_edit_warning + \
|
|
zephyr_h_header_include_guard_str + \
|
|
"#include <microkernel.h>\n" + \
|
|
"\n"
|
|
|
|
|
|
def generate_taskgroup_line(taskgroup, group_id):
|
|
|
|
global zephyr_h_data
|
|
zephyr_h_data += \
|
|
"#define " + taskgroup + " 0x%8.8x\n" % group_id
|
|
|
|
|
|
def generate_zephyr_h_taskgroups():
|
|
|
|
global zephyr_h_data
|
|
|
|
for group in group_key_list:
|
|
generate_taskgroup_line(group, group_dictionary[group])
|
|
|
|
zephyr_h_data += "\n"
|
|
|
|
|
|
def generate_obj_id_line(name, obj_id):
|
|
|
|
return "#define " + name + " 0x0001%4.4x\n" % obj_id
|
|
|
|
|
|
def generate_obj_id_lines(obj_types):
|
|
|
|
data = ""
|
|
for obj_type in obj_types:
|
|
for obj in obj_type[0]:
|
|
data += generate_obj_id_line(str(obj[0]), obj_type[1])
|
|
obj_type[1] += 1
|
|
if obj_type[1] > 0:
|
|
data += "\n"
|
|
|
|
return data
|
|
|
|
|
|
def generate_zephyr_h_obj_ids():
|
|
|
|
global zephyr_h_data
|
|
|
|
base_event = 4 # no need to generate ids for the 4 pre-defined events
|
|
event_id = base_event
|
|
for event in event_list:
|
|
zephyr_h_data += "#define %s %u\n" % (str(event[0]), event_id)
|
|
event_id += 1
|
|
if event_id > base_event:
|
|
zephyr_h_data += "\n"
|
|
|
|
obj_types = [
|
|
[task_list, 0],
|
|
[mutex_list, 0],
|
|
[sema_list, 0],
|
|
[fifo_list, 0],
|
|
[pipe_list, 0],
|
|
[mbx_list, 0],
|
|
[map_list, 0],
|
|
[pool_list, 0],
|
|
]
|
|
zephyr_h_data += generate_obj_id_lines(obj_types)
|
|
|
|
|
|
zephyr_h_footer_include_guard_str = \
|
|
"\n#endif /* " + zephyr_h_include_guard + " */\n"
|
|
|
|
|
|
def generate_zephyr_h_footer():
|
|
|
|
global zephyr_h_data
|
|
zephyr_h_data += \
|
|
zephyr_h_footer_include_guard_str
|
|
|
|
|
|
def zephyr_h_generate():
|
|
""" Generate zephyr.h file """
|
|
|
|
generate_zephyr_h_header()
|
|
generate_zephyr_h_taskgroups()
|
|
generate_zephyr_h_obj_ids()
|
|
generate_zephyr_h_footer()
|
|
|
|
write_file(output_dir + 'zephyr.h', zephyr_h_data)
|
|
|
|
|
|
#
|
|
# SYSTEM GENERATOR MAINLINE
|
|
#
|
|
|
|
|
|
mdef_parse()
|
|
get_output_dir()
|
|
kernel_main_c_generate()
|
|
kernel_main_h_generate()
|
|
kernel_struct_h_generate()
|
|
zephyr_h_generate()
|