summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--bsp/risc-v/platform/interrupt.h13
-rw-r--r--bsp/risc-v/platform/plic_driver.c127
-rw-r--r--libcpu/risc-v/e310/trap.c55
-rw-r--r--src/idle.c232
4 files changed, 299 insertions, 128 deletions
diff --git a/bsp/risc-v/platform/interrupt.h b/bsp/risc-v/platform/interrupt.h
index 33c28ea939..019ba400b9 100644
--- a/bsp/risc-v/platform/interrupt.h
+++ b/bsp/risc-v/platform/interrupt.h
@@ -1 +1,12 @@
-#define INT_TIMER0 48
+#ifndef __INTERRUPT_H__
+#define __INTERRUPT_H__
+#include <rthw.h>
+void rt_hw_interrupt_mask(int irq);
+void rt_hw_interrupt_unmask(int irq);
+rt_isr_handler_t rt_hw_interrupt_handle(rt_uint32_t vector, void *param);
+void rt_hw_interrupt_init(void);
+rt_uint32_t rt_hw_interrupt_get_active(rt_uint32_t fiq_irq);
+void rt_hw_interrupt_ack(rt_uint32_t fiq_irq, rt_uint32_t id);
+rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
+ void *param, char *name);
+#endif
diff --git a/bsp/risc-v/platform/plic_driver.c b/bsp/risc-v/platform/plic_driver.c
deleted file mode 100644
index 01b7e6edb1..0000000000
--- a/bsp/risc-v/platform/plic_driver.c
+++ /dev/null
@@ -1,127 +0,0 @@
-// See LICENSE for license details.
-
-#include "sifive/devices/plic.h"
-#include "plic_driver.h"
-#include "platform.h"
-#include "encoding.h"
-#include <string.h>
-
-
-// Note that there are no assertions or bounds checking on these
-// parameter values.
-
-void volatile_memzero(uint8_t * base, unsigned int size)
-{
- volatile uint8_t * ptr;
- for (ptr = base; ptr < (base + size); ptr++){
- *ptr = 0;
- }
-}
-
-void PLIC_init (
- plic_instance_t * this_plic,
- uintptr_t base_addr,
- uint32_t num_sources,
- uint32_t num_priorities
- )
-{
-
- this_plic->base_addr = base_addr;
- this_plic->num_sources = num_sources;
- this_plic->num_priorities = num_priorities;
-
- // Disable all interrupts (don't assume that these registers are reset).
- unsigned long hart_id = read_csr(mhartid);
- volatile_memzero((uint8_t*) (this_plic->base_addr +
- PLIC_ENABLE_OFFSET +
- (hart_id << PLIC_ENABLE_SHIFT_PER_TARGET)),
- (num_sources + 8) / 8);
-
- // Set all priorities to 0 (equal priority -- don't assume that these are reset).
- volatile_memzero ((uint8_t *)(this_plic->base_addr +
- PLIC_PRIORITY_OFFSET),
- (num_sources + 1) << PLIC_PRIORITY_SHIFT_PER_SOURCE);
-
- // Set the threshold to 0.
- volatile plic_threshold* threshold = (plic_threshold*)
- (this_plic->base_addr +
- PLIC_THRESHOLD_OFFSET +
- (hart_id << PLIC_THRESHOLD_SHIFT_PER_TARGET));
-
- *threshold = 0;
-
-}
-
-void PLIC_set_threshold (plic_instance_t * this_plic,
- plic_threshold threshold){
-
- unsigned long hart_id = read_csr(mhartid);
- volatile plic_threshold* threshold_ptr = (plic_threshold*) (this_plic->base_addr +
- PLIC_THRESHOLD_OFFSET +
- (hart_id << PLIC_THRESHOLD_SHIFT_PER_TARGET));
-
- *threshold_ptr = threshold;
-
-}
-
-
-void PLIC_enable_interrupt (plic_instance_t * this_plic, plic_source source){
-
- unsigned long hart_id = read_csr(mhartid);
- volatile uint8_t * current_ptr = (volatile uint8_t *)(this_plic->base_addr +
- PLIC_ENABLE_OFFSET +
- (hart_id << PLIC_ENABLE_SHIFT_PER_TARGET) +
- (source >> 3));
- uint8_t current = *current_ptr;
- current = current | ( 1 << (source & 0x7));
- *current_ptr = current;
-
-}
-
-void PLIC_disable_interrupt (plic_instance_t * this_plic, plic_source source){
-
- unsigned long hart_id = read_csr(mhartid);
- volatile uint8_t * current_ptr = (volatile uint8_t *) (this_plic->base_addr +
- PLIC_ENABLE_OFFSET +
- (hart_id << PLIC_ENABLE_SHIFT_PER_TARGET) +
- (source >> 3));
- uint8_t current = *current_ptr;
- current = current & ~(( 1 << (source & 0x7)));
- *current_ptr = current;
-
-}
-
-void PLIC_set_priority (plic_instance_t * this_plic, plic_source source, plic_priority priority){
-
- if (this_plic->num_priorities > 0) {
- volatile plic_priority * priority_ptr = (volatile plic_priority *)
- (this_plic->base_addr +
- PLIC_PRIORITY_OFFSET +
- (source << PLIC_PRIORITY_SHIFT_PER_SOURCE));
- *priority_ptr = priority;
- }
-}
-
-plic_source PLIC_claim_interrupt(plic_instance_t * this_plic){
-
- unsigned long hart_id = read_csr(mhartid);
-
- volatile plic_source * claim_addr = (volatile plic_source * )
- (this_plic->base_addr +
- PLIC_CLAIM_OFFSET +
- (hart_id << PLIC_CLAIM_SHIFT_PER_TARGET));
-
- return *claim_addr;
-
-}
-
-void PLIC_complete_interrupt(plic_instance_t * this_plic, plic_source source){
-
- unsigned long hart_id = read_csr(mhartid);
- volatile plic_source * claim_addr = (volatile plic_source *) (this_plic->base_addr +
- PLIC_CLAIM_OFFSET +
- (hart_id << PLIC_CLAIM_SHIFT_PER_TARGET));
- *claim_addr = source;
-
-}
-
diff --git a/libcpu/risc-v/e310/trap.c b/libcpu/risc-v/e310/trap.c
new file mode 100644
index 0000000000..7429e1a5f3
--- /dev/null
+++ b/libcpu/risc-v/e310/trap.c
@@ -0,0 +1,55 @@
+#include <rtthread.h>
+#include <rthw.h>
+#include <platform.h>
+#include <encoding.h>
+#include "interrupt.h"
+extern struct rt_irq_desc irq_desc[];
+extern rt_uint32_t rt_hw_interrupt_get_active(rt_uint32_t fiq_irq);
+void rt_hw_trap_irq()
+{
+ rt_isr_handler_t isr_func;
+ rt_uint32_t irq;
+ void *param;
+
+ /* get irq number */
+ irq = rt_hw_interrupt_get_active(0);
+
+ /* get interrupt service routine */
+ isr_func = irq_desc[irq].handler;
+ param = irq_desc[irq].param;
+
+ /* turn to interrupt service routine */
+ isr_func(irq, param);
+ rt_hw_interrupt_ack(0, irq);
+
+#ifdef RT_USING_INTERRUPT_INFO
+ irq_desc[irq].counter ++;
+#endif
+}
+void handle_m_ext_interrupt()
+{
+}
+void rt_systick_handler(void)
+{
+ clear_csr(mie, MIP_MTIP);
+
+ // Reset the timer for 3s in the future.
+ // This also clears the existing timer interrupt.
+
+ volatile uint64_t * mtime = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIME);
+ volatile uint64_t * mtimecmp = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
+ uint64_t now = *mtime;
+ uint64_t then = now + 2 * RTC_FREQ/RT_TICK_PER_SECOND;
+ *mtimecmp = then;
+ rt_tick_increase();
+
+ // read the current value of the LEDS and invert them.
+/*
+ GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << RED_LED_OFFSET) |
+ (0x1 << GREEN_LED_OFFSET) |
+ (0x1 << BLUE_LED_OFFSET));
+ */
+
+ // Re-enable the timer interrupt.
+ set_csr(mie, MIP_MTIP);
+}
diff --git a/src/idle.c b/src/idle.c
new file mode 100644
index 0000000000..7373f280e1
--- /dev/null
+++ b/src/idle.c
@@ -0,0 +1,232 @@
+/*
+ * File : idle.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2006-03-23 Bernard the first version
+ * 2010-11-10 Bernard add cleanup callback function in thread exit.
+ * 2012-12-29 Bernard fix compiling warning.
+ * 2013-12-21 Grissiom let rt_thread_idle_excute loop until there is no
+ * dead thread.
+ * 2016-08-09 ArdaFu add method to get the handler of the idle thread.
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+
+#if defined (RT_USING_HOOK)
+#ifndef RT_USING_IDLE_HOOK
+#define RT_USING_IDLE_HOOK
+#endif
+#endif
+
+#ifndef IDLE_THREAD_STACK_SIZE
+#if defined (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP)
+#define IDLE_THREAD_STACK_SIZE 256
+#else
+#define IDLE_THREAD_STACK_SIZE 128
+#endif
+#endif
+
+static struct rt_thread idle;
+ALIGN(RT_ALIGN_SIZE)
+static rt_uint8_t rt_thread_stack[IDLE_THREAD_STACK_SIZE];
+
+extern rt_list_t rt_thread_defunct;
+
+#ifdef RT_USING_IDLE_HOOK
+static void (*rt_thread_idle_hook)();
+
+/**
+ * @ingroup Hook
+ * This function sets a hook function to idle thread loop. When the system performs
+ * idle loop, this hook function should be invoked.
+ *
+ * @param hook the specified hook function
+ *
+ * @note the hook function must be simple and never be blocked or suspend.
+ */
+void rt_thread_idle_sethook(void (*hook)(void))
+{
+ rt_thread_idle_hook = hook;
+}
+#endif
+
+/* Return whether there is defunctional thread to be deleted. */
+rt_inline int _has_defunct_thread(void)
+{
+ /* The rt_list_isempty has prototype of "int rt_list_isempty(const rt_list_t *l)".
+ * So the compiler has a good reason that the rt_thread_defunct list does
+ * not change within rt_thread_idle_excute thus optimize the "while" loop
+ * into a "if".
+ *
+ * So add the volatile qualifier here. */
+ const volatile rt_list_t *l = (const volatile rt_list_t*)&rt_thread_defunct;
+
+ return l->next != l;
+}
+
+/**
+ * @ingroup Thread
+ *
+ * This function will perform system background job when system idle.
+ */
+void rt_thread_idle_excute(void)
+{
+ /* Loop until there is no dead thread. So one call to rt_thread_idle_excute
+ * will do all the cleanups. */
+ while (_has_defunct_thread())
+ {
+ rt_base_t lock;
+ rt_thread_t thread;
+#ifdef RT_USING_MODULE
+ rt_module_t module = RT_NULL;
+#endif
+ RT_DEBUG_NOT_IN_INTERRUPT;
+
+ /* disable interrupt */
+ lock = rt_hw_interrupt_disable();
+
+ /* re-check whether list is empty */
+ if (_has_defunct_thread())
+ {
+ /* get defunct thread */
+ thread = rt_list_entry(rt_thread_defunct.next,
+ struct rt_thread,
+ tlist);
+#ifdef RT_USING_MODULE
+ /* get thread's parent module */
+ module = (rt_module_t)thread->module_id;
+
+ /* if the thread is module's main thread */
+ if (module != RT_NULL && module->module_thread == thread)
+ {
+ /* detach module's main thread */
+ module->module_thread = RT_NULL;
+ }
+#endif
+ /* remove defunct thread */
+ rt_list_remove(&(thread->tlist));
+ /* invoke thread cleanup */
+ if (thread->cleanup != RT_NULL)
+ thread->cleanup(thread);
+
+ /* if it's a system object, not delete it */
+ if (rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE)
+ {
+ /* enable interrupt */
+ rt_hw_interrupt_enable(lock);
+
+ return;
+ }
+ }
+ else
+ {
+ /* enable interrupt */
+ rt_hw_interrupt_enable(lock);
+
+ /* may the defunct thread list is removed by others, just return */
+ return;
+ }
+
+ /* enable interrupt */
+ rt_hw_interrupt_enable(lock);
+
+#ifdef RT_USING_HEAP
+#if defined(RT_USING_MODULE) && defined(RT_USING_SLAB)
+ /* the thread belongs to an application module */
+ if (thread->flags & RT_OBJECT_FLAG_MODULE)
+ rt_module_free((rt_module_t)thread->module_id, thread->stack_addr);
+ else
+#endif
+ /* release thread's stack */
+ RT_KERNEL_FREE(thread->stack_addr);
+ /* delete thread object */
+ rt_object_delete((rt_object_t)thread);
+#endif
+
+#ifdef RT_USING_MODULE
+ if (module != RT_NULL)
+ {
+ extern rt_err_t rt_module_destroy(rt_module_t module);
+
+ /* if sub thread list and main thread are all empty */
+ if ((module->module_thread == RT_NULL) &&
+ rt_list_isempty(&module->module_object[RT_Object_Class_Thread].object_list))
+ {
+ module->nref --;
+ }
+
+ /* destroy module */
+ if (module->nref == 0)
+ rt_module_destroy(module);
+ }
+#endif
+ }
+}
+
+static void rt_thread_idle_entry(void *parameter)
+{
+ rt_hw_interrupt_enable(0x888);
+ while (1)
+ {
+ #ifdef RT_USING_IDLE_HOOK
+ if (rt_thread_idle_hook != RT_NULL)
+ {
+ rt_thread_idle_hook();
+ }
+ #endif
+
+ rt_thread_idle_excute();
+ }
+}
+
+/**
+ * @ingroup SystemInit
+ *
+ * This function will initialize idle thread, then start it.
+ *
+ * @note this function must be invoked when system init.
+ */
+void rt_thread_idle_init(void)
+{
+ /* initialize thread */
+ rt_thread_init(&idle,
+ "tidle",
+ rt_thread_idle_entry,
+ RT_NULL,
+ &rt_thread_stack[0],
+ sizeof(rt_thread_stack),
+ RT_THREAD_PRIORITY_MAX - 1,
+ 32);
+
+ /* startup */
+ rt_thread_startup(&idle);
+}
+
+/**
+ * @ingroup Thread
+ *
+ * This function will get the handler of the idle thread.
+ *
+ */
+rt_thread_t rt_thread_idle_gethandler(void)
+{
+ return (rt_thread_t)(&idle);
+}
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 07:59:36 +0000