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
PrintHii(IN CONST CHAR8 * Language OPTIONAL,IN CONST EFI_STRING_ID HiiFormatStringId,...)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
PrintHelp(IN CONST CHAR8 * Language OPTIONAL)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
ProcessShellParameters(OUT CHAR16 ** KernelPath,OUT CHAR16 ** FdtPath,OUT CHAR16 ** InitrdPath,OUT CHAR16 ** LinuxCommandLine,OUT UINTN * AtagMachineType)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