MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDriver.c

   1 /** @file
   2   The driver binding for UEFI PXEBC protocol.
   3
   4 Copyright (c) 2007 - 2009, Intel Corporation.<BR>
   5 All rights reserved. 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
  16 #include "PxeBcImpl.h"
  17
  18 EFI_DRIVER_BINDING_PROTOCOL gPxeBcDriverBinding = {
  19   PxeBcDriverBindingSupported,
  20   PxeBcDriverBindingStart,
  21   PxeBcDriverBindingStop,
  22   0xa,
  23   NULL,
  24   NULL
  25 };
  26
  27 /**
  28   This is the declaration of an EFI image entry point. This entry point is
  29   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
  30   both device drivers and bus drivers.
  31
  32   @param  ImageHandle           The firmware allocated handle for the UEFI image.
  33   @param  SystemTable           A pointer to the EFI System Table.
  34
  35   @retval EFI_SUCCESS           The operation completed successfully.
  36   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  37
  38 **/
  39 EFI_STATUS
  40 EFIAPI
  41 PxeBcDriverEntryPoint (
  42   IN EFI_HANDLE             ImageHandle,
  43   IN EFI_SYSTEM_TABLE       *SystemTable
  44   )
  45 {
  46   return EfiLibInstallDriverBindingComponentName2 (
  47           ImageHandle,
  48           SystemTable,
  49           &gPxeBcDriverBinding,
  50           ImageHandle,
  51           &gPxeBcComponentName,
  52           &gPxeBcComponentName2
  53           );
  54 }
  55
  56
  57 /**
  58   Test to see if this driver supports ControllerHandle. This service
  59   is called by the EFI boot service ConnectController(). In
  60   order to make drivers as small as possible, there are a few calling
  61   restrictions for this service. ConnectController() must
  62   follow these calling restrictions. If any other agent wishes to call
  63   Supported() it must also follow these calling restrictions.
  64   PxeBc requires DHCP4 and MTFTP4 protocols.
  65
  66   @param  This                Protocol instance pointer.
  67   @param  ControllerHandle    Handle of device to test
  68   @param  RemainingDevicePath Optional parameter use to pick a specific child
  69                               device to start.
  70
  71   @retval EFI_SUCCESS         This driver supports this device
  72   @retval EFI_ALREADY_STARTED This driver is already running on this device
  73   @retval other               This driver does not support this device
  74
  75 **/
  76 EFI_STATUS
  77 EFIAPI
  78 PxeBcDriverBindingSupported (
  79   IN EFI_DRIVER_BINDING_PROTOCOL  * This,
  80   IN EFI_HANDLE                   ControllerHandle,
  81   IN EFI_DEVICE_PATH_PROTOCOL     * RemainingDevicePath OPTIONAL
  82   )
  83 {
  84   EFI_PXE_BASE_CODE_PROTOCOL  *PxeBc;
  85   EFI_STATUS                  Status;
  86
  87   Status = gBS->OpenProtocol (
  88                   ControllerHandle,
  89                   &gEfiPxeBaseCodeProtocolGuid,
  90                   (VOID **) &PxeBc,
  91                   This->DriverBindingHandle,
  92                   ControllerHandle,
  93                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
  94                   );
  95
  96   if (!EFI_ERROR (Status)) {
  97     return EFI_ALREADY_STARTED;
  98   }
  99
 100   Status = gBS->OpenProtocol (
 101                   ControllerHandle,
 102                   &gEfiDhcp4ServiceBindingProtocolGuid,
 103                   NULL,
 104                   This->DriverBindingHandle,
 105                   ControllerHandle,
 106                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 107                   );
 108
 109   if (!EFI_ERROR (Status)) {
 110
 111     Status = gBS->OpenProtocol (
 112                     ControllerHandle,
 113                     &gEfiMtftp4ServiceBindingProtocolGuid,
 114                     NULL,
 115                     This->DriverBindingHandle,
 116                     ControllerHandle,
 117                     EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 118                     );
 119
 120   }
 121
 122   return Status;
 123 }
 124
 125
 126 /**
 127   Start this driver on ControllerHandle. This service is called by the
 128   EFI boot service ConnectController(). In order to make
 129   drivers as small as possible, there are a few calling restrictions for
 130   this service. ConnectController() must follow these
 131   calling restrictions. If any other agent wishes to call Start() it
 132   must also follow these calling restrictions.
 133
 134   @param  This                 Protocol instance pointer.
 135   @param  ControllerHandle     Handle of device to bind driver to
 136   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 137                                device to start.
 138
 139   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 140   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
 141   @retval other                This driver does not support this device
 142
 143 **/
 144 EFI_STATUS
 145 EFIAPI
 146 PxeBcDriverBindingStart (
 147   IN EFI_DRIVER_BINDING_PROTOCOL  * This,
 148   IN EFI_HANDLE                   ControllerHandle,
 149   IN EFI_DEVICE_PATH_PROTOCOL     * RemainingDevicePath OPTIONAL
 150   )
 151 {
 152   PXEBC_PRIVATE_DATA  *Private;
 153   UINTN               Index;
 154   EFI_STATUS          Status;
 155
 156   Private = AllocateZeroPool (sizeof (PXEBC_PRIVATE_DATA));
 157   if (Private == NULL) {
 158     return EFI_OUT_OF_RESOURCES;
 159   }
 160
 161   Private->Signature                    = PXEBC_PRIVATE_DATA_SIGNATURE;
 162   Private->Controller                   = ControllerHandle;
 163   Private->Image                        = This->DriverBindingHandle;
 164   CopyMem (&Private->PxeBc, &mPxeBcProtocolTemplate, sizeof (Private->PxeBc));
 165   Private->PxeBc.Mode                   = &Private->Mode;
 166   CopyMem (&Private->LoadFile, &mLoadFileProtocolTemplate, sizeof (Private->LoadFile));
 167
 168   Private->ProxyOffer.Packet.Offer.Size = PXEBC_CACHED_DHCP4_PACKET_MAX_SIZE;
 169   Private->Dhcp4Ack.Packet.Ack.Size     = PXEBC_CACHED_DHCP4_PACKET_MAX_SIZE;
 170   Private->PxeReply.Packet.Ack.Size     = PXEBC_CACHED_DHCP4_PACKET_MAX_SIZE;
 171
 172   for (Index = 0; Index < PXEBC_MAX_OFFER_NUM; Index++) {
 173     Private->Dhcp4Offers[Index].Packet.Offer.Size = PXEBC_CACHED_DHCP4_PACKET_MAX_SIZE;
 174   }
 175
 176   //
 177   // Get the NII interface
 178   //
 179   Status = gBS->OpenProtocol (
 180                   ControllerHandle,
 181                   &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 182                   (VOID **) &Private->Nii,
 183                   This->DriverBindingHandle,
 184                   ControllerHandle,
 185                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 186                   );
 187   if (EFI_ERROR (Status)) {
 188     goto ON_ERROR;
 189   }
 190
 191   Status = NetLibCreateServiceChild (
 192             ControllerHandle,
 193             This->DriverBindingHandle,
 194             &gEfiArpServiceBindingProtocolGuid,
 195             &Private->ArpChild
 196             );
 197   if (EFI_ERROR (Status)) {
 198     goto ON_ERROR;
 199   }
 200
 201   Status = gBS->OpenProtocol (
 202                   Private->ArpChild,
 203                   &gEfiArpProtocolGuid,
 204                   (VOID **) &Private->Arp,
 205                   This->DriverBindingHandle,
 206                   ControllerHandle,
 207                   EFI_OPEN_PROTOCOL_BY_DRIVER
 208                   );
 209   if (EFI_ERROR (Status)) {
 210     goto ON_ERROR;
 211   }
 212
 213   Status = NetLibCreateServiceChild (
 214             ControllerHandle,
 215             This->DriverBindingHandle,
 216             &gEfiDhcp4ServiceBindingProtocolGuid,
 217             &Private->Dhcp4Child
 218             );
 219   if (EFI_ERROR (Status)) {
 220     goto ON_ERROR;
 221   }
 222
 223   Status = gBS->OpenProtocol (
 224                   Private->Dhcp4Child,
 225                   &gEfiDhcp4ProtocolGuid,
 226                   (VOID **) &Private->Dhcp4,
 227                   This->DriverBindingHandle,
 228                   ControllerHandle,
 229                   EFI_OPEN_PROTOCOL_BY_DRIVER
 230                   );
 231   if (EFI_ERROR (Status)) {
 232     goto ON_ERROR;
 233   }
 234
 235   Status = NetLibCreateServiceChild (
 236              ControllerHandle,
 237              This->DriverBindingHandle,
 238              &gEfiIp4ServiceBindingProtocolGuid,
 239              &Private->Ip4Child
 240              );
 241   if (EFI_ERROR (Status)) {
 242     goto ON_ERROR;
 243   }
 244
 245   Status = gBS->OpenProtocol (
 246                   Private->Ip4Child,
 247                   &gEfiIp4ProtocolGuid,
 248                   (VOID **) &Private->Ip4,
 249                   This->DriverBindingHandle,
 250                   ControllerHandle,
 251                   EFI_OPEN_PROTOCOL_BY_DRIVER
 252                   );
 253   if (EFI_ERROR (Status)) {
 254     goto ON_ERROR;
 255   }
 256
 257   Status = NetLibCreateServiceChild (
 258              ControllerHandle,
 259              This->DriverBindingHandle,
 260              &gEfiMtftp4ServiceBindingProtocolGuid,
 261              &Private->Mtftp4Child
 262              );
 263
 264   if (EFI_ERROR (Status)) {
 265     goto ON_ERROR;
 266   }
 267
 268   Status = gBS->OpenProtocol (
 269                   Private->Mtftp4Child,
 270                   &gEfiMtftp4ProtocolGuid,
 271                   (VOID **) &Private->Mtftp4,
 272                   This->DriverBindingHandle,
 273                   ControllerHandle,
 274                   EFI_OPEN_PROTOCOL_BY_DRIVER
 275                   );
 276
 277   if (EFI_ERROR (Status)) {
 278     goto ON_ERROR;
 279   }
 280
 281   Status = NetLibCreateServiceChild (
 282              ControllerHandle,
 283              This->DriverBindingHandle,
 284              &gEfiUdp4ServiceBindingProtocolGuid,
 285              &Private->Udp4ReadChild
 286              );
 287
 288   if (EFI_ERROR (Status)) {
 289     goto ON_ERROR;
 290   }
 291
 292   //
 293   // The UDP instance for EfiPxeBcUdpRead
 294   //
 295   Status = gBS->OpenProtocol (
 296                   Private->Udp4ReadChild,
 297                   &gEfiUdp4ProtocolGuid,
 298                   (VOID **) &Private->Udp4Read,
 299                   This->DriverBindingHandle,
 300                   ControllerHandle,
 301                   EFI_OPEN_PROTOCOL_BY_DRIVER
 302                   );
 303
 304   if (EFI_ERROR (Status)) {
 305     goto ON_ERROR;
 306   }
 307
 308   //
 309   // The UDP instance for EfiPxeBcUdpWrite
 310   //
 311   Status = NetLibCreateServiceChild (
 312              ControllerHandle,
 313              This->DriverBindingHandle,
 314              &gEfiUdp4ServiceBindingProtocolGuid,
 315              &Private->Udp4WriteChild
 316              );
 317   if (EFI_ERROR (Status)) {
 318     goto ON_ERROR;
 319   }
 320
 321   Status = gBS->OpenProtocol (
 322                   Private->Udp4WriteChild,
 323                   &gEfiUdp4ProtocolGuid,
 324                   (VOID **) &Private->Udp4Write,
 325                   This->DriverBindingHandle,
 326                   ControllerHandle,
 327                   EFI_OPEN_PROTOCOL_BY_DRIVER
 328                   );
 329   if (EFI_ERROR (Status)) {
 330     goto ON_ERROR;
 331   }
 332   ZeroMem (&Private->Udp4CfgData, sizeof (EFI_UDP4_CONFIG_DATA));
 333   Private->Udp4CfgData.AcceptBroadcast    = TRUE;
 334   Private->Udp4CfgData.AcceptPromiscuous  = FALSE;
 335   Private->Udp4CfgData.AcceptAnyPort      = TRUE;
 336   Private->Udp4CfgData.AllowDuplicatePort = TRUE;
 337   Private->Udp4CfgData.TypeOfService      = DEFAULT_ToS;
 338   Private->Udp4CfgData.TimeToLive         = DEFAULT_TTL;
 339   Private->Udp4CfgData.DoNotFragment      = FALSE;
 340   Private->Udp4CfgData.ReceiveTimeout     = 50000;  // 50 milliseconds
 341   Private->Udp4CfgData.UseDefaultAddress  = FALSE;
 342
 343   PxeBcInitSeedPacket (&Private->SeedPacket, Private->Udp4Read);
 344   Private->MacLen = Private->SeedPacket.Dhcp4.Header.HwAddrLen;
 345   CopyMem (&Private->Mac, &Private->SeedPacket.Dhcp4.Header.ClientHwAddr[0], Private->MacLen);
 346
 347
 348   ZeroMem (&Private->Ip4ConfigData, sizeof (EFI_IP4_CONFIG_DATA));
 349   Private->Ip4ConfigData.DefaultProtocol   = EFI_IP_PROTO_ICMP;
 350   Private->Ip4ConfigData.AcceptIcmpErrors  = TRUE;
 351   Private->Ip4ConfigData.TypeOfService     = DEFAULT_ToS;
 352   Private->Ip4ConfigData.TimeToLive        = DEFAULT_TTL;
 353   Private->Ip4ConfigData.DoNotFragment     = FALSE;
 354   Private->Ip4ConfigData.RawData           = FALSE;
 355
 356   Status = gBS->InstallMultipleProtocolInterfaces (
 357                   &ControllerHandle,
 358                   &gEfiPxeBaseCodeProtocolGuid,
 359                   &Private->PxeBc,
 360                   &gEfiLoadFileProtocolGuid,
 361                   &Private->LoadFile,
 362                   NULL
 363                   );
 364   if (EFI_ERROR (Status)) {
 365     goto ON_ERROR;
 366   }
 367
 368   return EFI_SUCCESS;
 369
 370 ON_ERROR:
 371
 372   if (Private->Udp4WriteChild != NULL) {
 373     gBS->CloseProtocol (
 374            Private->Udp4WriteChild,
 375            &gEfiUdp4ProtocolGuid,
 376            This->DriverBindingHandle,
 377            ControllerHandle
 378            );
 379     NetLibDestroyServiceChild (
 380       ControllerHandle,
 381       This->DriverBindingHandle,
 382       &gEfiUdp4ServiceBindingProtocolGuid,
 383       Private->Udp4WriteChild
 384       );
 385   }
 386
 387   if (Private->Udp4ReadChild != NULL) {
 388     gBS->CloseProtocol (
 389           Private->Udp4ReadChild,
 390           &gEfiUdp4ProtocolGuid,
 391           This->DriverBindingHandle,
 392           ControllerHandle
 393           );
 394     NetLibDestroyServiceChild (
 395       ControllerHandle,
 396       This->DriverBindingHandle,
 397       &gEfiUdp4ServiceBindingProtocolGuid,
 398       Private->Udp4ReadChild
 399       );
 400   }
 401
 402   if (Private->Mtftp4Child != NULL) {
 403     gBS->CloseProtocol (
 404           Private->Mtftp4Child,
 405           &gEfiMtftp4ProtocolGuid,
 406           This->DriverBindingHandle,
 407           ControllerHandle
 408           );
 409
 410     NetLibDestroyServiceChild (
 411       ControllerHandle,
 412       This->DriverBindingHandle,
 413       &gEfiMtftp4ServiceBindingProtocolGuid,
 414       Private->Mtftp4Child
 415       );
 416   }
 417
 418   if (Private->Ip4Child != NULL) {
 419     gBS->CloseProtocol (
 420           Private->Ip4Child,
 421           &gEfiIp4ProtocolGuid,
 422           This->DriverBindingHandle,
 423           ControllerHandle
 424           );
 425
 426     NetLibDestroyServiceChild (
 427       ControllerHandle,
 428       This->DriverBindingHandle,
 429       &gEfiIp4ServiceBindingProtocolGuid,
 430       Private->Ip4Child
 431       );
 432   }
 433
 434   if (Private->Dhcp4Child != NULL) {
 435     gBS->CloseProtocol (
 436           Private->Dhcp4Child,
 437           &gEfiDhcp4ProtocolGuid,
 438           This->DriverBindingHandle,
 439           ControllerHandle
 440           );
 441
 442     NetLibDestroyServiceChild (
 443       ControllerHandle,
 444       This->DriverBindingHandle,
 445       &gEfiDhcp4ServiceBindingProtocolGuid,
 446       Private->Dhcp4Child
 447       );
 448   }
 449
 450   if (Private->ArpChild != NULL) {
 451     gBS->CloseProtocol (
 452           Private->ArpChild,
 453           &gEfiArpProtocolGuid,
 454           This->DriverBindingHandle,
 455           ControllerHandle
 456           );
 457
 458     NetLibDestroyServiceChild (
 459       ControllerHandle,
 460       This->DriverBindingHandle,
 461       &gEfiArpServiceBindingProtocolGuid,
 462       Private->ArpChild
 463       );
 464   }
 465
 466   gBS->FreePool (Private);
 467
 468   return Status;
 469 }
 470
 471
 472 /**
 473   Stop this driver on ControllerHandle. This service is called by the
 474   EFI boot service DisconnectController(). In order to
 475   make drivers as small as possible, there are a few calling
 476   restrictions for this service. DisconnectController()
 477   must follow these calling restrictions. If any other agent wishes
 478   to call Stop() it must also follow these calling restrictions.
 479
 480   @param  This              Protocol instance pointer.
 481   @param  ControllerHandle  Handle of device to stop driver on
 482   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 483                             children is zero stop the entire bus driver.
 484   @param  ChildHandleBuffer List of Child Handles to Stop.
 485
 486   @retval EFI_SUCCESS       This driver is removed ControllerHandle
 487   @retval other             This driver was not removed from this device
 488
 489 **/
 490 EFI_STATUS
 491 EFIAPI
 492 PxeBcDriverBindingStop (
 493   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 494   IN EFI_HANDLE                   ControllerHandle,
 495   IN UINTN                        NumberOfChildren,
 496   IN EFI_HANDLE                   *ChildHandleBuffer
 497   )
 498 {
 499   PXEBC_PRIVATE_DATA          *Private;
 500   EFI_PXE_BASE_CODE_PROTOCOL  *PxeBc;
 501   EFI_HANDLE                  NicHandle;
 502   EFI_STATUS                  Status;
 503
 504   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
 505   if (NicHandle == NULL) {
 506     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp4ProtocolGuid);
 507
 508     if (NicHandle == NULL) {
 509       NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
 510
 511       if (NicHandle == NULL) {
 512         NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp4ProtocolGuid);
 513
 514         if (NicHandle == NULL) {
 515           NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiMtftp4ProtocolGuid);
 516
 517           if (NicHandle == NULL) {
 518             return EFI_DEVICE_ERROR;
 519           }
 520         }
 521       }
 522     }
 523   }
 524
 525   Status = gBS->OpenProtocol (
 526                   NicHandle,
 527                   &gEfiPxeBaseCodeProtocolGuid,
 528                   (VOID **) &PxeBc,
 529                   This->DriverBindingHandle,
 530                   ControllerHandle,
 531                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 532                   );
 533
 534   if (EFI_ERROR (Status)) {
 535     return Status;
 536   }
 537
 538   Private = PXEBC_PRIVATE_DATA_FROM_PXEBC (PxeBc);
 539
 540   Status = gBS->UninstallMultipleProtocolInterfaces (
 541                   NicHandle,
 542                   &gEfiPxeBaseCodeProtocolGuid,
 543                   &Private->PxeBc,
 544                   &gEfiLoadFileProtocolGuid,
 545                   &Private->LoadFile,
 546                   NULL
 547                   );
 548
 549   if (!EFI_ERROR (Status)) {
 550
 551     gBS->CloseProtocol (
 552            Private->Udp4WriteChild,
 553            &gEfiUdp4ProtocolGuid,
 554            This->DriverBindingHandle,
 555            NicHandle
 556            );
 557     NetLibDestroyServiceChild (
 558       ControllerHandle,
 559       This->DriverBindingHandle,
 560       &gEfiUdp4ServiceBindingProtocolGuid,
 561       Private->Udp4WriteChild
 562       );
 563
 564     gBS->CloseProtocol (
 565           Private->Udp4ReadChild,
 566           &gEfiUdp4ProtocolGuid,
 567           This->DriverBindingHandle,
 568           NicHandle
 569           );
 570     NetLibDestroyServiceChild (
 571       NicHandle,
 572       This->DriverBindingHandle,
 573       &gEfiUdp4ServiceBindingProtocolGuid,
 574       Private->Udp4ReadChild
 575       );
 576
 577     gBS->CloseProtocol (
 578           Private->Dhcp4Child,
 579           &gEfiDhcp4ProtocolGuid,
 580           This->DriverBindingHandle,
 581           NicHandle
 582           );
 583     NetLibDestroyServiceChild (
 584       NicHandle,
 585       This->DriverBindingHandle,
 586       &gEfiDhcp4ServiceBindingProtocolGuid,
 587       Private->Dhcp4Child
 588       );
 589
 590     gBS->CloseProtocol (
 591           Private->Mtftp4Child,
 592           &gEfiMtftp4ProtocolGuid,
 593           This->DriverBindingHandle,
 594           NicHandle
 595           );
 596     NetLibDestroyServiceChild (
 597       NicHandle,
 598       This->DriverBindingHandle,
 599       &gEfiMtftp4ServiceBindingProtocolGuid,
 600       Private->Mtftp4Child
 601       );
 602
 603     gBS->CloseProtocol (
 604           Private->Ip4Child,
 605           &gEfiIp4ProtocolGuid,
 606           This->DriverBindingHandle,
 607           NicHandle
 608           );
 609     NetLibDestroyServiceChild (
 610       NicHandle,
 611       This->DriverBindingHandle,
 612       &gEfiIp4ServiceBindingProtocolGuid,
 613       Private->Ip4Child
 614       );
 615
 616     gBS->CloseProtocol (
 617           Private->ArpChild,
 618           &gEfiArpProtocolGuid,
 619           This->DriverBindingHandle,
 620           NicHandle
 621           );
 622     NetLibDestroyServiceChild (
 623       NicHandle,
 624       This->DriverBindingHandle,
 625       &gEfiArpServiceBindingProtocolGuid,
 626       Private->ArpChild
 627       );
 628
 629     gBS->FreePool (Private);
 630   }
 631
 632   return Status;
 633 }
 634
 635