pinebuds/rtos/rtx/TARGET_CORTEX_A/rt_System.c

/*----------------------------------------------------------------------------
 *      RL-ARM - RTX
 *----------------------------------------------------------------------------
 *      Name:    RT_SYSTEM.C
 *      Purpose: System Task Manager
 *      Rev.:    V4.60
 *----------------------------------------------------------------------------
 *
 * Copyright (c) 1999-2009 KEIL, 2009-2012 ARM Germany GmbH
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  - Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *  - Neither the name of ARM  nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *---------------------------------------------------------------------------*/

#include "rt_System.h"
#include "RTX_Config.h"
#include "rt_Event.h"
#include "rt_List.h"
#include "rt_Mailbox.h"
#include "rt_Robin.h"
#include "rt_Semaphore.h"
#include "rt_Task.h"
#include "rt_Time.h"
#include "rt_Timer.h"
#include "rt_TypeDef.h"
#ifdef __CORTEX_A9
#include "rt_HAL_CA.h"
#else
#include "rt_HAL_CM.h"
#endif

/*----------------------------------------------------------------------------
 *      Global Variables
 *---------------------------------------------------------------------------*/

int os_tick_irqn;

/*----------------------------------------------------------------------------
 *      Local Variables
 *---------------------------------------------------------------------------*/

static volatile BIT os_lock;
static volatile BIT os_psh_flag;
#ifndef __CORTEX_A9
static U8 pend_flags;
#endif
/*----------------------------------------------------------------------------
 *      Global Functions
 *---------------------------------------------------------------------------*/

#if defined(__CC_ARM)
__asm void $$RTX$$version(void) {
  /* Export a version number symbol for a version control. */

  EXPORT __RL_RTX_VER

      __RL_RTX_VER EQU 0x450
}
#endif

/*--------------------------- rt_suspend ------------------------------------*/

U32 rt_suspend(void) {
  /* Suspend OS scheduler */
  U32 delta = 0xFFFF;

  rt_tsk_lock();

  if (os_dly.p_dlnk) {
    delta = os_dly.delta_time;
  }
#ifndef __CMSIS_RTOS
  if (os_tmr.next) {
    if (os_tmr.tcnt < delta)
      delta = os_tmr.tcnt;
  }
#endif

  return (delta);
}

/*--------------------------- rt_resume -------------------------------------*/

void rt_resume(U32 sleep_time) {
  /* Resume OS scheduler after suspend */
  P_TCB next;
  U32 delta;

  os_tsk.run->state = READY;
  rt_put_rdy_first(os_tsk.run);

  os_robin.task = NULL;

  /* Update delays. */
  if (os_dly.p_dlnk) {
    delta = sleep_time;
    if (delta >= os_dly.delta_time) {
      delta -= os_dly.delta_time;
      os_time += os_dly.delta_time;
      os_dly.delta_time = 1;
      while (os_dly.p_dlnk) {
        rt_dec_dly();
        if (delta == 0)
          break;
        delta--;
        os_time++;
      }
    } else {
      os_time += delta;
      os_dly.delta_time -= delta;
    }
  } else {
    os_time += sleep_time;
  }

#ifndef __CMSIS_RTOS
  /* Check the user timers. */
  if (os_tmr.next) {
    delta = sleep_time;
    if (delta >= os_tmr.tcnt) {
      delta -= os_tmr.tcnt;
      os_tmr.tcnt = 1;
      while (os_tmr.next) {
        rt_tmr_tick();
        if (delta == 0)
          break;
        delta--;
      }
    } else {
      os_tmr.tcnt -= delta;
    }
  }
#endif

  /* Switch back to highest ready task */
  next = rt_get_first(&os_rdy);
  rt_switch_req(next);

  rt_tsk_unlock();
}

/*--------------------------- rt_tsk_lock -----------------------------------*/

void rt_tsk_lock(void) {
  /* Prevent task switching by locking out scheduler */
  if (os_tick_irqn < 0) {
    OS_LOCK();
    os_lock = __TRUE;
    OS_UNPEND(&pend_flags);
  } else {
    OS_X_LOCK(os_tick_irqn);
    os_lock = __TRUE;
    OS_X_UNPEND(&pend_flags);
  }
}

/*--------------------------- rt_tsk_unlock ---------------------------------*/

void rt_tsk_unlock(void) {
  /* Unlock scheduler and re-enable task switching */
  if (os_tick_irqn < 0) {
    OS_UNLOCK();
    os_lock = __FALSE;
    OS_PEND(pend_flags, os_psh_flag);
    os_psh_flag = __FALSE;
  } else {
    OS_X_UNLOCK(os_tick_irqn);
    os_lock = __FALSE;
    OS_X_PEND(pend_flags, os_psh_flag);
    os_psh_flag = __FALSE;
  }
}

/*--------------------------- rt_psh_req ------------------------------------*/

void rt_psh_req(void) {
  /* Initiate a post service handling request if required. */
  if (os_lock == __FALSE) {
    OS_PEND_IRQ();
  } else {
    os_psh_flag = __TRUE;
  }
}

/*--------------------------- rt_pop_req ------------------------------------*/

void rt_pop_req(void) {
  /* Process an ISR post service requests. */
  struct OS_XCB *p_CB;
  P_TCB next;
  U32 idx;

  os_tsk.run->state = READY;
  rt_put_rdy_first(os_tsk.run);

  idx = os_psq->last;
  while (os_psq->count) {
    p_CB = os_psq->q[idx].id;
    if (p_CB->cb_type == TCB) {
      /* Is of TCB type */
      rt_evt_psh((P_TCB)p_CB, (U16)os_psq->q[idx].arg);
    } else if (p_CB->cb_type == MCB) {
      /* Is of MCB type */
      rt_mbx_psh((P_MCB)p_CB, (void *)os_psq->q[idx].arg);
    } else {
      /* Must be of SCB type */
      rt_sem_psh((P_SCB)p_CB);
    }
    if (++idx == os_psq->size)
      idx = 0;
    rt_dec(&os_psq->count);
  }
  os_psq->last = idx;

  next = rt_get_first(&os_rdy);
  rt_switch_req(next);
}

/*--------------------------- os_tick_init ----------------------------------*/

__weak int os_tick_init(void) {
  /* Initialize SysTick timer as system tick timer. */
  rt_systick_init();
  return (-1); /* Return IRQ number of SysTick timer */
}

/*--------------------------- os_tick_irqack --------------------------------*/

__weak void os_tick_irqack(void) { /* Acknowledge timer interrupt. */
}

/*--------------------------- rt_systick ------------------------------------*/

extern void sysTimerTick(void);

void rt_systick(void) {
  /* Check for system clock update, suspend running task. */
  P_TCB next;

  os_tsk.run->state = READY;
  rt_put_rdy_first(os_tsk.run);

  /* Check Round Robin timeout. */
  rt_chk_robin();

  /* Update delays. */
  os_time++;
  rt_dec_dly();

  /* Check the user timers. */
#ifdef __CMSIS_RTOS
  sysTimerTick();
#else
  rt_tmr_tick();
#endif

  /* Switch back to highest ready task */
  next = rt_get_first(&os_rdy);
  rt_switch_req(next);
}

/*--------------------------- rt_stk_check ----------------------------------*/

__weak void rt_stk_check(void) {
  /* Check for stack overflow. */
  if ((os_tsk.run->tsk_stack < (U32)os_tsk.run->stack) ||
      (os_tsk.run->stack[0] != MAGIC_WORD)) {
    os_error(OS_ERR_STK_OVF);
  }
}

/*----------------------------------------------------------------------------
 * end of file
 *---------------------------------------------------------------------------*/