/* | |
FreeRTOS V5.4.0 - Copyright (C) 2003-2009 Richard Barry. | |
This file is part of the FreeRTOS distribution. | |
FreeRTOS is free software; you can redistribute it and/or modify it under | |
the terms of the GNU General Public License (version 2) as published by the | |
Free Software Foundation and modified by the FreeRTOS exception. | |
**NOTE** The exception to the GPL is included to allow you to distribute a | |
combined work that includes FreeRTOS without being obliged to provide the | |
source code for proprietary components outside of the FreeRTOS kernel. | |
Alternative commercial license and support terms are also available upon | |
request. See the licensing section of http://www.FreeRTOS.org for full | |
license details. | |
FreeRTOS 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 FreeRTOS; if not, write to the Free Software Foundation, Inc., 59 | |
Temple Place, Suite 330, Boston, MA 02111-1307 USA. | |
*************************************************************************** | |
* * | |
* Looking for a quick start? Then check out the FreeRTOS eBook! * | |
* See http://www.FreeRTOS.org/Documentation for details * | |
* * | |
*************************************************************************** | |
1 tab == 4 spaces! | |
Please ensure to read the configuration and relevant port sections of the | |
online documentation. | |
http://www.FreeRTOS.org - Documentation, latest information, license and | |
contact details. | |
http://www.SafeRTOS.com - A version that is certified for use in safety | |
critical systems. | |
http://www.OpenRTOS.com - Commercial support, development, porting, | |
licensing and training services. | |
*/ | |
/* | |
Changes from V2.5.2 | |
+ usCriticalNesting now has a volatile qualifier. | |
*/ | |
/* Standard includes. */ | |
#include <stdlib.h> | |
#include <signal.h> | |
/* Scheduler includes. */ | |
#include "FreeRTOS.h" | |
#include "task.h" | |
/*----------------------------------------------------------- | |
* Implementation of functions defined in portable.h for the MSP430 port. | |
*----------------------------------------------------------*/ | |
/* Constants required for hardware setup. The tick ISR runs off the ACLK, | |
not the MCLK. */ | |
#define portACLK_FREQUENCY_HZ ( ( portTickType ) 32768 ) | |
#define portINITIAL_CRITICAL_NESTING ( ( unsigned portSHORT ) 10 ) | |
#define portFLAGS_INT_ENABLED ( ( portSTACK_TYPE ) 0x08 ) | |
/* We require the address of the pxCurrentTCB variable, but don't want to know | |
any details of its type. */ | |
typedef void tskTCB; | |
extern volatile tskTCB * volatile pxCurrentTCB; | |
/* Most ports implement critical sections by placing the interrupt flags on | |
the stack before disabling interrupts. Exiting the critical section is then | |
simply a case of popping the flags from the stack. As mspgcc does not use | |
a frame pointer this cannot be done as modifying the stack will clobber all | |
the stack variables. Instead each task maintains a count of the critical | |
section nesting depth. Each time a critical section is entered the count is | |
incremented. Each time a critical section is left the count is decremented - | |
with interrupts only being re-enabled if the count is zero. | |
usCriticalNesting will get set to zero when the scheduler starts, but must | |
not be initialised to zero as this will cause problems during the startup | |
sequence. */ | |
volatile unsigned portSHORT usCriticalNesting = portINITIAL_CRITICAL_NESTING; | |
/*-----------------------------------------------------------*/ | |
/* | |
* Macro to save a task context to the task stack. This simply pushes all the | |
* general purpose msp430 registers onto the stack, followed by the | |
* usCriticalNesting value used by the task. Finally the resultant stack | |
* pointer value is saved into the task control block so it can be retrieved | |
* the next time the task executes. | |
*/ | |
#define portSAVE_CONTEXT() \ | |
asm volatile ( "push r4 \n\t" \ | |
"push r5 \n\t" \ | |
"push r6 \n\t" \ | |
"push r7 \n\t" \ | |
"push r8 \n\t" \ | |
"push r9 \n\t" \ | |
"push r10 \n\t" \ | |
"push r11 \n\t" \ | |
"push r12 \n\t" \ | |
"push r13 \n\t" \ | |
"push r14 \n\t" \ | |
"push r15 \n\t" \ | |
"mov.w usCriticalNesting, r14 \n\t" \ | |
"push r14 \n\t" \ | |
"mov.w pxCurrentTCB, r12 \n\t" \ | |
"mov.w r1, @r12 \n\t" \ | |
); | |
/* | |
* Macro to restore a task context from the task stack. This is effectively | |
* the reverse of portSAVE_CONTEXT(). First the stack pointer value is | |
* loaded from the task control block. Next the value for usCriticalNesting | |
* used by the task is retrieved from the stack - followed by the value of all | |
* the general purpose msp430 registers. | |
* | |
* The bic instruction ensures there are no low power bits set in the status | |
* register that is about to be popped from the stack. | |
*/ | |
#define portRESTORE_CONTEXT() \ | |
asm volatile ( "mov.w pxCurrentTCB, r12 \n\t" \ | |
"mov.w @r12, r1 \n\t" \ | |
"pop r15 \n\t" \ | |
"mov.w r15, usCriticalNesting \n\t" \ | |
"pop r15 \n\t" \ | |
"pop r14 \n\t" \ | |
"pop r13 \n\t" \ | |
"pop r12 \n\t" \ | |
"pop r11 \n\t" \ | |
"pop r10 \n\t" \ | |
"pop r9 \n\t" \ | |
"pop r8 \n\t" \ | |
"pop r7 \n\t" \ | |
"pop r6 \n\t" \ | |
"pop r5 \n\t" \ | |
"pop r4 \n\t" \ | |
"bic #(0xf0),0(r1) \n\t" \ | |
"reti \n\t" \ | |
); | |
/*-----------------------------------------------------------*/ | |
/* | |
* Sets up the periodic ISR used for the RTOS tick. This uses timer 0, but | |
* could have alternatively used the watchdog timer or timer 1. | |
*/ | |
static void prvSetupTimerInterrupt( void ); | |
/*-----------------------------------------------------------*/ | |
/* | |
* Initialise the stack of a task to look exactly as if a call to | |
* portSAVE_CONTEXT had been called. | |
* | |
* See the header file portable.h. | |
*/ | |
portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters ) | |
{ | |
/* | |
Place a few bytes of known values on the bottom of the stack. | |
This is just useful for debugging and can be included if required. | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x1111; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x2222; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x3333; | |
pxTopOfStack--; | |
*/ | |
/* The msp430 automatically pushes the PC then SR onto the stack before | |
executing an ISR. We want the stack to look just as if this has happened | |
so place a pointer to the start of the task on the stack first - followed | |
by the flags we want the task to use when it starts up. */ | |
*pxTopOfStack = ( portSTACK_TYPE ) pxCode; | |
pxTopOfStack--; | |
*pxTopOfStack = portFLAGS_INT_ENABLED; | |
pxTopOfStack--; | |
/* Next the general purpose registers. */ | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x4444; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x5555; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x6666; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x7777; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x8888; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0x9999; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0xaaaa; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0xbbbb; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0xcccc; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0xdddd; | |
pxTopOfStack--; | |
*pxTopOfStack = ( portSTACK_TYPE ) 0xeeee; | |
pxTopOfStack--; | |
/* When the task starts is will expect to find the function parameter in | |
R15. */ | |
*pxTopOfStack = ( portSTACK_TYPE ) pvParameters; | |
pxTopOfStack--; | |
/* The code generated by the mspgcc compiler does not maintain separate | |
stack and frame pointers. The portENTER_CRITICAL macro cannot therefore | |
use the stack as per other ports. Instead a variable is used to keep | |
track of the critical section nesting. This variable has to be stored | |
as part of the task context and is initially set to zero. */ | |
*pxTopOfStack = ( portSTACK_TYPE ) portNO_CRITICAL_SECTION_NESTING; | |
/* Return a pointer to the top of the stack we have generated so this can | |
be stored in the task control block for the task. */ | |
return pxTopOfStack; | |
} | |
/*-----------------------------------------------------------*/ | |
portBASE_TYPE xPortStartScheduler( void ) | |
{ | |
/* Setup the hardware to generate the tick. Interrupts are disabled when | |
this function is called. */ | |
prvSetupTimerInterrupt(); | |
/* Restore the context of the first task that is going to run. */ | |
portRESTORE_CONTEXT(); | |
/* Should not get here as the tasks are now running! */ | |
return pdTRUE; | |
} | |
/*-----------------------------------------------------------*/ | |
void vPortEndScheduler( void ) | |
{ | |
/* It is unlikely that the MSP430 port will get stopped. If required simply | |
disable the tick interrupt here. */ | |
} | |
/*-----------------------------------------------------------*/ | |
/* | |
* Manual context switch called by portYIELD or taskYIELD. | |
* | |
* The first thing we do is save the registers so we can use a naked attribute. | |
*/ | |
void vPortYield( void ) __attribute__ ( ( naked ) ); | |
void vPortYield( void ) | |
{ | |
/* We want the stack of the task being saved to look exactly as if the task | |
was saved during a pre-emptive RTOS tick ISR. Before calling an ISR the | |
msp430 places the status register onto the stack. As this is a function | |
call and not an ISR we have to do this manually. */ | |
asm volatile ( "push r2" ); | |
_DINT(); | |
/* Save the context of the current task. */ | |
portSAVE_CONTEXT(); | |
/* Switch to the highest priority task that is ready to run. */ | |
vTaskSwitchContext(); | |
/* Restore the context of the new task. */ | |
portRESTORE_CONTEXT(); | |
} | |
/*-----------------------------------------------------------*/ | |
/* | |
* Hardware initialisation to generate the RTOS tick. This uses timer 0 | |
* but could alternatively use the watchdog timer or timer 1. | |
*/ | |
static void prvSetupTimerInterrupt( void ) | |
{ | |
/* Ensure the timer is stopped. */ | |
TACTL = 0; | |
/* Run the timer of the ACLK. */ | |
TACTL = TASSEL_1; | |
/* Clear everything to start with. */ | |
TACTL |= TACLR; | |
/* Set the compare match value according to the tick rate we want. */ | |
TACCR0 = portACLK_FREQUENCY_HZ / configTICK_RATE_HZ; | |
/* Enable the interrupts. */ | |
TACCTL0 = CCIE; | |
/* Start up clean. */ | |
TACTL |= TACLR; | |
/* Up mode. */ | |
TACTL |= MC_1; | |
} | |
/*-----------------------------------------------------------*/ | |
/* | |
* The interrupt service routine used depends on whether the pre-emptive | |
* scheduler is being used or not. | |
*/ | |
#if configUSE_PREEMPTION == 1 | |
/* | |
* Tick ISR for preemptive scheduler. We can use a naked attribute as | |
* the context is saved at the start of vPortYieldFromTick(). The tick | |
* count is incremented after the context is saved. | |
*/ | |
interrupt (TIMERA0_VECTOR) prvTickISR( void ) __attribute__ ( ( naked ) ); | |
interrupt (TIMERA0_VECTOR) prvTickISR( void ) | |
{ | |
/* Save the context of the interrupted task. */ | |
portSAVE_CONTEXT(); | |
/* Increment the tick count then switch to the highest priority task | |
that is ready to run. */ | |
vTaskIncrementTick(); | |
vTaskSwitchContext(); | |
/* Restore the context of the new task. */ | |
portRESTORE_CONTEXT(); | |
} | |
#else | |
/* | |
* Tick ISR for the cooperative scheduler. All this does is increment the | |
* tick count. We don't need to switch context, this can only be done by | |
* manual calls to taskYIELD(); | |
*/ | |
interrupt (TIMERA0_VECTOR) prvTickISR( void ); | |
interrupt (TIMERA0_VECTOR) prvTickISR( void ) | |
{ | |
vTaskIncrementTick(); | |
} | |
#endif | |