Subversion Repositories HelenOS

Rev

Rev 2726 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*++
  2.  
  3. Copyright (c) 1999  Intel Corporation
  4.    
  5. Module Name:
  6.  
  7.     salpal.c
  8.  
  9. Abstract:
  10.  
  11.     Functions to make SAL and PAL proc calls
  12.  
  13. Revision History
  14.  
  15. --*/
  16. #include "lib.h"
  17. #include "palproc.h"
  18. #include "salproc.h"
  19. /*++
  20.  
  21. Copyright (c) 1999  Intel Corporation
  22.  
  23. Module Name:
  24.  
  25.     EfiRtLib.h
  26.  
  27. Abstract:
  28.  
  29.     EFI Runtime library functions
  30.  
  31.  
  32.  
  33. Revision History
  34.  
  35. --*/
  36.  
  37. #include "efi.h"
  38. #include "efilib.h"
  39.  
  40. rArg
  41. MakeStaticPALCall (
  42.     IN UINT64   PALPROCPtr,
  43.     IN UINT64   Arg1,
  44.     IN UINT64   Arg2,
  45.     IN UINT64   Arg3,
  46.     IN UINT64   Arg4
  47.     );
  48.  
  49. rArg
  50. MakeStackedPALCall (
  51.     IN UINT64   PALPROCPtr,
  52.     IN UINT64   Arg1,
  53.     IN UINT64   Arg2,
  54.     IN UINT64   Arg3,
  55.     IN UINT64   Arg4
  56.     );
  57.  
  58.  
  59. PLABEL   SalProcPlabel;
  60. PLABEL   PalProcPlabel;
  61. CALL_SAL_PROC   GlobalSalProc;
  62. CALL_PAL_PROC   GlobalPalProc;
  63.  
  64. VOID
  65. LibInitSalAndPalProc (
  66.     OUT PLABEL  *SalPlabel,
  67.     OUT UINT64  *PalEntry
  68.     )
  69. {
  70.     SAL_SYSTEM_TABLE_ASCENDING_ORDER    *SalSystemTable;
  71.     EFI_STATUS                          Status;
  72.  
  73.     GlobalSalProc = NULL;
  74.     GlobalPalProc = NULL;
  75.  
  76.     Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID **)&SalSystemTable);
  77.     if (EFI_ERROR(Status)) {
  78.         return;
  79.     }
  80.  
  81.     //
  82.     // BugBug: Add code to test checksum on the Sal System Table
  83.     //
  84.     if (SalSystemTable->Entry0.Type != 0) {
  85.         return;
  86.     }
  87.  
  88.     SalProcPlabel.ProcEntryPoint = SalSystemTable->Entry0.SalProcEntry;
  89.     SalProcPlabel.GP             = SalSystemTable->Entry0.GlobalDataPointer;
  90.     GlobalSalProc                = (CALL_SAL_PROC)&SalProcPlabel.ProcEntryPoint;
  91.  
  92.     //
  93.     // Need to check the PAL spec to make sure I'm not responsible for
  94.     //  storing more state.
  95.     // We are passing in a Plabel that should be ignorred by the PAL. Call
  96.     //  this way will cause use to retore our gp after the PAL returns.
  97.     //
  98.     PalProcPlabel.ProcEntryPoint = SalSystemTable->Entry0.PalProcEntry;
  99.     PalProcPlabel.GP             = SalSystemTable->Entry0.GlobalDataPointer;
  100.     GlobalPalProc                = (CALL_PAL_PROC)PalProcPlabel.ProcEntryPoint;
  101.  
  102.     *PalEntry = PalProcPlabel.ProcEntryPoint;
  103.     *SalPlabel = SalProcPlabel;
  104. }
  105.  
  106. EFI_STATUS
  107. LibGetSalIoPortMapping (
  108.     OUT UINT64  *IoPortMapping
  109.     )
  110. /*++
  111.  
  112.   Get the IO Port Map from the SAL System Table.
  113.   DO NOT USE THIS TO DO YOU OWN IO's!!!!!!!!!!!!
  114.   Only use this for getting info, or initing the built in EFI IO abstraction.
  115.   Always use the EFI Device IO protoocl to access IO space.
  116.  
  117. --*/
  118. {
  119.     SAL_SYSTEM_TABLE_ASCENDING_ORDER    *SalSystemTable;
  120.     SAL_ST_MEMORY_DESCRIPTOR_ENTRY      *SalMemDesc;
  121.     EFI_STATUS                          Status;
  122.  
  123.     Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID **)&SalSystemTable);
  124.     if (EFI_ERROR(Status)) {
  125.         return EFI_UNSUPPORTED;
  126.     }
  127.  
  128.     //
  129.     // BugBug: Add code to test checksum on the Sal System Table
  130.     //
  131.     if (SalSystemTable->Entry0.Type != 0) {
  132.         return EFI_UNSUPPORTED;
  133.     }
  134.  
  135.     //
  136.     // The SalSystemTable pointer includes the Type 0 entry.
  137.     //  The SalMemDesc is Type 1 so it comes next.
  138.     //
  139.     SalMemDesc = (SAL_ST_MEMORY_DESCRIPTOR_ENTRY *)(SalSystemTable + 1);
  140.     while (SalMemDesc->Type == SAL_ST_MEMORY_DESCRIPTOR) {
  141.         if (SalMemDesc->MemoryType == SAL_IO_PORT_MAPPING) {
  142.             *IoPortMapping = SalMemDesc->PhysicalMemoryAddress;
  143.             return EFI_SUCCESS;
  144.         }
  145.         SalMemDesc++;
  146.    }
  147.     return EFI_UNSUPPORTED;
  148. }
  149.  
  150. EFI_STATUS
  151. LibGetSalIpiBlock (
  152.     OUT UINT64  *IpiBlock
  153.     )
  154. /*++
  155.  
  156.   Get the IPI block from the SAL system table
  157.  
  158. --*/
  159. {
  160.     SAL_SYSTEM_TABLE_ASCENDING_ORDER    *SalSystemTable;
  161.     SAL_ST_MEMORY_DESCRIPTOR_ENTRY      *SalMemDesc;
  162.     EFI_STATUS                          Status;
  163.  
  164.     Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID*)&SalSystemTable);
  165.     if (EFI_ERROR(Status)) {
  166.         return EFI_UNSUPPORTED;
  167.     }
  168.  
  169.     //
  170.     // BugBug: Add code to test checksum on the Sal System Table
  171.     //
  172.     if (SalSystemTable->Entry0.Type != 0) {
  173.         return EFI_UNSUPPORTED;
  174.     }
  175.  
  176.     //
  177.     // The SalSystemTable pointer includes the Type 0 entry.
  178.     //  The SalMemDesc is Type 1 so it comes next.
  179.     //
  180.     SalMemDesc = (SAL_ST_MEMORY_DESCRIPTOR_ENTRY *)(SalSystemTable + 1);
  181.     while (SalMemDesc->Type == SAL_ST_MEMORY_DESCRIPTOR) {
  182.         if (SalMemDesc->MemoryType == SAL_SAPIC_IPI_BLOCK ) {
  183.             *IpiBlock = SalMemDesc->PhysicalMemoryAddress;
  184.             return EFI_SUCCESS;
  185.         }
  186.         SalMemDesc++;
  187.     }
  188.     return EFI_UNSUPPORTED;
  189. }
  190.  
  191. EFI_STATUS
  192. LibGetSalWakeupVector (
  193.     OUT UINT64  *WakeVector
  194.     )
  195. /*++
  196.  
  197. Get the wakeup vector from the SAL system table
  198.  
  199. --*/
  200. {
  201.     SAL_ST_AP_WAKEUP_DECRIPTOR      *ApWakeUp;
  202.  
  203.     ApWakeUp = LibSearchSalSystemTable (SAL_ST_AP_WAKEUP);
  204.     if (!ApWakeUp) {
  205.         *WakeVector = -1;
  206.         return EFI_UNSUPPORTED;
  207.     }
  208.     *WakeVector = ApWakeUp->ExternalInterruptVector;
  209.     return EFI_SUCCESS;
  210. }
  211.  
  212. VOID *
  213. LibSearchSalSystemTable (
  214.     IN  UINT8   EntryType  
  215.     )
  216. {
  217.     EFI_STATUS                          Status;
  218.     UINT8                               *SalTableHack;
  219.     SAL_SYSTEM_TABLE_ASCENDING_ORDER    *SalSystemTable;
  220.     UINT16                              EntryCount;
  221.     UINT16                              Count;
  222.  
  223.     Status = LibGetSystemConfigurationTable(&SalSystemTableGuid, (VOID*)&SalSystemTable);
  224.     if (EFI_ERROR(Status)) {
  225.         return NULL;
  226.     }
  227.  
  228.     EntryCount = SalSystemTable->Header.EntryCount;
  229.     if (EntryCount == 0) {
  230.         return NULL;
  231.     }
  232.     //
  233.     // BugBug: Add code to test checksum on the Sal System Table
  234.     //
  235.  
  236.     SalTableHack = (UINT8 *)&SalSystemTable->Entry0;
  237.     for (Count = 0; Count < EntryCount ;Count++) {
  238.         if (*SalTableHack == EntryType) {
  239.             return (VOID *)SalTableHack;
  240.         }
  241.         switch (*SalTableHack) {
  242.         case SAL_ST_ENTRY_POINT:
  243.             SalTableHack += 48;
  244.             break;
  245.         case SAL_ST_MEMORY_DESCRIPTOR:
  246.             SalTableHack += 32;
  247.             break;
  248.         case SAL_ST_PLATFORM_FEATURES:
  249.             SalTableHack += 16;
  250.             break;
  251.         case SAL_ST_TR_USAGE:
  252.             SalTableHack += 32;
  253.             break;
  254.         case SAL_ST_PTC:
  255.             SalTableHack += 16;
  256.             break;
  257.         case SAL_ST_AP_WAKEUP:
  258.             SalTableHack += 16;
  259.             break;
  260.         default:
  261.             ASSERT(FALSE);
  262.             break;
  263.         }
  264.     }
  265.     return NULL;
  266. }
  267.  
  268. VOID
  269. LibSalProc (
  270.     IN  UINT64    Arg1,
  271.     IN  UINT64    Arg2,
  272.     IN  UINT64    Arg3,
  273.     IN  UINT64    Arg4,
  274.     IN  UINT64    Arg5,
  275.     IN  UINT64    Arg6,
  276.     IN  UINT64    Arg7,
  277.     IN  UINT64    Arg8,
  278.     OUT rArg      *Results  OPTIONAL
  279.     )
  280. {
  281.     rArg    ReturnValue;
  282.  
  283.     ReturnValue.p0 = -3;    // SAL status return completed with error
  284.     if (GlobalSalProc) {
  285.         ReturnValue = GlobalSalProc(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8);
  286.     }
  287.  
  288.     if (Results) {
  289.         CopyMem (Results, &ReturnValue, sizeof(rArg));
  290.     }
  291. }
  292.  
  293. VOID
  294. LibPalProc (
  295.     IN  UINT64    Arg1, // Pal Proc index
  296.     IN  UINT64    Arg2,
  297.     IN  UINT64    Arg3,
  298.     IN  UINT64    Arg4,
  299.     OUT rArg      *Results  OPTIONAL
  300.     )
  301. {
  302.    
  303.     rArg    ReturnValue;
  304.  
  305.     ReturnValue.p0 = -3;    // PAL status return completed with error
  306.  
  307.     //
  308.     // check for valid PalProc entry point
  309.     //
  310.    
  311.     if (!GlobalPalProc) {
  312.         if (Results)
  313.             CopyMem (Results, &ReturnValue, sizeof(rArg));
  314.         return;
  315.     }
  316.        
  317.     //
  318.     // check if index falls within stacked or static register calling conventions
  319.     // and call appropriate Pal stub call
  320.     //
  321.  
  322.     if (((Arg1 >=255) && (Arg1 <=511)) ||
  323.         ((Arg1 >=768) && (Arg1 <=1023))) {    
  324.             ReturnValue = MakeStackedPALCall((UINT64)GlobalPalProc,Arg1,Arg2,Arg3,Arg4);
  325.     }
  326.     else {
  327.         ReturnValue = MakeStaticPALCall((UINT64)GlobalPalProc,Arg1,Arg2,Arg3,Arg4);
  328.     }
  329.          
  330.     if (Results)
  331.         CopyMem (Results, &ReturnValue, sizeof(rArg));
  332.        
  333.     return;
  334. }
  335.  
  336.