ArmPlatformPkg/Bds: Make ".EFI" files recognizable as EFI applications
[mirror_edk2.git] / ArmPlatformPkg / Bds / BdsHelper.c
1 /** @file
2 *
3 * Copyright (c) 2011-2013, 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 "BdsInternal.h"
16
17 EFI_STATUS
18 EditHIInputStr (
19 IN OUT CHAR16 *CmdLine,
20 IN UINTN MaxCmdLine
21 )
22 {
23 UINTN CmdLineIndex;
24 UINTN WaitIndex;
25 CHAR8 Char;
26 EFI_INPUT_KEY Key;
27 EFI_STATUS Status;
28
29 // The command line must be at least one character long
30 ASSERT (MaxCmdLine > 0);
31
32 // Ensure the last character of the buffer is the NULL character
33 CmdLine[MaxCmdLine - 1] = '\0';
34
35 Print (CmdLine);
36
37 // To prevent a buffer overflow, we only allow to enter (MaxCmdLine-1) characters
38 for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine - 1; ) {
39 Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);
40 ASSERT_EFI_ERROR (Status);
41
42 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
43 ASSERT_EFI_ERROR (Status);
44
45 // Unicode character is valid when Scancode is NUll
46 if (Key.ScanCode == SCAN_NULL) {
47 // Scan code is NUll, hence read Unicode character
48 Char = (CHAR8)Key.UnicodeChar;
49 } else {
50 Char = CHAR_NULL;
51 }
52
53 if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {
54 CmdLine[CmdLineIndex] = '\0';
55 Print (L"\n\r");
56
57 return EFI_SUCCESS;
58 } else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
59 if (CmdLineIndex != 0) {
60 CmdLineIndex--;
61 Print (L"\b \b");
62 }
63 } else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {
64 return EFI_INVALID_PARAMETER;
65 } else {
66 CmdLine[CmdLineIndex++] = Key.UnicodeChar;
67 Print (L"%c", Key.UnicodeChar);
68 }
69 }
70
71 return EFI_SUCCESS;
72 }
73
74 EFI_STATUS
75 GetHIInputStr (
76 IN OUT CHAR16 *CmdLine,
77 IN UINTN MaxCmdLine
78 )
79 {
80 EFI_STATUS Status;
81
82 // For a new input just passed an empty string
83 CmdLine[0] = L'\0';
84
85 Status = EditHIInputStr (CmdLine, MaxCmdLine);
86
87 return Status;
88 }
89
90 EFI_STATUS
91 EditHIInputAscii (
92 IN OUT CHAR8 *CmdLine,
93 IN UINTN MaxCmdLine
94 )
95 {
96 CHAR16* Str;
97 EFI_STATUS Status;
98
99 Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));
100 AsciiStrToUnicodeStr (CmdLine, Str);
101
102 Status = EditHIInputStr (Str, MaxCmdLine);
103 if (!EFI_ERROR(Status)) {
104 UnicodeStrToAsciiStr (Str, CmdLine);
105 }
106 FreePool (Str);
107
108 return Status;
109 }
110
111 EFI_STATUS
112 GetHIInputAscii (
113 IN OUT CHAR8 *CmdLine,
114 IN UINTN MaxCmdLine
115 )
116 {
117 // For a new input just passed an empty string
118 CmdLine[0] = '\0';
119
120 return EditHIInputAscii (CmdLine,MaxCmdLine);
121 }
122
123 EFI_STATUS
124 GetHIInputInteger (
125 OUT UINTN *Integer
126 )
127 {
128 CHAR16 CmdLine[255];
129 EFI_STATUS Status;
130
131 CmdLine[0] = '\0';
132 Status = EditHIInputStr (CmdLine, 255);
133 if (!EFI_ERROR(Status)) {
134 *Integer = StrDecimalToUintn (CmdLine);
135 }
136
137 return Status;
138 }
139
140 EFI_STATUS
141 GetHIInputIP (
142 OUT EFI_IP_ADDRESS *Ip
143 )
144 {
145 CHAR16 CmdLine[255];
146 CHAR16 *Str;
147 EFI_STATUS Status;
148
149 CmdLine[0] = '\0';
150 Status = EditHIInputStr (CmdLine,255);
151 if (!EFI_ERROR(Status)) {
152 Str = CmdLine;
153 Ip->v4.Addr[0] = (UINT8)StrDecimalToUintn (Str);
154
155 Str = StrStr (Str, L".");
156 if (Str == NULL) {
157 return EFI_INVALID_PARAMETER;
158 }
159
160 Ip->v4.Addr[1] = (UINT8)StrDecimalToUintn (++Str);
161
162 Str = StrStr (Str, L".");
163 if (Str == NULL) {
164 return EFI_INVALID_PARAMETER;
165 }
166
167 Ip->v4.Addr[2] = (UINT8)StrDecimalToUintn (++Str);
168
169 Str = StrStr (Str, L".");
170 if (Str == NULL) {
171 return EFI_INVALID_PARAMETER;
172 }
173
174 Ip->v4.Addr[3] = (UINT8)StrDecimalToUintn (++Str);
175 }
176
177 return Status;
178 }
179
180 EFI_STATUS
181 GetHIInputBoolean (
182 OUT BOOLEAN *Value
183 )
184 {
185 CHAR16 CmdBoolean[2];
186 EFI_STATUS Status;
187
188 while(1) {
189 Print (L"[y/n] ");
190 Status = GetHIInputStr (CmdBoolean, 2);
191 if (EFI_ERROR(Status)) {
192 return Status;
193 } else if ((CmdBoolean[0] == L'y') || (CmdBoolean[0] == L'Y')) {
194 if (Value) *Value = TRUE;
195 return EFI_SUCCESS;
196 } else if ((CmdBoolean[0] == L'n') || (CmdBoolean[0] == L'N')) {
197 if (Value) *Value = FALSE;
198 return EFI_SUCCESS;
199 }
200 }
201 }
202
203 BOOLEAN
204 HasFilePathEfiExtension (
205 IN CHAR16* FilePath
206 )
207 {
208 return (StrCmp (FilePath + (StrSize (FilePath) / sizeof (CHAR16)) - 5, L".EFI") == 0) ||
209 (StrCmp (FilePath + (StrSize (FilePath) / sizeof (CHAR16)) - 5, L".efi") == 0);
210 }
211
212 // Return the last non end-type Device Path Node from a Device Path
213 EFI_DEVICE_PATH*
214 GetLastDevicePathNode (
215 IN EFI_DEVICE_PATH* DevicePath
216 )
217 {
218 EFI_DEVICE_PATH* PrevDevicePathNode;
219
220 PrevDevicePathNode = DevicePath;
221 while (!IsDevicePathEndType (DevicePath)) {
222 PrevDevicePathNode = DevicePath;
223 DevicePath = NextDevicePathNode (DevicePath);
224 }
225
226 return PrevDevicePathNode;
227 }
228
229 EFI_STATUS
230 GenerateDeviceDescriptionName (
231 IN EFI_HANDLE Handle,
232 IN OUT CHAR16* Description
233 )
234 {
235 EFI_STATUS Status;
236 EFI_COMPONENT_NAME_PROTOCOL* ComponentName2Protocol;
237 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
238 EFI_DEVICE_PATH_PROTOCOL* DevicePathProtocol;
239 CHAR16* DriverName;
240 CHAR16* DevicePathTxt;
241 EFI_DEVICE_PATH* DevicePathNode;
242
243 ComponentName2Protocol = NULL;
244 Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);
245 if (!EFI_ERROR(Status)) {
246 //TODO: Fixme. we must find the best langague
247 Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);
248 if (!EFI_ERROR(Status)) {
249 StrnCpy (Description, DriverName, BOOT_DEVICE_DESCRIPTION_MAX);
250 }
251 }
252
253 if (EFI_ERROR(Status)) {
254 // Use the lastest non null entry of the Device path as a description
255 Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);
256 if (EFI_ERROR(Status)) {
257 return Status;
258 }
259
260 // Convert the last non end-type Device Path Node in text for the description
261 DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);
262 Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
263 ASSERT_EFI_ERROR(Status);
264 DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePathNode, TRUE, TRUE);
265 StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);
266 FreePool (DevicePathTxt);
267 }
268
269 return EFI_SUCCESS;
270 }
271
272 EFI_STATUS
273 BdsStartBootOption (
274 IN CHAR16* BootOption
275 )
276 {
277 EFI_STATUS Status;
278 BDS_LOAD_OPTION *BdsLoadOption;
279
280 Status = BootOptionFromLoadOptionVariable (BootOption, &BdsLoadOption);
281 if (!EFI_ERROR(Status)) {
282 Status = BootOptionStart (BdsLoadOption);
283 FreePool (BdsLoadOption);
284
285 if (!EFI_ERROR(Status)) {
286 Status = EFI_SUCCESS;
287 } else {
288 Status = EFI_NOT_STARTED;
289 }
290 } else {
291 Status = EFI_NOT_FOUND;
292 }
293 return Status;
294 }
295
296 UINTN
297 GetUnalignedDevicePathSize (
298 IN EFI_DEVICE_PATH* DevicePath
299 )
300 {
301 UINTN Size;
302 EFI_DEVICE_PATH* AlignedDevicePath;
303
304 if ((UINTN)DevicePath & 0x1) {
305 AlignedDevicePath = DuplicateDevicePath (DevicePath);
306 Size = GetDevicePathSize (AlignedDevicePath);
307 FreePool (AlignedDevicePath);
308 } else {
309 Size = GetDevicePathSize (DevicePath);
310 }
311 return Size;
312 }
313
314 EFI_DEVICE_PATH*
315 GetAlignedDevicePath (
316 IN EFI_DEVICE_PATH* DevicePath
317 )
318 {
319 if ((UINTN)DevicePath & 0x1) {
320 return DuplicateDevicePath (DevicePath);
321 } else {
322 return DevicePath;
323 }
324 }
325