修改： ../../libcpu/risc-v/e310/context_gcc.S

	enable interrupt after return form rt_hw_context_switch

1 files changed, 0 insertions, 231 deletions

diff --git a/src/idle.c b/src/idle.c
deleted file mode 100644
index db87baa484..0000000000
--- a/src/idle.c
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * 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)
-{
-    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);
-}