VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/ShellPkg/Library/UefiShellDriver1CommandsLib/Connect.c@ 101283

Last change on this file since 101283 was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 16.6 KB
Line 
1/** @file
2 Main file for connect shell Driver1 function.
3
4 (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR>
5 Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
6 SPDX-License-Identifier: BSD-2-Clause-Patent
7
8**/
9
10#include "UefiShellDriver1CommandsLib.h"
11
12/**
13 Create all handles associate with every device path node.
14
15 @param DevicePathToConnect The device path which will be connected.
16
17 @retval EFI_SUCCESS All handles associate with every device path node
18 have been created.
19 @retval EFI_INVALID_PARAMETER DevicePathToConnect is NULL.
20 @retval EFI_NOT_FOUND Create the handle associate with one device path
21 node failed
22
23**/
24EFI_STATUS
25ShellConnectDevicePath (
26 IN EFI_DEVICE_PATH_PROTOCOL *DevicePathToConnect
27 )
28{
29 EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath;
30 EFI_STATUS Status;
31 EFI_HANDLE Handle;
32 EFI_HANDLE PreviousHandle;
33
34 if (DevicePathToConnect == NULL) {
35 return EFI_INVALID_PARAMETER;
36 }
37
38 PreviousHandle = NULL;
39 do {
40 RemainingDevicePath = DevicePathToConnect;
41 Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &Handle);
42
43 if (!EFI_ERROR (Status) && (Handle != NULL)) {
44 if (PreviousHandle == Handle) {
45 Status = EFI_NOT_FOUND;
46 } else {
47 PreviousHandle = Handle;
48 Status = gBS->ConnectController (Handle, NULL, RemainingDevicePath, FALSE);
49 }
50 }
51 } while (!EFI_ERROR (Status) && !IsDevicePathEnd (RemainingDevicePath));
52
53 return Status;
54}
55
56/**
57 Connect drivers for PCI root bridge.
58
59 @retval EFI_SUCCESS Connect drivers successfully.
60 @retval EFI_NOT_FOUND Cannot find PCI root bridge device.
61
62**/
63EFI_STATUS
64ShellConnectPciRootBridge (
65 VOID
66 )
67{
68 UINTN RootBridgeHandleCount;
69 EFI_HANDLE *RootBridgeHandleBuffer;
70 UINTN RootBridgeIndex;
71 EFI_STATUS Status;
72
73 RootBridgeHandleCount = 0;
74
75 Status = gBS->LocateHandleBuffer (
76 ByProtocol,
77 &gEfiPciRootBridgeIoProtocolGuid,
78 NULL,
79 &RootBridgeHandleCount,
80 &RootBridgeHandleBuffer
81 );
82 if (EFI_ERROR (Status)) {
83 return Status;
84 }
85
86 for (RootBridgeIndex = 0; RootBridgeIndex < RootBridgeHandleCount; RootBridgeIndex++) {
87 gBS->ConnectController (RootBridgeHandleBuffer[RootBridgeIndex], NULL, NULL, FALSE);
88 }
89
90 FreePool (RootBridgeHandleBuffer);
91
92 return EFI_SUCCESS;
93}
94
95/**
96 Connect controller(s) and driver(s).
97
98 @param[in] ControllerHandle The handle to the controller. Should have driver binding on it.
99 @param[in] DriverHandle The handle to the driver. Should have driver binding.
100 @param[in] Recursive TRUE to connect recursively, FALSE otherwise.
101 @param[in] Output TRUE to have info on the screen, FALSE otherwise.
102 @param[in] AlwaysOutput Override Output for errors.
103
104 @retval EFI_SUCCESS The operation was successful.
105**/
106EFI_STATUS
107ConnectControllers (
108 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,
109 IN CONST EFI_HANDLE DriverHandle OPTIONAL,
110 IN CONST BOOLEAN Recursive,
111 IN CONST BOOLEAN Output,
112 IN CONST BOOLEAN AlwaysOutput
113 )
114{
115 EFI_STATUS Status;
116 EFI_STATUS Status2;
117 EFI_HANDLE *ControllerHandleList;
118 EFI_HANDLE *DriverHandleList;
119 EFI_HANDLE *HandleWalker;
120
121 ControllerHandleList = NULL;
122 Status = EFI_NOT_FOUND;
123 Status2 = EFI_NOT_FOUND;
124
125 //
126 // If we have a single handle to connect make that a 'list'
127 //
128 if (DriverHandle == NULL) {
129 DriverHandleList = NULL;
130 } else {
131 DriverHandleList = AllocateZeroPool (2*sizeof (EFI_HANDLE));
132 if (DriverHandleList == NULL) {
133 return (EFI_OUT_OF_RESOURCES);
134 }
135
136 DriverHandleList[0] = DriverHandle;
137 DriverHandleList[1] = NULL;
138 }
139
140 //
141 // do we connect all controllers (with a loop) or a single one...
142 // This is where we call the gBS->ConnectController function.
143 //
144 if (ControllerHandle == NULL) {
145 ControllerHandleList = GetHandleListByProtocol (&gEfiDevicePathProtocolGuid);
146 for (HandleWalker = ControllerHandleList
147 ; HandleWalker != NULL && *HandleWalker != NULL
148 ; HandleWalker++
149 )
150 {
151 Status = gBS->ConnectController (*HandleWalker, DriverHandleList, NULL, Recursive);
152 if (!EFI_ERROR (Status)) {
153 Status2 = EFI_SUCCESS;
154 }
155
156 if ((Output && !EFI_ERROR (Status)) || AlwaysOutput) {
157 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Connect", ConvertHandleToHandleIndex (*HandleWalker), Status);
158 }
159 }
160 } else {
161 Status = gBS->ConnectController (ControllerHandle, DriverHandleList, NULL, Recursive);
162 if (!EFI_ERROR (Status)) {
163 Status2 = EFI_SUCCESS;
164 }
165
166 if ((Output && !EFI_ERROR (Status)) || AlwaysOutput) {
167 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HANDLE_RESULT), gShellDriver1HiiHandle, L"Connect", ConvertHandleToHandleIndex (ControllerHandle), Status);
168 }
169 }
170
171 //
172 // Free any memory we allocated.
173 //
174 if (ControllerHandleList != NULL) {
175 FreePool (ControllerHandleList);
176 }
177
178 if (DriverHandleList != NULL) {
179 FreePool (DriverHandleList);
180 }
181
182 return (Status2);
183}
184
185/**
186 Do a connect from an EFI variable via it's key name.
187
188 @param[in] Key The name of the EFI Variable.
189
190 @retval EFI_SUCCESS The operation was successful.
191**/
192EFI_STATUS
193ShellConnectFromDevPaths (
194 IN CONST CHAR16 *Key
195 )
196{
197 EFI_DEVICE_PATH_PROTOCOL *DevPath;
198 EFI_DEVICE_PATH_PROTOCOL *CopyOfDevPath;
199 EFI_DEVICE_PATH_PROTOCOL *Instance;
200 EFI_DEVICE_PATH_PROTOCOL *Next;
201 UINTN Length;
202 UINTN Index;
203 UINTN HandleArrayCount;
204 UINTN Size;
205 EFI_HANDLE *HandleArray;
206 EFI_STATUS Status;
207 BOOLEAN AtLeastOneConnected;
208 EFI_PCI_IO_PROTOCOL *PciIo;
209 UINT8 Class[3];
210
211 DevPath = NULL;
212 Length = 0;
213 AtLeastOneConnected = FALSE;
214
215 //
216 // Get the DevicePath buffer from the variable...
217 //
218 Status = gRT->GetVariable ((CHAR16 *)Key, (EFI_GUID *)&gEfiGlobalVariableGuid, NULL, &Length, DevPath);
219 if (Status == EFI_BUFFER_TOO_SMALL) {
220 DevPath = AllocateZeroPool (Length);
221 if (DevPath == NULL) {
222 return EFI_OUT_OF_RESOURCES;
223 }
224
225 Status = gRT->GetVariable ((CHAR16 *)Key, (EFI_GUID *)&gEfiGlobalVariableGuid, NULL, &Length, DevPath);
226 if (EFI_ERROR (Status)) {
227 if (DevPath != NULL) {
228 FreePool (DevPath);
229 }
230
231 return Status;
232 }
233 } else if (EFI_ERROR (Status)) {
234 return Status;
235 }
236
237 Status = EFI_NOT_FOUND;
238
239 CopyOfDevPath = DevPath;
240 //
241 // walk the list of devices and connect them
242 //
243 do {
244 //
245 // Check every instance of the console variable
246 //
247 Instance = GetNextDevicePathInstance (&CopyOfDevPath, &Size);
248 if (Instance == NULL) {
249 if (DevPath != NULL) {
250 FreePool (DevPath);
251 }
252
253 return EFI_UNSUPPORTED;
254 }
255
256 Next = Instance;
257 while (!IsDevicePathEndType (Next)) {
258 Next = NextDevicePathNode (Next);
259 }
260
261 SetDevicePathEndNode (Next);
262 //
263 // connect short form device path
264 //
265 if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&
266 ( (DevicePathSubType (Instance) == MSG_USB_CLASS_DP)
267 || (DevicePathSubType (Instance) == MSG_USB_WWID_DP)
268 ))
269 {
270 Status = ShellConnectPciRootBridge ();
271 if (EFI_ERROR (Status)) {
272 FreePool (Instance);
273 FreePool (DevPath);
274 return Status;
275 }
276
277 Status = gBS->LocateHandleBuffer (
278 ByProtocol,
279 &gEfiPciIoProtocolGuid,
280 NULL,
281 &HandleArrayCount,
282 &HandleArray
283 );
284
285 if (!EFI_ERROR (Status)) {
286 for (Index = 0; Index < HandleArrayCount; Index++) {
287 Status = gBS->HandleProtocol (
288 HandleArray[Index],
289 &gEfiPciIoProtocolGuid,
290 (VOID **)&PciIo
291 );
292
293 if (!EFI_ERROR (Status)) {
294 Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0x09, 3, &Class);
295 if (!EFI_ERROR (Status)) {
296 if ((PCI_CLASS_SERIAL == Class[2]) &&
297 (PCI_CLASS_SERIAL_USB == Class[1]))
298 {
299 Status = gBS->ConnectController (
300 HandleArray[Index],
301 NULL,
302 Instance,
303 FALSE
304 );
305 if (!EFI_ERROR (Status)) {
306 AtLeastOneConnected = TRUE;
307 }
308 }
309 }
310 }
311 }
312 }
313
314 if (HandleArray != NULL) {
315 FreePool (HandleArray);
316 }
317 } else {
318 //
319 // connect the entire device path
320 //
321 Status = ShellConnectDevicePath (Instance);
322 if (!EFI_ERROR (Status)) {
323 AtLeastOneConnected = TRUE;
324 }
325 }
326
327 FreePool (Instance);
328 } while (CopyOfDevPath != NULL);
329
330 if (DevPath != NULL) {
331 FreePool (DevPath);
332 }
333
334 if (AtLeastOneConnected) {
335 return EFI_SUCCESS;
336 } else {
337 return EFI_NOT_FOUND;
338 }
339}
340
341/**
342 Convert the handle identifiers from strings and then connect them.
343
344 One of them should have driver binding and either can be NULL.
345
346 @param[in] Handle1 The first handle.
347 @param[in] Handle2 The second handle.
348 @param[in] Recursive TRUE to do connect recursively. FALSE otherwise.
349 @param[in] Output TRUE to have output to screen. FALSE otherwise.
350
351 @retval EFI_SUCCESS The operation was successful.
352**/
353EFI_STATUS
354ConvertAndConnectControllers (
355 IN EFI_HANDLE Handle1 OPTIONAL,
356 IN EFI_HANDLE Handle2 OPTIONAL,
357 IN CONST BOOLEAN Recursive,
358 IN CONST BOOLEAN Output
359 )
360{
361 //
362 // if only one is NULL verify it's the proper one...
363 //
364 if ( ((Handle1 == NULL) && (Handle2 != NULL))
365 || ((Handle1 != NULL) && (Handle2 == NULL))
366 )
367 {
368 //
369 // Figure out which one should be NULL and move the handle to the right place.
370 // If Handle1 is NULL then test Handle2 and vise versa.
371 // The one that DOES has driver binding must be Handle2
372 //
373 if (Handle1 == NULL) {
374 if (EFI_ERROR (gBS->OpenProtocol (Handle2, &gEfiDriverBindingProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
375 // swap
376 Handle1 = Handle2;
377 Handle2 = NULL;
378 } else {
379 // We're all good...
380 }
381 } else {
382 if (EFI_ERROR (gBS->OpenProtocol (Handle1, &gEfiDriverBindingProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
383 // We're all good...
384 } else {
385 // swap
386 Handle2 = Handle1;
387 Handle1 = NULL;
388 }
389 }
390 }
391
392 return (ConnectControllers (Handle1, Handle2, Recursive, Output, (BOOLEAN)(Handle2 != NULL && Handle1 != NULL)));
393}
394
395STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
396 { L"-c", TypeFlag },
397 { L"-r", TypeFlag },
398 { NULL, TypeMax }
399};
400
401/**
402 Function for 'connect' command.
403
404 @param[in] ImageHandle Handle to the Image (NULL if Internal).
405 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
406**/
407SHELL_STATUS
408EFIAPI
409ShellCommandRunConnect (
410 IN EFI_HANDLE ImageHandle,
411 IN EFI_SYSTEM_TABLE *SystemTable
412 )
413{
414 EFI_STATUS Status;
415 LIST_ENTRY *Package;
416 CHAR16 *ProblemParam;
417 SHELL_STATUS ShellStatus;
418 CONST CHAR16 *Param1;
419 CONST CHAR16 *Param2;
420 UINTN Count;
421 EFI_HANDLE Handle1;
422 EFI_HANDLE Handle2;
423 UINT64 Intermediate;
424
425 ShellStatus = SHELL_SUCCESS;
426 //
427 // initialize the shell lib (we must be in non-auto-init...)
428 //
429 Status = ShellInitialize ();
430 ASSERT_EFI_ERROR (Status);
431
432 Status = CommandInit ();
433 ASSERT_EFI_ERROR (Status);
434
435 //
436 // parse the command line
437 //
438 Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
439 if (EFI_ERROR (Status)) {
440 if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
441 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, L"connect", ProblemParam);
442 FreePool (ProblemParam);
443 ShellStatus = SHELL_INVALID_PARAMETER;
444 } else {
445 ASSERT (FALSE);
446 }
447 } else {
448 //
449 // if more than 2 'value' parameters (plus the name one) or either -r or -c with any value parameters we have too many parameters
450 //
451 Count = (gInReconnect ? 0x4 : 0x3);
452 if ( (ShellCommandLineGetCount (Package) > Count)
453 || (ShellCommandLineGetFlag (Package, L"-c") && (ShellCommandLineGetCount (Package) > 1))
454 || (ShellCommandLineGetFlag (Package, L"-r") && (ShellCommandLineGetCount (Package) > 2))
455 || (ShellCommandLineGetFlag (Package, L"-r") && ShellCommandLineGetFlag (Package, L"-c"))
456 )
457 {
458 //
459 // error for too many parameters
460 //
461 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle, L"connect");
462 ShellStatus = SHELL_INVALID_PARAMETER;
463 } else if (ShellCommandLineGetFlag (Package, L"-c")) {
464 //
465 // do the conin and conout from EFI variables
466 // if the first fails dont 'loose' the error
467 //
468 Status = ShellConnectFromDevPaths (L"ConInDev");
469 if (EFI_ERROR (Status)) {
470 ShellConnectFromDevPaths (L"ConOutDev");
471 } else {
472 Status = ShellConnectFromDevPaths (L"ConOutDev");
473 }
474
475 if (EFI_ERROR (Status)) {
476 ShellConnectFromDevPaths (L"ErrOutDev");
477 } else {
478 Status = ShellConnectFromDevPaths (L"ErrOutDev");
479 }
480
481 if (EFI_ERROR (Status)) {
482 ShellConnectFromDevPaths (L"ErrOut");
483 } else {
484 Status = ShellConnectFromDevPaths (L"ErrOut");
485 }
486
487 if (EFI_ERROR (Status)) {
488 ShellConnectFromDevPaths (L"ConIn");
489 } else {
490 Status = ShellConnectFromDevPaths (L"ConIn");
491 }
492
493 if (EFI_ERROR (Status)) {
494 ShellConnectFromDevPaths (L"ConOut");
495 } else {
496 Status = ShellConnectFromDevPaths (L"ConOut");
497 }
498
499 if (EFI_ERROR (Status)) {
500 ShellStatus = SHELL_DEVICE_ERROR;
501 }
502 } else {
503 //
504 // 0, 1, or 2 specific handles and possibly recursive
505 //
506 Param1 = ShellCommandLineGetRawValue (Package, 1);
507 Param2 = ShellCommandLineGetRawValue (Package, 2);
508 Count = ShellCommandLineGetCount (Package);
509
510 if (Param1 != NULL) {
511 Status = ShellConvertStringToUint64 (Param1, &Intermediate, TRUE, FALSE);
512 Handle1 = ConvertHandleIndexToHandle ((UINTN)Intermediate);
513 if (EFI_ERROR (Status)) {
514 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"connect", Param1);
515 ShellStatus = SHELL_INVALID_PARAMETER;
516 }
517 } else {
518 Handle1 = NULL;
519 }
520
521 if (Param2 != NULL) {
522 Status = ShellConvertStringToUint64 (Param2, &Intermediate, TRUE, FALSE);
523 Handle2 = ConvertHandleIndexToHandle ((UINTN)Intermediate);
524 if (EFI_ERROR (Status)) {
525 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"connect", Param2);
526 ShellStatus = SHELL_INVALID_PARAMETER;
527 }
528 } else {
529 Handle2 = NULL;
530 }
531
532 if (ShellStatus == SHELL_SUCCESS) {
533 if ((Param1 != NULL) && (Handle1 == NULL)) {
534 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"connect", Param1);
535 ShellStatus = SHELL_INVALID_PARAMETER;
536 } else if ((Param2 != NULL) && (Handle2 == NULL)) {
537 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"connect", Param2);
538 ShellStatus = SHELL_INVALID_PARAMETER;
539 } else if ((Handle2 != NULL) && (Handle1 != NULL) && EFI_ERROR (gBS->OpenProtocol (Handle2, &gEfiDriverBindingProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
540 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, L"connect", Param2);
541 ShellStatus = SHELL_INVALID_PARAMETER;
542 } else {
543 Status = ConvertAndConnectControllers (Handle1, Handle2, ShellCommandLineGetFlag (Package, L"-r"), (BOOLEAN)(Count != 0));
544 if (EFI_ERROR (Status)) {
545 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_CONNECT_NONE), gShellDriver1HiiHandle);
546 ShellStatus = SHELL_DEVICE_ERROR;
547 }
548 }
549 }
550 }
551
552 ShellCommandLineFreeVarList (Package);
553 }
554
555 return (ShellStatus);
556}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette