3d618419e673dde48026be071cd1f2aca69fe876
[mirror_edk2.git] / EmbeddedPkg / Ebl / Main.c
1 /** @file
2 Basic command line parser for EBL (Embedded Boot Loader)
3
4 Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
5 Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
6
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15
16 **/
17
18 #include "Ebl.h"
19
20 // Globals for command history processing
21 INTN mCmdHistoryEnd = -1;
22 INTN mCmdHistoryStart = -1;
23 INTN mCmdHistoryCurrent = -1;
24 CHAR8 mCmdHistory[MAX_CMD_HISTORY][MAX_CMD_LINE];
25 CHAR8 *mCmdBlank = "";
26
27 // Globals to remember current screen geometry
28 UINTN gScreenColumns;
29 UINTN gScreenRows;
30
31 // Global to turn on/off breaking commands with prompts before they scroll the screen
32 BOOLEAN gPageBreak = TRUE;
33
34 VOID
35 RingBufferIncrement (
36 IN INTN *Value
37 )
38 {
39 *Value = *Value + 1;
40
41 if (*Value >= MAX_CMD_HISTORY) {
42 *Value = 0;
43 }
44 }
45
46 VOID
47 RingBufferDecrement (
48 IN INTN *Value
49 )
50 {
51 *Value = *Value - 1;
52
53 if (*Value < 0) {
54 *Value = MAX_CMD_HISTORY - 1;
55 }
56 }
57
58 /**
59 Save this command in the circular history buffer. Older commands are
60 overwritten with newer commands.
61
62 @param Cmd Command line to archive the history of.
63
64 @return None
65
66 **/
67 VOID
68 SetCmdHistory (
69 IN CHAR8 *Cmd
70 )
71 {
72 // Don't bother adding empty commands to the list
73 if (AsciiStrLen(Cmd) != 0) {
74
75 // First entry
76 if (mCmdHistoryStart == -1) {
77 mCmdHistoryStart = 0;
78 mCmdHistoryEnd = 0;
79 } else {
80 // Record the new command at the next index
81 RingBufferIncrement(&mCmdHistoryStart);
82
83 // If the next index runs into the end index, shuffle end back by one
84 if (mCmdHistoryStart == mCmdHistoryEnd) {
85 RingBufferIncrement(&mCmdHistoryEnd);
86 }
87 }
88
89 // Copy the new command line into the ring buffer
90 AsciiStrnCpy(&mCmdHistory[mCmdHistoryStart][0], Cmd, MAX_CMD_LINE);
91 }
92
93 // Reset the command history for the next up arrow press
94 mCmdHistoryCurrent = mCmdHistoryStart;
95 }
96
97
98 /**
99 Retreave data from the Command History buffer. Direction maps into up arrow
100 an down arrow on the command line
101
102 @param Direction Command forward or back
103
104 @return The Command history based on the Direction
105
106 **/
107 CHAR8 *
108 GetCmdHistory (
109 IN UINT16 Direction
110 )
111 {
112 CHAR8 *HistoricalCommand = NULL;
113
114 // No history yet?
115 if (mCmdHistoryCurrent == -1) {
116 HistoricalCommand = mCmdBlank;
117 goto Exit;
118 }
119
120 if (Direction == SCAN_UP) {
121 HistoricalCommand = &mCmdHistory[mCmdHistoryCurrent][0];
122
123 // if we just echoed the last command, hang out there, don't wrap around
124 if (mCmdHistoryCurrent == mCmdHistoryEnd) {
125 goto Exit;
126 }
127
128 // otherwise, back up by one
129 RingBufferDecrement(&mCmdHistoryCurrent);
130
131 } else if (Direction == SCAN_DOWN) {
132
133 // if we last echoed the start command, put a blank prompt out
134 if (mCmdHistoryCurrent == mCmdHistoryStart) {
135 HistoricalCommand = mCmdBlank;
136 goto Exit;
137 }
138
139 // otherwise increment the current pointer and return that command
140 RingBufferIncrement(&mCmdHistoryCurrent);
141 RingBufferIncrement(&mCmdHistoryCurrent);
142
143 HistoricalCommand = &mCmdHistory[mCmdHistoryCurrent][0];
144 RingBufferDecrement(&mCmdHistoryCurrent);
145 }
146
147 Exit:
148 return HistoricalCommand;
149 }
150
151
152 /**
153 Parse the CmdLine and break it up into Argc (arg count) and Argv (array of
154 pointers to each argument). The Cmd buffer is altered and seperators are
155 converted to string terminators. This allows Argv to point into CmdLine.
156 A CmdLine can support multiple commands. The next command in the command line
157 is returned if it exists.
158
159 @param CmdLine String to parse for a set of commands
160 @param Argc Returns the number of arguments in the CmdLine current command
161 @param Argv Argc pointers to each string in CmdLine
162
163 @return Next Command in the command line or NULL if non exists
164 **/
165 CHAR8 *
166 ParseArguments (
167 IN CHAR8 *CmdLine,
168 OUT UINTN *Argc,
169 OUT CHAR8 **Argv
170 )
171 {
172 UINTN Arg;
173 CHAR8 *Char;
174 BOOLEAN LookingForArg;
175 BOOLEAN InQuote;
176
177 *Argc = 0;
178 if (AsciiStrLen (CmdLine) == 0) {
179 return NULL;
180 }
181
182 // Walk a single command line. A CMD_SEPERATOR allows mult commands on a single line
183 InQuote = FALSE;
184 LookingForArg = TRUE;
185 for (Char = CmdLine, Arg = 0; *Char != '\0'; Char++) {
186 if (!InQuote && *Char == CMD_SEPERATOR) {
187 break;
188 }
189
190 // Perform any text conversion here
191 if (*Char == '\t') {
192 // TAB to space
193 *Char = ' ';
194 }
195
196 if (LookingForArg) {
197 // Look for the beging of an Argv[] entry
198 if (*Char == '"') {
199 Argv[Arg++] = ++Char;
200 LookingForArg = FALSE;
201 InQuote = TRUE;
202 } else if (*Char != ' ') {
203 Argv[Arg++] = Char;
204 LookingForArg = FALSE;
205 }
206 } else {
207 // Looking for the terminator of an Argv[] entry
208 if (!InQuote && (*Char == ' ')) {
209 *Char = '\0';
210 LookingForArg = TRUE;
211 } else if (!InQuote && (*Char == '"') && (*(Char-1) != '\\')) {
212 InQuote = TRUE;
213 } else if (InQuote && (*Char == '"') && (*(Char-1) != '\\')) {
214 *Char = '\0';
215 InQuote = FALSE;
216 }
217 }
218 }
219
220 *Argc = Arg;
221
222 if (*Char == CMD_SEPERATOR) {
223 // Replace the command delimeter with null and return pointer to next command line
224 *Char = '\0';
225 return ++Char;
226 }
227
228 return NULL;
229 }
230
231
232 /**
233 Return a keypress or optionally timeout if a timeout value was passed in.
234 An optional callback funciton is called evey second when waiting for a
235 timeout.
236
237 @param Key EFI Key information returned
238 @param TimeoutInSec Number of seconds to wait to timeout
239 @param CallBack Callback called every second during the timeout wait
240
241 @return EFI_SUCCESS Key was returned
242 @return EFI_TIMEOUT If the TimoutInSec expired
243
244 **/
245 EFI_STATUS
246 EblGetCharKey (
247 IN OUT EFI_INPUT_KEY *Key,
248 IN UINTN TimeoutInSec,
249 IN EBL_GET_CHAR_CALL_BACK CallBack OPTIONAL
250 )
251 {
252 EFI_STATUS Status;
253 UINTN WaitCount;
254 UINTN WaitIndex;
255 EFI_EVENT WaitList[2];
256
257 WaitCount = 1;
258 WaitList[0] = gST->ConIn->WaitForKey;
259 if (TimeoutInSec != 0) {
260 // Create a time event for 1 sec duration if we have a timeout
261 gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[1]);
262 gBS->SetTimer (WaitList[1], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
263 WaitCount++;
264 }
265
266 for (;;) {
267 Status = gBS->WaitForEvent (WaitCount, WaitList, &WaitIndex);
268 ASSERT_EFI_ERROR (Status);
269
270 switch (WaitIndex) {
271 case 0:
272 // Key event signaled
273 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, Key);
274 if (!EFI_ERROR (Status)) {
275 if (WaitCount == 2) {
276 gBS->CloseEvent (WaitList[1]);
277 }
278 return EFI_SUCCESS;
279 }
280 break;
281
282 case 1:
283 // Periodic 1 sec timer signaled
284 TimeoutInSec--;
285 if (CallBack != NULL) {
286 // Call the users callback function if registered
287 CallBack (TimeoutInSec);
288 }
289 if (TimeoutInSec == 0) {
290 gBS->CloseEvent (WaitList[1]);
291 return EFI_TIMEOUT;
292 }
293 break;
294 default:
295 ASSERT (FALSE);
296 }
297 }
298 }
299
300
301 /**
302 This routine is used prevent command output data from scrolling off the end
303 of the screen. The global gPageBreak is used to turn on or off this feature.
304 If the CurrentRow is near the end of the screen pause and print out a prompt
305 If the use hits Q to quit return TRUE else for any other key return FALSE.
306 PrefixNewline is used to figure out if a newline is needed before the prompt
307 string. This depends on the last print done before calling this function.
308 CurrentRow is updated by one on a call or set back to zero if a prompt is
309 needed.
310
311 @param CurrentRow Used to figure out if its the end of the page and updated
312 @param PrefixNewline Did previous print issue a newline
313
314 @return TRUE if Q was hit to quit, FALSE in all other cases.
315
316 **/
317 BOOLEAN
318 EblAnyKeyToContinueQtoQuit (
319 IN UINTN *CurrentRow,
320 IN BOOLEAN PrefixNewline
321 )
322 {
323 EFI_INPUT_KEY InputKey;
324
325 if (!gPageBreak) {
326 // global disable for this feature
327 return FALSE;
328 }
329
330 if (*CurrentRow >= (gScreenRows - 2)) {
331 if (PrefixNewline) {
332 AsciiPrint ("\n");
333 }
334 AsciiPrint ("Any key to continue (Q to quit): ");
335 EblGetCharKey (&InputKey, 0, NULL);
336 AsciiPrint ("\n");
337
338 // Time to promt to stop the screen. We have to leave space for the prompt string
339 *CurrentRow = 0;
340 if (InputKey.UnicodeChar == 'Q' || InputKey.UnicodeChar == 'q') {
341 return TRUE;
342 }
343 } else {
344 *CurrentRow += 1;
345 }
346
347 return FALSE;
348 }
349
350
351 /**
352 Set the text color of the EFI Console. If a zero is passed in reset to
353 default text/background color.
354
355 @param Attribute For text and background color
356
357 **/
358 VOID
359 EblSetTextColor (
360 UINTN Attribute
361 )
362 {
363 if (Attribute == 0) {
364 // Set the text color back to default
365 Attribute = (UINTN)PcdGet32 (PcdEmbeddedDefaultTextColor);
366 }
367
368 gST->ConOut->SetAttribute (gST->ConOut, Attribute);
369 }
370
371
372 /**
373 Collect the keyboard input for a cmd line. Carage Return, New Line, or ESC
374 terminates the command line. You can edit the command line via left arrow,
375 delete and backspace and they all back up and erase the command line.
376 No edit of commnad line is possible without deletion at this time!
377 The up arrow and down arrow fill Cmd with information from the history
378 buffer.
379
380 @param Cmd Command line to return
381 @param CmdMaxSize Maximum size of Cmd
382
383 @return The Status of EblGetCharKey()
384
385 **/
386 EFI_STATUS
387 GetCmd (
388 IN OUT CHAR8 *Cmd,
389 IN UINTN CmdMaxSize
390 )
391 {
392 EFI_STATUS Status;
393 UINTN Index;
394 UINTN Index2;
395 CHAR8 Char;
396 CHAR8 *History;
397 EFI_INPUT_KEY Key;
398
399 for (Index = 0; Index < CmdMaxSize - 1;) {
400 Status = EblGetCharKey (&Key, 0, NULL);
401 if (EFI_ERROR (Status)) {
402 Cmd[Index] = '\0';
403 AsciiPrint ("\n");
404 return Status;
405 }
406
407 Char = (CHAR8)Key.UnicodeChar;
408 if ((Char == '\n') || (Char == '\r') || (Char == 0x7f)) {
409 Cmd[Index] = '\0';
410 if (FixedPcdGetBool(PcdEmbeddedShellCharacterEcho) == TRUE) {
411 AsciiPrint ("\n\r");
412 }
413 return EFI_SUCCESS;
414 } else if ((Char == '\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
415 if (Index != 0) {
416 Index--;
417 //
418 // Update the display
419 //
420 AsciiPrint ("\b \b");
421 }
422 } else if ((Key.ScanCode == SCAN_UP) || Key.ScanCode == SCAN_DOWN) {
423 History = GetCmdHistory (Key.ScanCode);
424 //
425 // Clear display line
426 //
427 for (Index2 = 0; Index2 < Index; Index2++) {
428 AsciiPrint ("\b \b");
429 }
430 AsciiPrint (History);
431 Index = AsciiStrLen (History);
432 AsciiStrnCpy (Cmd, History, CmdMaxSize);
433 } else {
434 Cmd[Index++] = Char;
435 if (FixedPcdGetBool(PcdEmbeddedShellCharacterEcho) == TRUE) {
436 AsciiPrint ("%c", Char);
437 }
438 }
439 }
440
441 return EFI_SUCCESS;
442 }
443
444
445 /**
446 Print the boot up banner for the EBL.
447 **/
448 VOID
449 EblPrintStartupBanner (
450 VOID
451 )
452 {
453 AsciiPrint ("Embedded Boot Loader (");
454 EblSetTextColor (EFI_YELLOW);
455 AsciiPrint ("EBL");
456 EblSetTextColor (0);
457 AsciiPrint (") prototype. Built at %a on %a\n",__TIME__, __DATE__);
458 AsciiPrint ("THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN 'AS IS' BASIS,\nWITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\n");
459 AsciiPrint ("Please send feedback to edk2-devel@lists.sourceforge.net\n");
460 }
461
462
463 /**
464 Send null requests to all removable media block IO devices so the a media add/remove/change
465 can be detected in real before we execute a command.
466
467 This is mainly due to the fact that the FAT driver does not do this today so you can get stale
468 dir commands after an SD Card has been removed.
469 **/
470 VOID
471 EblProbeRemovableMedia (
472 VOID
473 )
474 {
475 UINTN Index;
476 UINTN Max;
477 EFI_OPEN_FILE *File;
478
479 //
480 // Probe for media insertion/removal in removable media devices
481 //
482 Max = EfiGetDeviceCounts (EfiOpenBlockIo);
483 if (Max != 0) {
484 for (Index = 0; Index < Max; Index++) {
485 File = EfiDeviceOpenByType (EfiOpenBlockIo, Index);
486 if (File != NULL) {
487 if (File->FsBlockIoMedia->RemovableMedia) {
488 // Probe to see if media is present (or not) or media changed
489 // this causes the ReinstallProtocolInterface() to fire in the
490 // block io driver to update the system about media change events
491 File->FsBlockIo->ReadBlocks (File->FsBlockIo, File->FsBlockIo->Media->MediaId, (EFI_LBA)0, 0, NULL);
492 }
493 EfiClose (File);
494 }
495 }
496 }
497 }
498
499
500
501
502 /**
503 Print the prompt for the EBL.
504 **/
505 VOID
506 EblPrompt (
507 VOID
508 )
509 {
510 EblSetTextColor (EFI_YELLOW);
511 AsciiPrint ("%a %a",(CHAR8 *)PcdGetPtr (PcdEmbeddedPrompt), EfiGetCwd ());
512 EblSetTextColor (0);
513 AsciiPrint ("%a", ">");
514 }
515
516
517
518 /**
519 Parse a command line and execute the commands. The ; seperator allows
520 multiple commands for each command line. Stop processing if one of the
521 commands returns an error.
522
523 @param CmdLine Command Line to process.
524 @param MaxCmdLineSize MaxSize of the Command line
525
526 @return EFI status of the Command
527
528 **/
529 EFI_STATUS
530 ProcessCmdLine (
531 IN CHAR8 *CmdLine,
532 IN UINTN MaxCmdLineSize
533 )
534 {
535 EFI_STATUS Status;
536 EBL_COMMAND_TABLE *Cmd;
537 CHAR8 *Ptr;
538 UINTN Argc;
539 CHAR8 *Argv[MAX_ARGS];
540
541 // Parse the command line. The loop processes commands seperated by ;
542 for (Ptr = CmdLine, Status = EFI_SUCCESS; Ptr != NULL;) {
543 Ptr = ParseArguments (Ptr, &Argc, Argv);
544 if (Argc != 0) {
545 Cmd = EblGetCommand (Argv[0]);
546 if (Cmd != NULL) {
547 // Execute the Command!
548 Status = Cmd->Command (Argc, Argv);
549 if (Status == EFI_ABORTED) {
550 // exit command so lets exit
551 break;
552 } else if (Status == EFI_TIMEOUT) {
553 // pause command got imput so don't process any more cmd on this cmd line
554 break;
555 } else if (EFI_ERROR (Status)) {
556 AsciiPrint ("%a returned %r error\n", Cmd->Name, Status);
557 // if any command fails stop processing CmdLine
558 break;
559 }
560 }
561 }
562 }
563
564 return Status;
565 }
566
567
568
569 /**
570 Embedded Boot Loader (EBL) - A simple EFI command line application for embedded
571 devices. PcdEmbeddedAutomaticBootCommand is a complied in commnad line that
572 gets executed automatically. The ; seperator allows multiple commands
573 for each command line.
574
575 @param ImageHandle EFI ImageHandle for this application.
576 @param SystemTable EFI system table
577
578 @return EFI status of the applicaiton
579
580 **/
581 EFI_STATUS
582 EFIAPI
583 EdkBootLoaderEntry (
584 IN EFI_HANDLE ImageHandle,
585 IN EFI_SYSTEM_TABLE *SystemTable
586 )
587 {
588 EFI_STATUS Status;
589 CHAR8 CmdLine[MAX_CMD_LINE];
590 CHAR16 *CommandLineVariable = NULL;
591 CHAR16 *CommandLineVariableName = L"default-cmdline";
592 UINTN CommandLineVariableSize = 0;
593 EFI_GUID VendorGuid;
594
595 // Initialize tables of commnads
596 EblInitializeCmdTable ();
597 EblInitializeDeviceCmd ();
598 EblInitializemdHwDebugCmds ();
599 EblInitializemdHwIoDebugCmds ();
600 EblInitializeDirCmd ();
601 EblInitializeHobCmd ();
602 EblInitializeScriptCmd ();
603 EblInitializeExternalCmd ();
604 EblInitializeNetworkCmd();
605 EblInitializeVariableCmds ();
606
607 if (gST->ConOut == NULL) {
608 DEBUG((EFI_D_ERROR,"Errot: No Console Output\n"));
609 return EFI_NOT_READY;
610 }
611
612 // Disable the 5 minute EFI watchdog time so we don't get automatically reset
613 gBS->SetWatchdogTimer (0, 0, 0, NULL);
614
615 if (FeaturePcdGet (PcdEmbeddedMacBoot)) {
616 // A MAC will boot in graphics mode, so turn it back to text here
617 // This protocol was removed from edk2. It is only an edk thing. We need to make our own copy.
618 // DisableQuietBoot ();
619
620 // Enable the biggest output screen size possible
621 gST->ConOut->SetMode (gST->ConOut, (UINTN)gST->ConOut->Mode->MaxMode - 1);
622
623 }
624
625 // Save current screen mode
626 gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &gScreenColumns, &gScreenRows);
627
628 EblPrintStartupBanner ();
629
630 // Parse command line and handle commands seperated by ;
631 // The loop prints the prompt gets user input and saves history
632
633 // Look for a variable with a default command line, otherwise use the Pcd
634 ZeroMem(&VendorGuid, sizeof(EFI_GUID));
635
636 Status = gRT->GetVariable(CommandLineVariableName, &VendorGuid, NULL, &CommandLineVariableSize, CommandLineVariable);
637 if (Status == EFI_BUFFER_TOO_SMALL) {
638 CommandLineVariable = AllocatePool(CommandLineVariableSize);
639
640 Status = gRT->GetVariable(CommandLineVariableName, &VendorGuid, NULL, &CommandLineVariableSize, CommandLineVariable);
641 if (!EFI_ERROR(Status)) {
642 UnicodeStrToAsciiStr(CommandLineVariable, CmdLine);
643 }
644
645 FreePool(CommandLineVariable);
646 }
647
648 if (EFI_ERROR(Status)) {
649 AsciiStrCpy (CmdLine, (CHAR8 *)PcdGetPtr (PcdEmbeddedAutomaticBootCommand));
650 }
651
652 for (;;) {
653 Status = ProcessCmdLine (CmdLine, MAX_CMD_LINE);
654 if (Status == EFI_ABORTED) {
655 // if a command returns EFI_ABORTED then exit the EBL
656 EblShutdownExternalCmdTable ();
657 return EFI_SUCCESS;
658 }
659
660 // get the command line from the user
661 EblPrompt ();
662 GetCmd (CmdLine, MAX_CMD_LINE);
663 SetCmdHistory (CmdLine);
664
665 if (FeaturePcdGet (PcdEmbeddedProbeRemovable)) {
666 // Probe removable media devices to see if media has been inserted or removed.
667 EblProbeRemovableMedia ();
668 }
669 }
670 }
671
672