Update RX GCC port - including extracting all inline asm into separate asm file.

This commit is contained in:
Richard Barry 2010-08-29 07:24:30 +00:00
parent 23b1023a7a
commit c4217432f2
3 changed files with 220 additions and 175 deletions

View file

@ -78,7 +78,7 @@ PSW is set with U and I set, and PM and IPL clear. */
* Function to start the first task executing - written in asm code as direct
* access to registers is required.
*/
static void prvStartFirstTask( void ) __attribute__((naked));
extern void prvStartFirstTask( void );
/*
* Software interrupt handler. Performs the actual context switch (saving and
@ -88,19 +88,14 @@ static void prvStartFirstTask( void ) __attribute__((naked));
static void prvYieldHandler( void );
/*
* The entry point for the software interrupt handler. This is the function
* that calls the inline asm function prvYieldHandler(). It is installed in
* the vector table, but the code that installs it is in prvYieldHandler rather
* than using a #pragma.
* The tick ISR handler. The peripheral used is configured by the application
* via a hook/callback function.
*/
void vSoftwareInterruptISR( void );
void vTickISR( void ) __attribute__((interrupt));
/*-----------------------------------------------------------*/
/* This is accessed by the inline assembler functions so is file scope for
convenience. */
extern void *pxCurrentTCB;
extern void vTaskSwitchContext( void );
/*-----------------------------------------------------------*/
@ -190,65 +185,24 @@ extern void vApplicationSetupTimerInterrupt( void );
/* Ensure the software interrupt is set to the kernel priority. */
_IPR( _ICU_SWINT ) = configKERNEL_INTERRUPT_PRIORITY;
/* Start the first task. */
prvStartFirstTask();
}
/* Just to make sure the function is not optimised away. */
( void ) vSoftwareInterruptISR();
/* Should not get here. */
return pdFAIL;
}
/*-----------------------------------------------------------*/
static void prvStartFirstTask( void )
{
__asm
(
/* When starting the scheduler there is nothing that needs moving to the
interrupt stack because the function is not called from an interrupt.
Just ensure the current stack is the user stack. */
"SETPSW U \n" \
/* Obtain the location of the stack associated with which ever task
pxCurrentTCB is currently pointing to. */
"MOV.L #_pxCurrentTCB, R15 \n" \
"MOV.L [R15], R15 \n" \
"MOV.L [R15], R0 \n" \
/* Restore the registers from the stack of the task pointed to by
pxCurrentTCB. */
"POP R15 \n" \
/* Accumulator low 32 bits. */
"MVTACLO R15 \n" \
"POP R15 \n" \
/* Accumulator high 32 bits. */
"MVTACHI R15 \n" \
"POP R15 \n" \
/* Floating point status word. */
"MVTC R15, FPSW \n" \
/* R1 to R15 - R0 is not included as it is the SP. */
"POPM R1-R15 \n" \
/* This pops the remaining registers. */
"RTE \n" \
"NOP \n" \
"NOP \n"
);
}
/*-----------------------------------------------------------*/
void vTickISR( void )
{
/* Re-enable interrupts. */
__asm volatile( "SETPSW I" );
/* Increment the tick, and perform any processing the new tick value
necessitates. */
vTaskIncrementTick();
vTaskIncrementTick();
/* Only select a new task if the preemptive scheduler is being used. */
#if( configUSE_PREEMPTION == 1 )
@ -257,124 +211,9 @@ void vTickISR( void )
}
/*-----------------------------------------------------------*/
void vSoftwareInterruptISR( void )
{
// prvYieldHandler();
}
/*-----------------------------------------------------------*/
#if 0
#pragma inline_asm prvYieldHandler
static void prvYieldHandler( void )
{
/* Install as the software interrupt handler. */
.RVECTOR _VECT( _ICU_SWINT ), _vSoftwareInterruptISR
/* Re-enable interrupts. */
SETPSW I
/* Move the data that was automatically pushed onto the interrupt stack when
the interrupt occurred from the interrupt stack to the user stack.
R15 is saved before it is clobbered. */
PUSH.L R15
/* Read the user stack pointer. */
MVFC USP, R15
/* Move the address down to the data being moved. */
SUB #12, R15
MVTC R15, USP
/* Copy the data across. */
MOV.L [ R0 ], [ R15 ] ; R15
MOV.L 4[ R0 ], 4[ R15 ] ; PC
MOV.L 8[ R0 ], 8[ R15 ] ; PSW
/* Move the interrupt stack pointer to its new correct position. */
ADD #12, R0
/* All the rest of the registers are saved directly to the user stack. */
SETPSW U
/* Save the rest of the general registers (R15 has been saved already). */
PUSHM R1-R14
/* Save the FPSW and accumulator. */
MVFC FPSW, R15
PUSH.L R15
MVFACHI R15
PUSH.L R15
MVFACMI R15 ; Middle order word.
SHLL #16, R15 ; Shifted left as it is restored to the low order word.
PUSH.L R15
/* Save the stack pointer to the TCB. */
MOV.L #_pxCurrentTCB, R15
MOV.L [ R15 ], R15
MOV.L R0, [ R15 ]
/* Ensure the interrupt mask is set to the syscall priority while the kernel
structures are being accessed. */
MVTIPL #configMAX_SYSCALL_INTERRUPT_PRIORITY
/* Select the next task to run. */
BSR.A _vTaskSwitchContext
/* Reset the interrupt mask as no more data structure access is required. */
MVTIPL #configKERNEL_INTERRUPT_PRIORITY
/* Load the stack pointer of the task that is now selected as the Running
state task from its TCB. */
MOV.L #_pxCurrentTCB,R15
MOV.L [ R15 ], R15
MOV.L [ R15 ], R0
/* Restore the context of the new task. The PSW (Program Status Word) and
PC will be popped by the RTE instruction. */
POP R15
MVTACLO R15
POP R15
MVTACHI R15
POP R15
MVTC R15,FPSW
POPM R1-R15
RTE
NOP
NOP
}
#endif
/*-----------------------------------------------------------*/
void vPortEndScheduler( void )
{
/* Not implemented as there is nothing to return to. */
/* The following line is just to prevent the symbol getting optimised away. */
( void ) vTaskSwitchContext();
}
/*-----------------------------------------------------------*/
unsigned long ulPortGetIPL( void )
{
__asm(
"MVFC PSW, R1 \n" \
"SHLR #28, R1 \n" \
"RTS "
);
}
/*-----------------------------------------------------------*/
void vPortSetIPL( unsigned long ulNewIPL )
{
__asm(
"MVFC PSW, R5 \n" \
"SHLL #28, R1 \n" \
"AND #-0F000001H, R5 \n" \
"OR R1, R5 \n" \
"MVTC R5, PSW \n" \
"RTS "
);
}
/*-----------------------------------------------------------*/