]> git.proxmox.com Git - mirror_edk2.git/blob - ArmPlatformPkg/Bds/BdsHelper.c
ArmPkg/ArmLib: Removed ArmInvalidateTlb when disabling cache as ArmDisableMmu() alrea...
[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 }
210
211 // Return the last non end-type Device Path Node from a Device Path
212 EFI_DEVICE_PATH*
213 GetLastDevicePathNode (
214 IN EFI_DEVICE_PATH* DevicePath
215 )
216 {
217 EFI_DEVICE_PATH* PrevDevicePathNode;
218
219 PrevDevicePathNode = DevicePath;
220 while (!IsDevicePathEndType (DevicePath)) {
221 PrevDevicePathNode = DevicePath;
222 DevicePath = NextDevicePathNode (DevicePath);
223 }
224
225 return PrevDevicePathNode;
226 }
227
228 EFI_STATUS
229 GenerateDeviceDescriptionName (
230 IN EFI_HANDLE Handle,
231 IN OUT CHAR16* Description
232 )
233 {
234 EFI_STATUS Status;
235 EFI_COMPONENT_NAME_PROTOCOL* ComponentName2Protocol;
236 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
237 EFI_DEVICE_PATH_PROTOCOL* DevicePathProtocol;
238 CHAR16* DriverName;
239 CHAR16* DevicePathTxt;
240 EFI_DEVICE_PATH* DevicePathNode;
241
242 ComponentName2Protocol = NULL;
243 Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);
244 if (!EFI_ERROR(Status)) {
245 //TODO: Fixme. we must find the best langague
246 Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);
247 if (!EFI_ERROR(Status)) {
248 StrnCpy (Description, DriverName, BOOT_DEVICE_DESCRIPTION_MAX);
249 }
250 }
251
252 if (EFI_ERROR(Status)) {
253 // Use the lastest non null entry of the Device path as a description
254 Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);
255 if (EFI_ERROR(Status)) {
256 return Status;
257 }
258
259 // Convert the last non end-type Device Path Node in text for the description
260 DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);
261 Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
262 ASSERT_EFI_ERROR(Status);
263 DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePathNode, TRUE, TRUE);
264 StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);
265 FreePool (DevicePathTxt);
266 }
267
268 return EFI_SUCCESS;
269 }
270
271 EFI_STATUS
272 BdsStartBootOption (
273 IN CHAR16* BootOption
274 )
275 {
276 EFI_STATUS Status;
277 BDS_LOAD_OPTION *BdsLoadOption;
278
279 Status = BootOptionFromLoadOptionVariable (BootOption, &BdsLoadOption);
280 if (!EFI_ERROR(Status)) {
281 Status = BootOptionStart (BdsLoadOption);
282 FreePool (BdsLoadOption);
283
284 if (!EFI_ERROR(Status)) {
285 Status = EFI_SUCCESS;
286 } else {
287 Status = EFI_NOT_STARTED;
288 }
289 } else {
290 Status = EFI_NOT_FOUND;
291 }
292 return Status;
293 }
294
295 UINTN
296 GetUnalignedDevicePathSize (
297 IN EFI_DEVICE_PATH* DevicePath
298 )
299 {
300 UINTN Size;
301 EFI_DEVICE_PATH* AlignedDevicePath;
302
303 if ((UINTN)DevicePath & 0x1) {
304 AlignedDevicePath = DuplicateDevicePath (DevicePath);
305 Size = GetDevicePathSize (AlignedDevicePath);
306 FreePool (AlignedDevicePath);
307 } else {
308 Size = GetDevicePathSize (DevicePath);
309 }
310 return Size;
311 }
312
313 EFI_DEVICE_PATH*
314 GetAlignedDevicePath (
315 IN EFI_DEVICE_PATH* DevicePath
316 )
317 {
318 if ((UINTN)DevicePath & 0x1) {
319 return DuplicateDevicePath (DevicePath);
320 } else {
321 return DevicePath;
322 }
323 }
324