b4484a7816
The nanokernel LIFOs could only have one fiber pending on one of them concurrently. If a second fiber wanted to take a contested LIFO, if would kick the pending fiber out of the wait 'container', but would not put it in back in the ready queue with an error. Instead, it would, for all intents and purposes, remove it from the scheduling mechanism of the nanokernel: the fiber would be 'lost' at that point. The nanokernel LIFOs now make use of the fiber pend queue, and thus allow multiple fibers to pend concurrently. sysgen is updated since the microkernel initializes statically two LIFOs, one for the command packets and one for the timer packets, and the LIFO data structure has changed. The nano_timers use the LIFOs and look at their internals, so they are updated as well. Change-Id: I250a610fcdee9d32172c88d38e6c3cfd5b437d15 Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>
1246 lines
40 KiB
Python
Executable File
1246 lines
40 KiB
Python
Executable File
#! /usr/bin/env python
|
|
#
|
|
# sysgen.py - 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 VPF file
|
|
# - name of directory for output files (optional)
|
|
|
|
# Generates:
|
|
# - kernel_main.c file
|
|
# - microkernel_objects.h file
|
|
# - vxmicro.h file
|
|
|
|
import os
|
|
import sys
|
|
|
|
# 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 vpf_parse():
|
|
""" Parse VPF 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 <microkernel.h>\n" +
|
|
"#include <toolchain.h>\n" +
|
|
"#include <sections.h>\n" +
|
|
"#include <vxmicro.h>\n")
|
|
|
|
|
|
def kernel_main_c_kargs():
|
|
""" Generate command packet variables """
|
|
|
|
# command packets
|
|
|
|
kernel_main_c_out("\n" +
|
|
"struct k_args K_ArgsBlocks[%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_ArgsBlocks[%d], NULL, 0, 0, (K_COMM) UNDEFINED},\n" %
|
|
(i - 1))
|
|
kernel_main_c_out(
|
|
" {&K_ArgsBlocks[%d], NULL, 0, 0, (K_COMM) UNDEFINED}\n" %
|
|
(num_kargs - 2) +
|
|
"};\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_ArgsBlocks[%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" +
|
|
"K_TIMER K_TimerBlocks[%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_TimerBlocks[%d], NULL, 0, 0, " % (i - 1) +
|
|
"(struct k_args *)0xffffffff},\n")
|
|
kernel_main_c_out(
|
|
" {&K_TimerBlocks[%d], NULL, 0, 0, (struct k_args *)0xffffffff}\n" %
|
|
(num_timers - 2) +
|
|
"};\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_TimerBlocks[%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 __%s_stack[%d];\n" %
|
|
(task[0], task[3]))
|
|
|
|
# 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, NULL, 0, (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 EVENTS[%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")
|
|
|
|
# pipe variables [should probably be eliminated]
|
|
|
|
kernel_main_c_out("\n" +
|
|
"PFN_CHANNEL_RWT pKS_Channel_PutWT = _task_pipe_put;\n" +
|
|
"PFN_CHANNEL_RWT pKS_Channel_GetWT = _task_pipe_get;\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 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 init_node(void)\n{\n")
|
|
if (len(pipe_list) > 0):
|
|
kernel_main_c_out(" _pipe_init();\n")
|
|
if (len(map_list) > 0):
|
|
kernel_main_c_out(" _mem_map_init();\n")
|
|
if (len(pool_list) > 0):
|
|
kernel_main_c_out(" _mem_pools_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" +
|
|
" kernel_init();\n" +
|
|
" task_group_start(EXE);\n" +
|
|
" 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 microkernel_objects.h FILE
|
|
#
|
|
|
|
|
|
micro_objs_h_data = ""
|
|
|
|
micro_objs_h_filename_str = \
|
|
"/* microkernel_objects.h - microkernel objects */\n\n"
|
|
|
|
micro_objs_h_include_guard = "_MICROKERNEL_OBJECTS__H_"
|
|
|
|
micro_objs_h_header_include_guard_str = \
|
|
"#ifndef " + micro_objs_h_include_guard + "\n" \
|
|
"#define " + micro_objs_h_include_guard + "\n\n"
|
|
|
|
|
|
def generate_micro_objs_h_header():
|
|
|
|
global micro_objs_h_data
|
|
micro_objs_h_data += \
|
|
micro_objs_h_filename_str + \
|
|
copyright + \
|
|
do_not_edit_warning + \
|
|
micro_objs_h_header_include_guard_str
|
|
|
|
micro_objs_h_footer_include_guard_str = \
|
|
"\n#endif /* " + micro_objs_h_include_guard + " */\n"
|
|
|
|
|
|
def generate_micro_objs_h_footer():
|
|
|
|
global micro_objs_h_data
|
|
micro_objs_h_data += \
|
|
micro_objs_h_footer_include_guard_str
|
|
|
|
|
|
def generate_taskgroup_line(taskgroup, group_id):
|
|
|
|
global micro_objs_h_data
|
|
micro_objs_h_data += \
|
|
"#define " + taskgroup + " 0x%8.8x\n" % group_id
|
|
|
|
|
|
def generate_micro_objs_h_taskgroups():
|
|
|
|
for group in group_key_list:
|
|
generate_taskgroup_line(group, group_dictionary[group])
|
|
|
|
|
|
def generate_micro_objs_h_nodes():
|
|
|
|
global micro_objs_h_data
|
|
micro_objs_h_data += \
|
|
"\n#define NODE1 0x00010000\n\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_micro_objs_h_obj_ids():
|
|
|
|
global micro_objs_h_data
|
|
|
|
obj_types = [
|
|
[task_list, 0],
|
|
[mutex_list, 0],
|
|
[sema_list, 0],
|
|
[fifo_list, 0],
|
|
[pipe_list, 0],
|
|
[mbx_list, 0],
|
|
[pool_list, 0],
|
|
]
|
|
|
|
micro_objs_h_data += generate_obj_id_lines(obj_types)
|
|
|
|
|
|
def generate_micro_objs_h_misc():
|
|
|
|
global micro_objs_h_data
|
|
micro_objs_h_data += "\n" + \
|
|
"#define TICKFREQ 1000\n" + \
|
|
"#define DATALEN 32768\n" + \
|
|
"#define CEILING_PRIO 5\n" + \
|
|
"#define KERNEL_PRIO 0\n" + \
|
|
"#define DRIVER_PRIO 1\n" + \
|
|
"#define TICKTIME 1000\n"
|
|
|
|
|
|
def micro_objs_h_generate():
|
|
|
|
generate_micro_objs_h_header()
|
|
generate_micro_objs_h_taskgroups()
|
|
generate_micro_objs_h_nodes()
|
|
generate_micro_objs_h_obj_ids()
|
|
generate_micro_objs_h_misc() # XXX - remove when ready
|
|
generate_micro_objs_h_footer()
|
|
|
|
write_file(output_dir + 'microkernel_objects.h', micro_objs_h_data)
|
|
|
|
|
|
#
|
|
# GENERATE vxmicro.h FILE
|
|
#
|
|
|
|
|
|
vxmicro_h_data = ""
|
|
|
|
vxmicro_h_filename_str = \
|
|
"/* vxmicro.h - microkernel master header file */\n\n"
|
|
|
|
vxmicro_h_include_guard = "_VXMICRO__H_"
|
|
|
|
vxmicro_h_header_include_guard_str = \
|
|
"#ifndef " + vxmicro_h_include_guard + "\n" \
|
|
"#define " + vxmicro_h_include_guard + "\n\n"
|
|
|
|
|
|
def generate_vxmicro_h_header():
|
|
|
|
global vxmicro_h_data
|
|
vxmicro_h_data += \
|
|
vxmicro_h_filename_str + \
|
|
copyright + \
|
|
do_not_edit_warning + \
|
|
vxmicro_h_header_include_guard_str + \
|
|
"#include <microkernel.h>\n" + \
|
|
"#include <microkernel_objects.h>\n"
|
|
|
|
|
|
def generate_vxmicro_h_misc():
|
|
|
|
global vxmicro_h_data
|
|
vxmicro_h_data += "\n" + \
|
|
"extern const int _k_num_events;\n" + \
|
|
"extern struct evstr EVENTS[];\n\n"
|
|
|
|
|
|
def generate_vxmicro_h_obj_ids():
|
|
|
|
global vxmicro_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:
|
|
vxmicro_h_data += "#define %s %u\n" % (str(event[0]), event_id)
|
|
event_id += 1
|
|
if event_id > base_event:
|
|
vxmicro_h_data += "\n"
|
|
|
|
obj_types = [
|
|
[map_list, 0],
|
|
]
|
|
vxmicro_h_data += generate_obj_id_lines(obj_types)
|
|
|
|
|
|
vxmicro_h_footer_include_guard_str = \
|
|
"\n#endif /* " + vxmicro_h_include_guard + " */\n"
|
|
|
|
|
|
def generate_vxmicro_h_task_entry_points():
|
|
|
|
global vxmicro_h_data
|
|
for task in task_list:
|
|
vxmicro_h_data += "extern void %s(void);\n" % task[2]
|
|
|
|
|
|
def generate_vxmicro_h_footer():
|
|
|
|
global vxmicro_h_data
|
|
vxmicro_h_data += \
|
|
vxmicro_h_footer_include_guard_str
|
|
|
|
|
|
def vxmicro_h_generate():
|
|
""" Generate vxmicro.h file """
|
|
|
|
generate_vxmicro_h_header()
|
|
generate_vxmicro_h_misc()
|
|
generate_vxmicro_h_obj_ids()
|
|
generate_vxmicro_h_task_entry_points()
|
|
generate_vxmicro_h_footer()
|
|
|
|
write_file(output_dir + 'vxmicro.h', vxmicro_h_data)
|
|
|
|
|
|
#
|
|
# SYSTEM GENERATOR MAINLINE
|
|
#
|
|
|
|
|
|
vpf_parse()
|
|
get_output_dir()
|
|
kernel_main_c_generate()
|
|
vxmicro_h_generate()
|
|
micro_objs_h_generate()
|