audk/EdkModulePkg/Core/Pei/Ipf/IpfCpuCore.s

193 lines
7.4 KiB
ArmAsm
Raw Normal View History

//++
// Copyright (c) 2006, Intel Corporation
// All rights reserved. This program and the accompanying materials
// are licensed and made available under the terms and conditions of the BSD License
// which accompanies this distribution. The full text of the license may be found at
// http://opensource.org/licenses/bsd-license.php
//
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
//
// Module Name:
//
// IpfCpuCore.s
//
// Abstract:
// IPF Specific assembly routines
//
//--
.file "IpfCpuCore.s"
#include "IpfMacro.i"
#include "IpfCpuCore.i"
//----------------------------------------------------------------------------------
// This module supports terminating CAR (Cache As RAM) stage. It copies all the
// CAR data into real RAM and then makes a stack switch.
// EFI_STATUS
// SwitchCoreStacks (
// IN VOID *EntryPoint,
// IN UINTN CopySize,
// IN VOID *OldBase,
// IN VOID *NewBase
// IN UINTN NewSP, OPTIONAL
// IN UINTN NewBSP OPTIONAL
// )
// EFI_STATUS
// SwitchCoreStacks (
// IN VOID *EntryPointForContinuationFunction,
// IN UINTN StartupDescriptor,
// IN VOID PEICorePointer,
// IN UINTN NewSP
// )
//----------------------------------------------------------------------------------
PROCEDURE_ENTRY (SwitchCoreStacks)
NESTED_SETUP (4,2,0,0)
// first save all stack registers in GPRs.
mov r13 = in0;; // this is a pointer to the PLABEL of the continuation function.
ld8 r16 = [r13],8;; // r16 = address of continuation function from the PLABEL
ld8 gp = [r13];; // gp = gp of continuation function from the PLABEL
mov b1 = r16;;
// save the parameters in r5, r6. these 2 seemed to be preserved across PAL calls
mov r5 = in1;; // this is the parameter1 to pass to the continuation function
mov r6 = in2;; // this is the parameter2 to pass to the continuation function
dep r6=0,r6,63,1;; // zero the bit 63.
mov r8 = in3;; // new stack pointer.
// r8 has the sp, this is 128K stack size, from this we will reserve 16K for the bspstore
movl r15 = PEI_BSP_STORE_SIZE;;
sub r8 = r8, r15;;
add r15 = (GuardBand),r8;; // some little buffer, now r15 will be our bspstore
// save the bspstore value to r4, save sp value to r7
mov r4 = r15
mov r7 = r8
mov r16 = r8;; // will be the new sp in uncache mode
alloc r11=0,0,0,0;; // Set 0-size frame
flushrs;;
mov r21 = RSC_KERNEL_DISABLED;; // for rse disable
mov ar.rsc = r21;; // turn off RSE
add sp = r0, r16 // transfer to the EFI stack
mov ar.bspstore = r15 // switch to EFI BSP
invala // change of ar.bspstore needs invala.
mov r19 = RSC_KERNEL_LAZ;; // RSC enabled, Lazy mode
mov ar.rsc = r19;; // turn rse on, in kernel mode
//-----------------------------------------------------------------------------------
// Save here the meaningful stuff for next few lines and then make the PAL call.
// Make PAL call to terminate the CAR status.
// AVL: do this only for recovery check call...
mov r28=ar.k3;;
dep r2 = r28,r0,0,8;; // Extract Function bits from GR20.
cmp.eq p6,p7 = RecoveryFn,r2;; // Is it Recovery check
(p7) br.sptk.few DoneCARTermination; // if not, don't terminate car..
TerminateCAR::
mov r28 = ip;;
add r28 = (DoneCARTerminationPALCall - TerminateCAR),r28;;
mov b0 = r28
mov r8 = ar.k5;;
mov b6 = r8
mov r28 = 0x208
mov r29 = r0
mov r30 = r0
mov r31 = r0
mov r8 = r0;;
br.sptk.few b6;; // Call PAL-A call.
DoneCARTerminationPALCall::
// don't check error in soft sdv, it is always returning -1 for this call for some reason
#if SOFT_SDV
#else
ReturnToPEIMain::
cmp.eq p6,p7 = r8,r0;;
//
// dead loop if the PAL call failed, we have the CAR on but the stack is now pointing to memory
//
(p7) br.sptk.few ReturnToPEIMain;;
//
// PAL call successed,now the stack are in memory so come into cache mode
// instead of uncache mode
//
alloc r11=0,0,0,0;; // Set 0-size frame
flushrs;;
mov r21 = RSC_KERNEL_DISABLED;; // for rse disable
mov ar.rsc = r21;; // turn off RSE
dep r6 = 0,r6,63,1 // zero the bit 63
dep r7 = 0,r7,63,1 // zero the bit 63
dep r4 = 0,r4,63,1;; // zero the bit 63
add sp = r0, r7 // transfer to the EFI stack in cache mode
mov ar.bspstore = r4 // switch to EFI BSP
invala // change of ar.bspstore needs invala.
mov r19 = RSC_KERNEL_LAZ;; // RSC enabled, Lazy mode
mov ar.rsc = r19;; // turn rse on, in kernel mode
#endif
DoneCARTermination::
// allocate a stack frame:
alloc r11=0,2,2,0 ;; // alloc outs going to ensuing DXE IPL service
// on the new stack
mov out0 = r5;;
mov out1 = r6;;
mov r16 = b1;;
mov b6 = r16;;
br.call.sptk.few b0=b6;; // Call the continuation function
NESTED_RETURN
PROCEDURE_EXIT(SwitchCoreStacks)
//-----------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
//++
// GetHandOffStatus
//
// This routine is called by all processors simultaneously, to get some hand-off
// status that has been captured by IPF dispatcher and recorded in kernel registers.
//
// Arguments :
//
// On Entry : None.
//
// Return Value: Lid, R20Status.
//
//--
//----------------------------------------------------------------------------------
PROCEDURE_ENTRY (GetHandOffStatus)
NESTED_SETUP (0,2+0,0,0)
mov r8 = ar.k6 // Health Status (Self test params)
mov r9 = ar.k4 // LID bits
mov r10 = ar.k3;; // SAL_E entry state
mov r11 = ar.k7 // Return address to PAL
NESTED_RETURN
PROCEDURE_EXIT (GetHandOffStatus)
//----------------------------------------------------------------------------------