system.c

Go to the documentation of this file.

/***************************************************************************
 * system.c
 * (C) 2010 Ivan Meleca
 * Based on original code written by Ruben Meleca
 * www.milos.it

#   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., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#include "system.h"
#include "dbgterm.h"
#include "heap.h"
#include "thread.h"
#include "timer.h"
#include "device.h"
#include "rtc.h"

__BOOL  __systemReset = __FALSE;                        
__STATIC __APP_ENTRY*   __systemAppEntry = __NULL;      
__STATIC __VOLATILE u32 __systemIrqCount;               
__STATIC __VOLATILE u32 __systemTickCount = 0;          
__STATIC __VOLATILE u32 __systemSecondsCount = 0;       
__STATIC __VOLATILE u32 __systemContextSwCount = 0;     
__STATIC __VOLATILE u32 __systemNestingISR = 0;         
__STATIC __PTHREAD      __systemThreadPtr;              
__STATIC __VOLATILE u8  __systemContextSwRequest;       
__VOID __systemThread(__VOID)
{
    u32 ticks = __systemTickCount;

    /* Start thread for software timers */
#if __CONFIG_ENABLE_SWTIMERS
    __timerInit(__CONFIG_STACK_TIMTHREAD);
#endif

    /* Initialize the Debug Terminal, if enabled */
#if __CONFIG_DBGTERM_ENABLED
    __dbgInit();
#endif // __CONFIG_DBGTERM_ENABLED

    if (__systemAppEntry)
    {
        (__systemAppEntry)();
    }
    
    for(;;)
    {

#if __CONFIG_ENABLE_WATCHDOG
        if (!__systemReset)
        {
//          __cpuResetWatchdog();
        }
#endif /* __CONFIG_ENABLE_WATCHDOG */
        
#if __CONFIG_ENABLE_HEARTBEAT
        __cpuHeartBeat();
#endif /* __CONFIG_ENABLE_HEARTBEAT */

        /* Seconds counter */
        if (__systemTickCount < ticks)
        {
            /* overflowed */
            ticks = 0xFFFFFFFF - ticks;
        }

        if (__systemTickCount - ticks > CPU_MS_TO_TICKS(1000))
        {
            __systemSecondsCount += (__systemTickCount - ticks) / CPU_MS_TO_TICKS(1000);
            ticks = __systemTickCount;
        }

        __threadSleep(__CONFIG_SYSTHREAD_SLEEP_TIME);
    }
}

__STATIC __VOID __systemInitThread(__VOID)
{

    /* Create system thread */
    __systemThreadPtr = __threadCreate( "system",                       /* name         */
                                        __systemThread,                 /* function     */
                                        __CONFIG_PRIO_SYSTHREAD,        /* priority     */
                                        __CONFIG_STACK_SYSTHREAD,       /* stack        */
                                        1,                              /* time to live */
                                        __NULL);                        /* parameter    */

    /* Call platform custom initialization before activating
     * the scheduler
     */
    __cpuCustomCreateSystemThread();
}

__VOID __systemInit(__APP_ENTRY* entry)
{
    /* Avoid interrupts we are not handling yet */
    __systemStop();
    
    __systemAppEntry = entry;
    
    /* Init CPU hardware */
    __cpuInitHardware();
    
    /* MMU */
    __cpuStartMMU();

    /* Init Interrupts */
    __cpuInitInterrupts();

    /* Init Heap */
    __heapInit(&__CPU_HEAP_BASE, (u32) &__CPU_HEAP_SIZE);

    /* Init RTC */
#if __CONFIG_COMPILE_RTC
    __rtcInit();
#endif /* __CONFIG_COMPILE_RTC */

    /* Initialize Watchdog */
#if __CONFIG_ENABLE_WATCHDOG
//  __cpuStartWatchdog();
#endif /* __CONFIG_ENABLE_WATCHDOG */
    
    /* Create System Threads */
    __systemInitThread();

    /* Init Scheduler timer after creating the first thread */
    __cpuInitSchedulerTimer();

    __systemScheduleThreadChange();

    /* Enable interrupts */
    __systemStart();

    /* If everything is OK, we should be running the OS by now.
     * This function will never return. __systemThread() will now enter execution under
     * the context of the OS.
     */
    for (;;)
    {
    }
}

__VOID __systemProcessTick(__VOID)
{
    /* Software system ticks */
    __systemTickCount++;
    __threadProcessTick();
}

__VOID __systemStop(__VOID)
{
    if (!__systemIrqCount)
    {
        __cpuDisableInterrupts();
    }
    __systemIrqCount++;
}

__VOID __systemStart(__VOID)
{
    if (__systemIrqCount && --__systemIrqCount) {
        return;
    }

    /* enable interrupts */
    __cpuEnableInterrupts();
}


__VOID __systemEnableScheduler(__VOID)
{
    __systemStop();
    if (__systemContextSwCount)
    {
        __systemContextSwCount--;

        /* Check for pending thread change request */
        if (!__systemContextSwCount && __systemContextSwRequest)
        {
            __systemContextSwRequest = 0;

            /* Check if there is a ready thread with higher priority
             * than the current one.
             */
            if (__threadGetCurrent()) {
                if (__threadGetCurrent()->th_priority > __threadGetReady()->th_priority)
                {
                    __threadAddToReadyList(__threadGetCurrent());
                    __threadSetCurrent(__NULL);
                    __systemScheduleThreadChange();
                }
            }
        }
    }
    __systemStart();
}

__VOID __systemDisableScheduler(__VOID)
{
    __systemStop();
    __systemContextSwCount++;
    if (__cpuThreadChangeScheduled())
        __cpuClearPendingThreadChange();
    __systemStart();
}

__VOID __systemScheduleThreadChange(__VOID)
{
    if (!__systemContextSwCount)
    {
        __cpuScheduleThreadChange();
    } else
    {
        __systemContextSwRequest = 1;
    }
}

__VOID __systemEnterISR(__VOID)
{
    __systemNestingISR++;
}

__VOID __systemLeaveISR(__VOID)
{
    __systemNestingISR--;
}

u32 __systemGetTickCount(__VOID)
{
    return __systemTickCount;
}

u32 __systemGetSecondsCount(__VOID)
{
    return __systemSecondsCount;
}

u32 __systemGetIrqCount(__VOID)
{
    return __systemIrqCount;
}

__BOOL __systemSchedulerDisabled(__VOID)
{
    if (__systemContextSwCount) return __TRUE;
    return __FALSE;
}