| #! /usr/bin/env python |
| # |
| # sysgen - System Generator |
| # |
| # |
| # Copyright (c) 2015, Wind River Systems, Inc. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| # Arguments: |
| # - name of MDEF file |
| # - name of directory for output files (optional) |
| |
| # Generates: |
| # - kernel_main.c file |
| # - kernel_main.h file (local copy) |
| # - micro_private_types.h file (local copy) |
| # - sysgen.h file |
| |
| import os |
| import sys |
| import subprocess |
| |
| # global variables describing system |
| |
| MIN_HEAP = 64 |
| heap_pos_in_pool_list = -1 |
| num_kargs = 0 |
| num_timers = 0 |
| num_prios = 0 |
| num_task_irqs = 0 |
| |
| task_list = [] |
| event_list = [] |
| mutex_list = [] |
| sema_list = [] |
| fifo_list = [] |
| pipe_list = [] |
| mbx_list = [] |
| map_list = [] |
| pool_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" + \ |
| " * Licensed under the Apache License, Version 2.0 (the \"License\");\n" + \ |
| " * you may not use this file except in compliance with the License.\n" + \ |
| " * You may obtain a copy of the License at\n" + \ |
| " *\n" + \ |
| " * http://www.apache.org/licenses/LICENSE-2.0\n" + \ |
| " *\n" + \ |
| " * Unless required by applicable law or agreed to in writing, software\n" + \ |
| " * distributed under the License is distributed on an \"AS IS\" BASIS,\n" + \ |
| " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" + \ |
| " * See the License for the specific language governing permissions and\n" + \ |
| " * limitations under the License.\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 |
| global MIN_HEAP |
| global heap_pos_in_pool_list |
| |
| # 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] == "HEAP_SIZE"): |
| if (len(words) != 2): |
| error_arg_count(line) |
| heap_size = int(words[1]) |
| heap_pos_in_pool_list = len(pool_list) |
| pool_list.append(("_HEAP_MEM_POOL", MIN_HEAP, heap_size, 1)) |
| 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 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 <sysgen.h>\n" + |
| "#include <misc/debug/object_tracing_common.h>\n" + |
| "#include <micro_private_types.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_SVC_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_SVC_UNDEFINED},\n") |
| kernel_main_c_out( |
| " {&_k_server_command_packets[%d], " % (num_kargs - 2) + |
| "NULL, 0, 0, _K_SVC_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 |
| |
| # 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_C void %s(void);\n" % task[2]) |
| |
| # task descriptors (including one for idle task) |
| # |
| # compiler puts these objects into the section as if |
| # it is a stack. hence the need to reverse the list. |
| # this is to preseve the order defined in MDEF file. |
| |
| kernel_main_c_out("\n") |
| for task in reversed(task_list): |
| name = task[0] |
| prio = task[1] |
| entry = task[2] |
| size = task[3] |
| obj_name = "_k_task_obj_%s" % (name) |
| |
| 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( |
| "struct k_task %s " % (obj_name)+ |
| "__in_section(_k_task_list, public, task) =\n" + |
| " {NULL, NULL, %d, (ktask_t)&%s,\n" % (prio, obj_name) + |
| " 0x00000001, %#010x,\n" % (group_bitmask) + |
| " %s, %s, %d,\n" % (entry, stack, size) + |
| " (taskabortfunction)NULL, NULL};\n" + |
| "ktask_t _k_task_ptr_%s " % (name) + |
| " __in_section(_k_task_ptr, public, task) = " + |
| " (ktask_t)&%s;\n" % (obj_name)) |
| |
| kernel_main_c_out( |
| "struct k_task _k_task_idle " + |
| "__in_section(_k_task_list, idle, task) =\n" + |
| " {NULL, NULL, %d, 0x00000000,\n" % (num_prios - 1) + |
| " 0x00000000, 0x00000000,\n" + |
| " (taskstartfunction)NULL, main_task_stack,\n" |
| " CONFIG_MAIN_STACK_SIZE,\n" + |
| " (taskabortfunction)NULL, NULL};\n" + |
| "ktask_t _k_task_ptr_idle " + |
| " __in_section(_k_task_ptr, idle, task) = " + |
| " (ktask_t)&_k_task_idle;\n") |
| |
| # currently scheduled task (idle task) |
| |
| kernel_main_c_out("\n" + |
| "struct k_task * _k_current_task = &_k_task_idle;\n") |
| |
| |
| 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_task *)&_k_task_priority_list[%d]},\n" % |
| (i - 1)) |
| kernel_main_c_out( |
| " {&_k_task_idle, &_k_task_idle}\n" + |
| "};\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 """ |
| |
| global num_task_irqs |
| |
| # event descriptors |
| |
| # pre-defined event for timer |
| if (num_timers > 0): |
| kernel_main_c_out("DEFINE_EVENT(TICK_EVENT, _k_ticker);\n") |
| else: |
| kernel_main_c_out("DEFINE_EVENT(TICK_EVENT, NULL);\n") |
| |
| # project-specific events |
| for event in event_list: |
| |
| # if there is a handler function, it needs to be declared |
| # before setting up the object via DEFINE_EVENT() |
| # |
| # in other words, no declaration if handler is NULL or 0 |
| handler = event[1].strip().lower() |
| if handler != "null" and handler != "0": |
| kernel_main_c_out("extern int %s(int event);\n" % (event[1])) |
| |
| kernel_main_c_out("DEFINE_EVENT(%s, %s);\n" % (event[0], event[1])) |
| |
| if (event[0].startswith("_TaskIrqEvt")): |
| num_task_irqs += 1 |
| |
| if (num_task_irqs > 0): |
| kernel_main_c_out("const kevent_t _TaskIrqEvt_objIds[] = {\n") |
| |
| for i in range(0, num_task_irqs): |
| kernel_main_c_out( |
| " (kevent_t)&_k_event_obj__TaskIrqEvt%d,\n" % (i) |
| ) |
| |
| kernel_main_c_out("};\n") |
| |
| |
| def kernel_main_c_mutexes(): |
| """ Generate mutex variables """ |
| |
| total_mutexes = len(mutex_list) |
| |
| if (total_mutexes == 0): |
| return |
| |
| # mutex descriptors |
| |
| kernel_main_c_out("\n") |
| for mutex in mutex_list: |
| name = mutex[0] |
| kernel_main_c_out("struct _k_mutex_struct _k_mutex_obj_%s = " % (name) + |
| "__MUTEX_DEFAULT;\n") |
| |
| |
| def kernel_main_c_semas(): |
| """ Generate semaphore variables """ |
| |
| total_semas = len(sema_list) |
| |
| if (total_semas == 0): |
| return |
| |
| # semaphore descriptors |
| |
| kernel_main_c_out("\n") |
| for semaphore in sema_list: |
| name = semaphore[0] |
| kernel_main_c_out("struct _k_sem_struct _k_sem_obj_%s = " % (name) + |
| "__K_SEMAPHORE_DEFAULT;\n") |
| |
| |
| def kernel_main_c_fifos(): |
| """ Generate FIFO variables """ |
| |
| total_fifos = len(fifo_list) |
| |
| if (total_fifos == 0): |
| 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") |
| for fifo in fifo_list: |
| name = fifo[0] |
| depth = fifo[1] |
| width = fifo[2] |
| buffer = "__" + fifo[0] + "_buffer" |
| kernel_main_c_out("struct _k_fifo_struct _k_fifo_obj_%s = " % (name) + |
| "__K_FIFO_DEFAULT(%d, %d, %s);\n" % (depth, width, buffer)) |
| kernel_main_c_out("\n") |
| |
| |
| def kernel_main_c_pipes(): |
| """ Generate pipe variables """ |
| |
| total_pipes = len(pipe_list) |
| |
| if (total_pipes == 0): |
| 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 |
| |
| for pipe in pipe_list: |
| name = pipe[0] |
| size = pipe[1] |
| buffer = "__" + pipe[0] + "_buffer" |
| kernel_main_c_out("struct _k_pipe_struct _k_pipe_obj_%s = " % (name) + |
| " __K_PIPE_INITIALIZER(%d, %s);\n" % (size, buffer) + |
| "kpipe_t _k_pipe_ptr_%s " % (name) + |
| " __in_section(_k_pipe_ptr, public, pipe) =\n" + |
| " (kpipe_t)&_k_pipe_obj_%s;\n" % (name)) |
| |
| |
| def kernel_main_c_mailboxes(): |
| """ Generate mailbox variables """ |
| |
| total_mbxs = len(mbx_list) |
| |
| if (total_mbxs == 0): |
| return |
| |
| # mailbox descriptors |
| |
| kernel_main_c_out("\n") |
| for mbx in mbx_list: |
| name = mbx[0] |
| kernel_main_c_out("struct _k_mbox_struct _k_mbox_obj_%s = " % (name) + |
| "__K_MAILBOX_DEFAULT;\n") |
| kernel_main_c_out("\n") |
| |
| |
| def kernel_main_c_maps(): |
| """ Generate memory map variables """ |
| |
| total_maps = len(map_list) |
| |
| if (total_maps == 0): |
| 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 |
| |
| for map in map_list: |
| name = map[0] |
| blocks = map[1] |
| block_size = map[2] |
| kernel_main_c_out( |
| "struct _k_mem_map_struct _k_mem_map_obj_%s = " % (name) + |
| " __K_MEM_MAP_INITIALIZER(%d, %d, __MAP_%s_buffer);\n" % |
| (blocks, block_size, map[0]) + |
| "kmemory_map_t _k_mem_map_ptr_%s " % (name) + |
| " __in_section(_k_mem_map_ptr, public, mem_map) =\n" + |
| " (kmemory_map_t)&_k_mem_map_obj_%s;\n" % (name)) |
| |
| |
| def kernel_main_c_pools(): |
| """ Generate memory pool variables """ |
| global heap_pos_in_pool_list |
| |
| 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 |
| # Heap pool if present can be indexed using the below variable |
| if (heap_pos_in_pool_list != -1): |
| kernel_main_c_out("\nconst kmemory_pool_t _heap_mem_pool_id = %d;\n" \ |
| %(heap_pos_in_pool_list)) |
| |
| # 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 = "block_sets_%#010x" % ident |
| |
| # determine block sizes used by pool (including actual minimum size) |
| |
| block_size_list = [max_block_size] |
| while (ident != 0): # loop forever |
| min_block_size_actual = block_size_list[len(block_size_list) - 1] |
| min_block_size_proposed = min_block_size_actual / 4 |
| if (min_block_size_proposed < min_block_size): |
| break |
| block_size_list.append(min_block_size_proposed) |
| frag_levels = len(block_size_list) |
| |
| # determine size of quad-block arrays, |
| # from the largest block size to the smallest block size |
| # - each array must be big enough to track the status of |
| # the entire memory pool buffer |
| # - each array entry tracks the status of 4 consecutive blocks |
| # - need to do rounding up with array for largest block size |
| # in case the # of largest size blocks isn't a multiple of 4 |
| # (i.e. it's final array entry may be partly unused) |
| |
| quad_block_sizes = [(num_maximal_blocks + 3) / 4] |
| quad_block_size_to_use = num_maximal_blocks |
| for index in range(1, frag_levels): |
| quad_block_sizes.append(quad_block_size_to_use) |
| quad_block_size_to_use *= 4 |
| |
| # generate array of quad-blocks for each block set |
| |
| for index in range(0, frag_levels): |
| kernel_main_c_out( |
| "struct pool_quad_block quad_blocks_%#010x_%d[%d];\n" % |
| (ident, index, quad_block_sizes[index])) |
| |
| # generate array of block sets for memory pool |
| |
| kernel_main_c_out("\nstruct pool_block_set %s[%d] =\n{\n" % |
| (frag_table, frag_levels)) |
| for index in range(0, frag_levels): |
| kernel_main_c_out(" { %d, %d, quad_blocks_%#010x_%d},\n" % |
| (block_size_list[index], quad_block_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, %d, %d, NULL, %s, %s},\n" % \ |
| (max_block_size, min_block_size_actual, |
| 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_node_init(): |
| """ Generate node initialization routine """ |
| |
| kernel_main_c_out("\n" + |
| "void _k_init_dynamic(void)\n{\n") |
| kernel_main_c_out(" _k_pipe_init();\n") |
| 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("#ifdef CONFIG_DEBUG_TRACING_KERNEL_OBJECTS\n") |
| # mutex object ids |
| for mutex in mutex_list: |
| name = mutex[0] |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mutex, " + |
| "&_k_mutex_obj_%s);\n" % (name)) |
| # semaphore object ids |
| for semaphore in sema_list: |
| name = semaphore[0] |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_sem, " + |
| "&_k_sem_obj_%s);\n" % (name)) |
| # fifo object ids |
| for fifo in fifo_list: |
| name = fifo[0] |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_fifo, " + |
| "&_k_fifo_obj_%s);\n" % (name)) |
| # mailbox object ids |
| for mbx in mbx_list: |
| name = mbx[0] |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mbox, " + |
| "&_k_mbox_obj_%s);\n" % (name)) |
| # pipe object id |
| for pipe in pipe_list: |
| name = pipe[0]; |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_pipe, " + |
| "&_k_pipe_obj_%s);\n" % (name)) |
| # memory map object id |
| for map in map_list: |
| name = map[0]; |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mem_map, " + |
| "&_k_mem_map_obj_%s);\n" % (name)) |
| # memory pool object id |
| pool_count = 0; |
| total_pools = len(pool_list); |
| while (pool_count < total_pools): |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_mem_pool, " + |
| "&(_k_mem_pool_list[%d]));\n" % (pool_count)) |
| pool_count = pool_count + 1; |
| |
| # event map object id |
| for event in event_list: |
| # no need to expose the irq task events |
| if not (event[0].startswith("_TaskIrqEvt")): |
| name = event[0]; |
| kernel_main_c_out("\tSYS_TRACING_OBJ_INIT(micro_event, " + |
| "&_k_event_obj_%s);\n" % (name)) |
| |
| kernel_main_c_out("#endif\n") |
| |
| kernel_main_c_out("}\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_node_init() |
| |
| 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 micro_private_types.h FILE |
| # |
| |
| |
| def micro_private_types_h_generate(): |
| """ Generate micro_private_types.h file """ |
| |
| global output_dir |
| |
| subprocess.check_call([ |
| "cp", |
| "-f", |
| os.environ["ZEPHYR_BASE"] + |
| "/kernel/microkernel/include/micro_private_types.h", |
| output_dir]) |
| |
| |
| # |
| # GENERATE sysgen.h FILE |
| # |
| |
| |
| sysgen_h_data = "" |
| |
| sysgen_h_filename_str = \ |
| "/* sysgen.h - system generated microkernel definitions */\n\n" |
| |
| sysgen_h_include_guard = "_SYSGEN__H_" |
| |
| sysgen_h_header_include_guard_str = \ |
| "#ifndef " + sysgen_h_include_guard + "\n" \ |
| "#define " + sysgen_h_include_guard + "\n\n" |
| |
| |
| def generate_sysgen_h_header(): |
| |
| global sysgen_h_data |
| sysgen_h_data += \ |
| sysgen_h_filename_str + \ |
| copyright + \ |
| do_not_edit_warning + \ |
| "#include <microkernel.h>\n" + \ |
| sysgen_h_header_include_guard_str + \ |
| "\n" |
| |
| |
| def generate_taskgroup_line(taskgroup, group_id): |
| |
| global sysgen_h_data |
| sysgen_h_data += \ |
| "#define " + taskgroup + " 0x%8.8x\n" % group_id |
| |
| |
| def generate_sysgen_h_taskgroups(): |
| |
| global sysgen_h_data |
| |
| for group in group_key_list: |
| generate_taskgroup_line(group, group_dictionary[group]) |
| |
| sysgen_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_sysgen_h_obj_ids(): |
| |
| global sysgen_h_data |
| global num_task_irqs |
| |
| # mutex object ids |
| |
| sysgen_h_data += "\n" |
| for mutex in mutex_list: |
| name = mutex[0] |
| sysgen_h_data += \ |
| "extern struct _k_mutex_struct _k_mutex_obj_%s;\n" % (name) |
| sysgen_h_data += \ |
| "#define %s ((kmutex_t)&_k_mutex_obj_%s)\n\n" % (name, name) |
| |
| # semaphore object ids |
| |
| sysgen_h_data += "\n" |
| for semaphore in sema_list: |
| name = semaphore[0] |
| sysgen_h_data += \ |
| "extern struct _k_sem_struct _k_sem_obj_%s;\n" % (name) |
| sysgen_h_data += \ |
| "#define %s ((ksem_t)&_k_sem_obj_%s)\n\n" % (name, name) |
| |
| # fifo object ids |
| |
| sysgen_h_data += "\n" |
| for fifo in fifo_list: |
| name = fifo[0] |
| sysgen_h_data += \ |
| "extern struct _k_fifo_struct _k_fifo_obj_%s;\n" % (name) |
| sysgen_h_data += \ |
| "#define %s ((kfifo_t)&_k_fifo_obj_%s)\n\n" % (name, name) |
| |
| # mailbox object ids |
| |
| sysgen_h_data += "\n" |
| for mbx in mbx_list: |
| name = mbx[0] |
| sysgen_h_data += \ |
| "extern struct _k_mbox_struct _k_mbox_obj_%s;\n" % (name) |
| sysgen_h_data += \ |
| "#define %s ((kmbox_t)&_k_mbox_obj_%s)\n\n" % (name, name) |
| |
| # pipe object id |
| |
| sysgen_h_data += "\n" |
| for pipe in pipe_list: |
| name = pipe[0]; |
| sysgen_h_data += \ |
| "extern struct _k_pipe_struct _k_pipe_obj_%s;\n" % (name) + \ |
| "#define %s ((kpipe_t)&_k_pipe_obj_%s)\n\n" % (name, name) |
| |
| # memory map object id |
| |
| sysgen_h_data += "\n" |
| for map in map_list: |
| name = map[0]; |
| sysgen_h_data += \ |
| "extern struct _k_mem_map_struct _k_mem_map_obj_%s;\n" % (name) + \ |
| "#define %s ((kmemory_map_t)&_k_mem_map_obj_%s)\n" % (name, name) |
| |
| # task object id |
| |
| sysgen_h_data += "\n" |
| for task in task_list: |
| name = task[0]; |
| sysgen_h_data += \ |
| "extern struct k_task _k_task_obj_%s;\n" % (name) + \ |
| "#define %s ((ktask_t)&_k_task_obj_%s)\n" % (name, name) |
| |
| # event object id |
| |
| sysgen_h_data += "\n" |
| for event in event_list: |
| # no need to expose the irq task events |
| if not (event[0].startswith("_TaskIrqEvt")): |
| name = event[0]; |
| sysgen_h_data += \ |
| "extern const kevent_t %s;\n" % (name) |
| |
| # all other object ids |
| |
| obj_types = [ |
| [pool_list, 0], |
| ] |
| sysgen_h_data += generate_obj_id_lines(obj_types) |
| |
| |
| sysgen_h_footer_include_guard_str = \ |
| "\n#endif /* " + sysgen_h_include_guard + " */\n" |
| |
| |
| def generate_sysgen_h_footer(): |
| |
| global sysgen_h_data |
| sysgen_h_data += \ |
| sysgen_h_footer_include_guard_str |
| |
| |
| def sysgen_h_generate(): |
| """ Generate sysgen.h file """ |
| |
| generate_sysgen_h_header() |
| generate_sysgen_h_taskgroups() |
| generate_sysgen_h_obj_ids() |
| generate_sysgen_h_footer() |
| |
| write_file(output_dir + 'sysgen.h', sysgen_h_data) |
| |
| |
| # |
| # SYSTEM GENERATOR MAINLINE |
| # |
| |
| |
| mdef_parse() |
| get_output_dir() |
| kernel_main_c_generate() |
| kernel_main_h_generate() |
| micro_private_types_h_generate() |
| sysgen_h_generate() |
