1 /** @file 2 * 3 * Copyright (c) 2011-2015, ARM Limited. All rights reserved. 4 * 5 * This program and the accompanying materials 6 * are licensed and made available under the terms and conditions of the BSD License 7 * which accompanies this distribution. The full text of the license may be found at 8 * http://opensource.org/licenses/bsd-license.php 9 * 10 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 * 13 **/ 14 15 #include "LinuxLoader.h" 16 17 // 18 // Internal variables 19 // 20 21 CONST EFI_GUID mLinuxLoaderHiiGuid = { 22 0xd5d16edc, 0x35c5, 0x4866, 23 {0xbd, 0xe5, 0x2b, 0x64, 0xa2, 0x26, 0x55, 0x6e} 24 }; 25 EFI_HANDLE mLinuxLoaderHiiHandle; 26 27 STATIC CONST SHELL_PARAM_ITEM ParamList[] = { 28 {L"-f", TypeValue}, 29 {L"-d", TypeValue}, 30 {L"-c", TypeValue}, 31 {L"-a", TypeValue}, 32 {NULL , TypeMax } 33 }; 34 35 /** 36 Print a string given the "HII Id" of the format string and a list of 37 arguments. 38 39 @param[in] Language The language of the string to retrieve. If 40 this parameter is NULL, then the current 41 platform language is used. 42 @param[in] HiiFormatStringId The format string Id for getting from Hii. 43 @param[in] ... The variable argument list. 44 45 @retval EFI_SUCCESS The printing was successful. 46 @retval EFI_OUT_OF_RESOURCES A memory allocation failed. 47 48 **/ 49 EFI_STATUS 50 PrintHii ( 51 IN CONST CHAR8 *Language OPTIONAL, 52 IN CONST EFI_STRING_ID HiiFormatStringId, 53 ... 54 ) 55 { 56 VA_LIST Marker; 57 CHAR16 *HiiFormatString; 58 CHAR16 Buffer[MAX_MSG_LEN]; 59 60 VA_START (Marker, HiiFormatStringId); 61 62 HiiFormatString = HiiGetString (mLinuxLoaderHiiHandle, HiiFormatStringId, Language); 63 if (HiiFormatString != NULL) { 64 UnicodeVSPrint (Buffer, sizeof (Buffer), HiiFormatString, Marker); 65 Print (L"%s", Buffer); 66 FreePool (HiiFormatString); 67 } else { 68 ASSERT (FALSE); 69 return EFI_OUT_OF_RESOURCES; 70 } 71 72 VA_END (Marker); 73 74 return EFI_SUCCESS; 75 } 76 77 /** 78 Print the help. 79 80 @param[in] Language The language of the string to retrieve. If this 81 parameter is NULL, then the current platform 82 language is used. 83 **/ 84 VOID 85 PrintHelp ( 86 IN CONST CHAR8 *Language OPTIONAL 87 ) 88 { 89 CHAR16 *Help; 90 CHAR16 *Walker; 91 CHAR16 *LineEnd; 92 93 // 94 // Print the help line by line as it is too big to be printed at once. 95 // 96 97 Help = HiiGetString (mLinuxLoaderHiiHandle, STRING_TOKEN (STR_HELP), Language); 98 if (Help != NULL) { 99 Walker = Help; 100 while (*Walker != L'\0') { 101 LineEnd = StrStr (Walker, L"\r\n"); 102 if (LineEnd != NULL) { 103 *LineEnd = L'\0'; 104 } 105 Print (L"%s\r\n", Walker); 106 if (LineEnd == NULL) { 107 break; 108 } 109 Walker = LineEnd + 2; 110 } 111 FreePool (Help); 112 } 113 114 } 115 116 /** 117 Process the Shell parameters in the case the application has been called 118 from the EFI Shell. 119 120 @param[out] KernelPath A pointer to the buffer where the path 121 to the Linux kernel (EFI Shell file path 122 or device path is stored. The address of 123 the buffer is NULL in case of an error. 124 Otherwise, the returned address is the 125 address of a buffer allocated with 126 a call to AllocatePool() that has to be 127 freed by the caller. 128 @param[out] FdtPath A pointer to the buffer where the path 129 to the FDT (EFI Shell file path or 130 device path) is stored. The address of 131 the buffer is NULL in case of an error or 132 if the path to the FDT is not defined. 133 Otherwise, the returned address is the 134 address of a buffer allocated with a call 135 to AllocatePool() that has to be freed by 136 the caller. 137 @param[out] InitrdPath A pointer to the buffer where the path 138 (EFI Shell file path or device path) 139 to the RAM root file system is stored. 140 The address of the buffer is NULL in case 141 of an error or if the path to the RAM root 142 file system is not defined. Otherwise, the 143 returned address is the address of a 144 buffer allocated with a call to 145 AllocatePool() that has to be freed by 146 the caller. 147 @param[out] LinuxCommandLine A pointer to the buffer where the Linux 148 kernel command line is stored. The address 149 of the buffer is NULL in case of an error 150 or if the Linux command line is not 151 defined. Otherwise, the returned address 152 is the address of a buffer allocated with 153 a call to AllocatePool() that has to be 154 freed by the caller. 155 @param[out] AtagMachineType Value of the ARM Machine Type 156 157 @retval EFI_SUCCESS The processing was successfull. 158 @retval EFI_ABORTED The initialisation of the Shell Library failed. 159 @retval EFI_NOT_FOUND Path to the Linux kernel not found. 160 @retval EFI_INVALID_PARAMETER At least one parameter is not valid or there is a 161 conflict between two parameters. 162 @retval EFI_OUT_OF_RESOURCES A memory allocation failed. 163 164 **/ 165 EFI_STATUS 166 ProcessShellParameters ( 167 OUT CHAR16 **KernelPath, 168 OUT CHAR16 **FdtPath, 169 OUT CHAR16 **InitrdPath, 170 OUT CHAR16 **LinuxCommandLine, 171 OUT UINTN *AtagMachineType 172 ) 173 { 174 EFI_STATUS Status; 175 LIST_ENTRY *CheckPackage; 176 CHAR16 *ProblemParam; 177 CONST CHAR16 *FlagValue; 178 CONST CHAR16 *ParameterValue; 179 UINTN LinuxCommandLineLen; 180 181 182 *KernelPath = NULL; 183 *FdtPath = NULL; 184 *InitrdPath = NULL; 185 *LinuxCommandLine = NULL; 186 *AtagMachineType = ARM_FDT_MACHINE_TYPE; 187 188 // 189 // Initialise the Shell Library as we are going to use it. 190 // Assert that the return code is EFI_SUCCESS as it should. 191 // To anticipate any change is the codes returned by 192 // ShellInitialize(), leave in case of error. 193 // 194 Status = ShellInitialize (); 195 if (EFI_ERROR (Status)) { 196 ASSERT_EFI_ERROR (Status); 197 return EFI_ABORTED; 198 } 199 200 Status = ShellCommandLineParse (ParamList, &CheckPackage, &ProblemParam, TRUE); 201 if (EFI_ERROR (Status)) { 202 if ((Status == EFI_VOLUME_CORRUPTED) && 203 (ProblemParam != NULL) ) { 204 PrintHii ( 205 NULL, STRING_TOKEN (STR_SHELL_INVALID_PARAMETER), ProblemParam 206 ); 207 FreePool (ProblemParam); 208 } else { 209 ASSERT (FALSE); 210 } 211 goto Error; 212 } 213 214 Status = EFI_INVALID_PARAMETER; 215 if (ShellCommandLineGetCount (CheckPackage) != 2) { 216 PrintHelp (NULL); 217 goto Error; 218 } 219 220 Status = EFI_OUT_OF_RESOURCES; 221 222 FlagValue = ShellCommandLineGetValue (CheckPackage, L"-a"); 223 if (FlagValue != NULL) { 224 if (ShellCommandLineGetFlag (CheckPackage, L"-d")) { 225 PrintHii (NULL, STRING_TOKEN (STR_ATAG_FDT_CONFLICT)); 226 goto Error; 227 } 228 *AtagMachineType = StrDecimalToUintn (FlagValue); 229 } 230 231 ParameterValue = ShellCommandLineGetRawValue (CheckPackage, 1); 232 *KernelPath = AllocateCopyPool (StrSize (ParameterValue), ParameterValue); 233 if (*KernelPath == NULL) { 234 goto Error; 235 } 236 237 FlagValue = ShellCommandLineGetValue (CheckPackage, L"-d"); 238 if (FlagValue != NULL) { 239 *FdtPath = AllocateCopyPool (StrSize (FlagValue), FlagValue); 240 if (*FdtPath == NULL) { 241 goto Error; 242 } 243 } 244 245 FlagValue = ShellCommandLineGetValue (CheckPackage, L"-f"); 246 if (FlagValue != NULL) { 247 *InitrdPath = AllocateCopyPool (StrSize (FlagValue), FlagValue); 248 if (*InitrdPath == NULL) { 249 goto Error; 250 } 251 } 252 253 FlagValue = ShellCommandLineGetValue (CheckPackage, L"-c"); 254 if (FlagValue != NULL) { 255 LinuxCommandLineLen = StrLen (FlagValue); 256 if ((LinuxCommandLineLen != 0) && 257 (FlagValue[0] == L'"' ) && 258 (FlagValue[LinuxCommandLineLen - 1] == L'"')) { 259 FlagValue++; 260 LinuxCommandLineLen -= 2; 261 } 262 263 *LinuxCommandLine = AllocateCopyPool ( 264 (LinuxCommandLineLen + 1) * sizeof (CHAR16), 265 FlagValue 266 ); 267 if (*LinuxCommandLine == NULL) { 268 goto Error; 269 } 270 (*LinuxCommandLine)[LinuxCommandLineLen] = L'\0'; 271 } 272 273 Status = EFI_SUCCESS; 274 275 Error: 276 ShellCommandLineFreeVarList (CheckPackage); 277 278 if (EFI_ERROR (Status)) { 279 if (*KernelPath != NULL) { 280 FreePool (*KernelPath); 281 *KernelPath = NULL; 282 } 283 if (*FdtPath != NULL) { 284 FreePool (*FdtPath); 285 *FdtPath = NULL; 286 } 287 if (*InitrdPath != NULL) { 288 FreePool (*InitrdPath); 289 *InitrdPath = NULL; 290 } 291 if (*LinuxCommandLine != NULL) { 292 FreePool (*LinuxCommandLine); 293 *LinuxCommandLine = NULL; 294 } 295 } 296 297 return Status; 298 } 299