[Cbe-oss-dev] [PATCH 10/10]MARS/modules: Task module implementation
Yuji Mano
yuji.mano at am.sony.com
Fri Nov 21 11:07:02 EST 2008
This adds the task module implementation.
Signed-off-by: Yuji Mano <yuji.mano at am.sony.com>
---
modules/task/src/mpu/module/task_module.c | 452 ++++++++++++++++++++++++++++++
modules/task/src/mpu/module/task_module.h | 83 +++++
2 files changed, 535 insertions(+)
--- /dev/null
+++ b/modules/task/src/mpu/module/task_module.c
@@ -0,0 +1,452 @@
+/*
+ * Copyright 2008 Sony Corporation of America
+ *
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this Library and associated documentation files (the
+ * "Library"), to deal in the Library without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Library, and to
+ * permit persons to whom the Library is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Library.
+ *
+ * If you modify the Library, you may copy and distribute your modified
+ * version of the Library in object code or as an executable provided
+ * that you also do one of the following:
+ *
+ * Accompany the modified version of the Library with the complete
+ * corresponding machine-readable source code for the modified version
+ * of the Library; or,
+ *
+ * Accompany the modified version of the Library with a written offer
+ * for a complete machine-readable copy of the corresponding source
+ * code of the modified version of the Library.
+ *
+ *
+ * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
+ */
+
+#include "task_module.h"
+
+/* stack pointer storage */
+void *_module_stack;
+void *_task_stack;
+
+/* global task structs */
+static struct mars_task_context *task;
+static struct mars_task_context_save_unit list[MARS_TASK_CONTEXT_SAVE_UNIT_MAX];
+
+/* task entry */
+typedef void (*mars_task_entry)(struct mars_task_args *args,
+ struct mars_task_module_syscalls *task_module_syscalls);
+
+static uint32_t get_kernel_id(void)
+{
+ return mars_module_get_kernel_id();
+}
+
+static struct mars_task_context *get_task(void)
+{
+ return (struct mars_task_context *)mars_module_get_workload();
+}
+
+static struct mars_task_context *get_task_by_id(struct mars_task_id *task_id)
+{
+ return (struct mars_task_context *)
+ mars_module_get_workload_by_id(task_id->workload_id);
+}
+
+static void __attribute__((noinline)) registers_save(void)
+{
+ /* push non-volatile registers on to the workload stack */
+ asm volatile (
+ "lqa $75, _task_stack;"
+
+ "stqd $80, -16($75);"
+ "stqd $81, -32($75);"
+ "stqd $82, -48($75);"
+ "stqd $83, -64($75);"
+ "stqd $84, -80($75);"
+ "stqd $85, -96($75);"
+ "stqd $86, -112($75);"
+ "stqd $87, -128($75);"
+ "stqd $88, -144($75);"
+ "stqd $89, -160($75);"
+ "stqd $90, -176($75);"
+ "stqd $91, -192($75);"
+ "stqd $92, -208($75);"
+ "stqd $93, -224($75);"
+ "stqd $94, -240($75);"
+ "stqd $95, -256($75);"
+ "stqd $96, -272($75);"
+ "stqd $97, -288($75);"
+ "stqd $98, -304($75);"
+ "stqd $99, -320($75);"
+ "stqd $100, -336($75);"
+ "stqd $101, -352($75);"
+ "stqd $102, -368($75);"
+ "stqd $103, -384($75);"
+ "stqd $104, -400($75);"
+ "stqd $105, -416($75);"
+ "stqd $106, -432($75);"
+ "stqd $107, -448($75);"
+ "stqd $108, -464($75);"
+ "stqd $109, -480($75);"
+ "stqd $110, -496($75);"
+ "stqd $111, -512($75);"
+ "stqd $112, -528($75);"
+ "stqd $113, -544($75);"
+ "stqd $114, -560($75);"
+ "stqd $115, -576($75);"
+ "stqd $116, -592($75);"
+ "stqd $117, -608($75);"
+ "stqd $118, -624($75);"
+ "stqd $119, -640($75);"
+ "stqd $120, -656($75);"
+ "stqd $121, -672($75);"
+ "stqd $122, -688($75);"
+ "stqd $123, -704($75);"
+ "stqd $124, -720($75);"
+ "stqd $125, -736($75);"
+ "stqd $126, -752($75);"
+ "stqd $127, -768($75);"
+ );
+}
+
+static void __attribute__((noinline)) registers_restore(void)
+{
+ /* pop non-volatile registers from saved workload stack */
+ asm volatile (
+ "lqa $75, _task_stack;"
+
+ "lqd $80, -16($75);"
+ "lqd $81, -32($75);"
+ "lqd $82, -48($75);"
+ "lqd $83, -64($75);"
+ "lqd $84, -80($75);"
+ "lqd $85, -96($75);"
+ "lqd $86, -112($75);"
+ "lqd $87, -128($75);"
+ "lqd $88, -144($75);"
+ "lqd $89, -160($75);"
+ "lqd $90, -176($75);"
+ "lqd $91, -192($75);"
+ "lqd $92, -208($75);"
+ "lqd $93, -224($75);"
+ "lqd $94, -240($75);"
+ "lqd $95, -256($75);"
+ "lqd $96, -272($75);"
+ "lqd $97, -288($75);"
+ "lqd $98, -304($75);"
+ "lqd $99, -320($75);"
+ "lqd $100, -336($75);"
+ "lqd $101, -352($75);"
+ "lqd $102, -368($75);"
+ "lqd $103, -384($75);"
+ "lqd $104, -400($75);"
+ "lqd $105, -416($75);"
+ "lqd $106, -432($75);"
+ "lqd $107, -448($75);"
+ "lqd $108, -464($75);"
+ "lqd $109, -480($75);"
+ "lqd $110, -496($75);"
+ "lqd $111, -512($75);"
+ "lqd $112, -528($75);"
+ "lqd $113, -544($75);"
+ "lqd $114, -560($75);"
+ "lqd $115, -576($75);"
+ "lqd $116, -592($75);"
+ "lqd $117, -608($75);"
+ "lqd $118, -624($75);"
+ "lqd $119, -640($75);"
+ "lqd $120, -656($75);"
+ "lqd $121, -672($75);"
+ "lqd $122, -688($75);"
+ "lqd $123, -704($75);"
+ "lqd $124, -720($75);"
+ "lqd $125, -736($75);"
+ "lqd $126, -752($75);"
+ "lqd $127, -768($75);"
+ );
+}
+
+static void __attribute__((noinline)) context_save(void)
+{
+ int i, offset = 0;
+
+ /* save registers state */
+ registers_save();
+
+ /* save workload stack pointer */
+ task->stack = (uint32_t)_task_stack;
+
+ /* get context save unit list */
+ mars_dma_get_and_wait(list, task->context_save_unit_ea,
+ MARS_TASK_CONTEXT_SAVE_UNIT_SIZE *
+ MARS_TASK_CONTEXT_SAVE_UNIT_MAX, MARS_DMA_TAG);
+
+ /* loop through save unit list */
+ for (i = 0; i < MARS_TASK_CONTEXT_SAVE_UNIT_MAX; i++) {
+ /* list terminator so exit loop */
+ if (!list[i].size)
+ break;
+
+ /* request dma put of the context save unit specified */
+ mars_dma_large_put((void *)(task->vaddr + list[i].addr),
+ task->context_save_area_ea + offset,
+ list[i].size, MARS_DMA_TAG);
+
+ offset += list[i].size;
+ }
+
+ /* wait for all dmas to complete */
+ mars_dma_wait(MARS_DMA_TAG);
+}
+
+static void __attribute__((noinline)) context_restore(void)
+{
+ int i, offset = 0;
+
+ /* get save context save unit list */
+ mars_dma_get_and_wait(list, task->context_save_unit_ea,
+ MARS_TASK_CONTEXT_SAVE_UNIT_SIZE *
+ MARS_TASK_CONTEXT_SAVE_UNIT_MAX, MARS_DMA_TAG);
+
+ /* loop through save unit list */
+ for (i = 0; i < MARS_TASK_CONTEXT_SAVE_UNIT_MAX; i++) {
+ /* list terminator so exit loop */
+ if (!list[i].size)
+ break;
+
+ /* request dma get of the context save unit specified */
+ mars_dma_large_get((void *)(task->vaddr + list[i].addr),
+ task->context_save_area_ea + offset,
+ list[i].size, MARS_DMA_TAG);
+
+ offset += list[i].size;
+ }
+
+ /* wait for all dmas to complete */
+ mars_dma_wait(MARS_DMA_TAG);
+
+ /* restore workload stack pointer */
+ _task_stack = (void *)task->stack;
+
+ /* restore registers state */
+ registers_restore();
+}
+
+static void __attribute__((noinline)) context_yield(void)
+{
+ /* save task stack pointer and restore module stack pointer */
+ asm volatile (
+ "stqa $sp, _task_stack;"
+ "lqa $sp, _module_stack;"
+ );
+
+ /* save task context */
+ context_save();
+
+ /* exit workload module */
+ mars_module_exit(MARS_WORKLOAD_STATE_READY);
+}
+
+static void __attribute__((noinline)) context_wait(void)
+{
+ /* save task stack pointer and restore module stack pointer */
+ asm volatile (
+ "stqa $sp, _task_stack;"
+ "lqa $sp, _module_stack;"
+ );
+
+ /* save task context */
+ context_save();
+
+ /* exit workload module */
+ mars_module_exit(MARS_WORKLOAD_STATE_WAITING);
+}
+
+static void __attribute__((noinline)) context_resume(void)
+{
+ /* restore task context */
+ context_restore();
+
+ /* restore task stack pointer */
+ asm volatile (
+ "lqa $sp, _task_stack;"
+ );
+}
+
+static void __attribute__((noinline)) context_exit(void)
+{
+ /* restore module stack pointer */
+ asm volatile (
+ "lqa $sp, _module_stack;"
+ );
+
+ /* exit workload module */
+ mars_module_exit(MARS_WORKLOAD_STATE_FINISHED);
+}
+
+static void task_exit(void)
+{
+ context_exit();
+}
+
+static void task_yield(void)
+{
+ context_yield();
+}
+
+static int task_schedule(uint16_t workload_id, struct mars_task_args *args,
+ uint8_t priority)
+{
+ int ret;
+ struct mars_task_context *schedule_task;
+ struct mars_workload_context *schedule_workload;
+
+ ret = mars_module_workload_schedule_begin(workload_id, priority,
+ &schedule_workload);
+ if (ret != MARS_SUCCESS)
+ return ret;
+
+ /* cast workload context to task context */
+ schedule_task = (struct mars_task_context *)schedule_workload;
+
+ /* initialize task specific context variables */
+ schedule_task->stack = 0;
+ if (args)
+ memcpy(&schedule_task->args, args,
+ sizeof(struct mars_task_args));
+
+ /* end process to schedule the workload in the workload queue */
+ ret = mars_module_workload_schedule_end(workload_id);
+ if (ret != MARS_SUCCESS)
+ return ret;
+
+ return MARS_SUCCESS;
+}
+
+static int task_wait(uint16_t workload_id)
+{
+ int ret;
+ uint64_t workload_bits;
+
+ /* get workload bits of workload to wait for */
+ workload_bits = mars_module_get_workload_bits_by_id(workload_id);
+
+ /* make sure workload is initialized */
+ if (MARS_BITS_GET(&workload_bits, STATE) ==
+ MARS_WORKLOAD_STATE_NONE)
+ return MARS_ERROR_STATE;
+
+ ret = mars_module_workload_wait(workload_id);
+ if (ret != MARS_SUCCESS)
+ return ret;
+
+ context_wait();
+
+ return MARS_SUCCESS;
+}
+
+static int task_try_wait(uint16_t workload_id)
+{
+ uint64_t workload_bits;
+
+ /* get workload bits of workload to wait for */
+ workload_bits = mars_module_get_workload_bits_by_id(workload_id);
+
+ /* make sure workload is initialized */
+ if (MARS_BITS_GET(&workload_bits, STATE) ==
+ MARS_WORKLOAD_STATE_NONE)
+ return MARS_ERROR_STATE;
+
+ /* if workload not finished return busy */
+ if (MARS_BITS_GET(&workload_bits, STATE) !=
+ MARS_WORKLOAD_STATE_FINISHED)
+ return MARS_ERROR_BUSY;
+
+ return MARS_SUCCESS;
+}
+
+static int task_signal_send(uint16_t workload_id)
+{
+ return mars_module_workload_signal_send(workload_id);
+}
+
+static int task_signal_wait(void)
+{
+ context_wait();
+
+ return MARS_SUCCESS;
+}
+
+static int task_signal_try_wait(void)
+{
+ uint64_t workload_bits;
+
+ /* get workload bits of caller workload */
+ workload_bits = mars_module_get_workload_bits();
+
+ /* if signal not yet received return busy */
+ if (MARS_BITS_GET(&workload_bits, SIGNAL) != MARS_WORKLOAD_SIGNAL_ON)
+ return MARS_ERROR_BUSY;
+
+ return MARS_SUCCESS;
+}
+
+static struct mars_task_module_syscalls task_module_syscalls =
+{
+ get_kernel_id,
+ get_task,
+ get_task_by_id,
+
+ task_exit,
+ task_yield,
+ task_schedule,
+ task_wait,
+ task_try_wait,
+ task_signal_send,
+ task_signal_wait,
+ task_signal_try_wait
+};
+
+void mars_module_main(void)
+{
+ /* get task context */
+ task = get_task();
+
+ /* save module stack pointer */
+ asm volatile (
+ "stqa $sp, _module_stack;"
+ );
+
+ /* if stack pointer is uninitialized run fresh, otherwise resume */
+ if (!task->stack) {
+ /* dma the exec code into mpu storage from host storage */
+ mars_dma_large_get_and_wait((void *)task->vaddr,
+ task->exec_ea, task->exec_size, MARS_DMA_TAG);
+
+ /* 0 the bss section */
+ memset((void *)task->vaddr + task->exec_size, 0,
+ task->bss_size);
+
+ /* call entry function */
+ ((mars_task_entry)task->entry)(
+ &task->args, &task_module_syscalls);
+ } else {
+ context_resume();
+ }
+
+ /* we probably should never reach here */
+ mars_module_exit(MARS_WORKLOAD_STATE_FINISHED);
+}
--- /dev/null
+++ b/modules/task/src/mpu/module/task_module.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2008 Sony Corporation of America
+ *
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this Library and associated documentation files (the
+ * "Library"), to deal in the Library without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Library, and to
+ * permit persons to whom the Library is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Library.
+ *
+ * If you modify the Library, you may copy and distribute your modified
+ * version of the Library in object code or as an executable provided
+ * that you also do one of the following:
+ *
+ * Accompany the modified version of the Library with the complete
+ * corresponding machine-readable source code for the modified version
+ * of the Library; or,
+ *
+ * Accompany the modified version of the Library with a written offer
+ * for a complete machine-readable copy of the corresponding source
+ * code of the modified version of the Library.
+ *
+ *
+ * THE LIBRARY IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * LIBRARY OR THE USE OR OTHER DEALINGS IN THE LIBRARY.
+ */
+
+#ifndef MARS_TASK_MODULE_H
+#define MARS_TASK_MODULE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include <mars/dma.h>
+#include <mars/error.h>
+#include <mars/module.h>
+#include <mars/mutex.h>
+
+#include "mars/task_types.h"
+
+#include "task_internal_types.h"
+
+/* mars task module syscalls */
+struct mars_task_module_syscalls {
+ uint32_t (*get_kernel_id)(void);
+ struct mars_task_context * (*get_task)(void);
+ struct mars_task_context * (*get_task_by_id)
+ (struct mars_task_id *task_id);
+
+ void (*exit)(void);
+ void (*yield)(void);
+ int (*schedule)(uint16_t workload_id, struct mars_task_args *args,
+ uint8_t priority);
+ int (*wait)(uint16_t workload_id);
+ int (*try_wait)(uint16_t workload_id);
+ int (*signal_send)(uint16_t workload_id);
+ int (*signal_wait)(void);
+ int (*signal_try_wait)(void);
+};
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+extern const struct mars_task_module_syscalls *mars_task_module_syscalls;
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
More information about the cbe-oss-dev
mailing list