ShellPkg/Library/UefiShellDriver1CommandsLib/Connect.c

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