MdeModulePkg/Universal/Network/SnpDxe/Snp.c

   1 /** @file
   2   Implementation of driver entry point and driver binding protocol.
   3
   4 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials are licensed
   6 and made available under the terms and conditions of the BSD License which
   7 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 "Snp.h"
  16
  17 /**
  18   One notified function to stop UNDI device when gBS->ExitBootServices() called.
  19
  20   @param  Event                   Pointer to this event
  21   @param  Context                 Event handler private data
  22
  23 **/
  24 VOID
  25 EFIAPI
  26 SnpNotifyExitBootServices (
  27   EFI_EVENT Event,
  28   VOID      *Context
  29   )
  30 {
  31   SNP_DRIVER             *Snp;
  32
  33   Snp  = (SNP_DRIVER *)Context;
  34
  35   //
  36   // Shutdown and stop UNDI driver
  37   //
  38   PxeShutdown (Snp);
  39   PxeStop (Snp);
  40 }
  41
  42 /**
  43   Send command to UNDI. It does nothing currently.
  44
  45   @param Cdb   command to be sent to UNDI.
  46
  47   @retval EFI_INVALID_PARAMETER  The command is 0.
  48   @retval EFI_UNSUPPORTED        Default return status because it's not
  49                                  supported currently.
  50
  51 **/
  52 EFI_STATUS
  53 EFIAPI
  54 IssueHwUndiCommand (
  55   UINT64 Cdb
  56   )
  57 {
  58   DEBUG ((EFI_D_ERROR, "\nIssueHwUndiCommand() - This should not be called!"));
  59
  60   if (Cdb == 0) {
  61     return EFI_INVALID_PARAMETER;
  62
  63   }
  64   //
  65   //  %%TBD - For now, nothing is done.
  66   //
  67   return EFI_UNSUPPORTED;
  68 }
  69
  70
  71 /**
  72   Compute 8-bit checksum of a buffer.
  73
  74   @param  Buffer               Pointer to buffer.
  75   @param  Length               Length of buffer in bytes.
  76
  77   @return 8-bit checksum of all bytes in buffer, or zero if ptr is NULL or len
  78           is zero.
  79
  80 **/
  81 UINT8
  82 Calc8BitCksum (
  83   VOID  *Buffer,
  84   UINTN Length
  85   )
  86 {
  87   UINT8 *Ptr;
  88   UINT8 Cksum;
  89
  90   Ptr   = Buffer;
  91   Cksum = 0;
  92
  93   if (Ptr == NULL || Length == 0) {
  94     return 0;
  95   }
  96
  97   while (Length-- != 0) {
  98     Cksum = (UINT8) (Cksum + *Ptr++);
  99   }
 100
 101   return Cksum;
 102 }
 103
 104 /**
 105   Test to see if this driver supports ControllerHandle. This service
 106   is called by the EFI boot service ConnectController(). In
 107   order to make drivers as small as possible, there are a few calling
 108   restrictions for this service. ConnectController() must
 109   follow these calling restrictions. If any other agent wishes to call
 110   Supported() it must also follow these calling restrictions.
 111
 112   @param  This                Protocol instance pointer.
 113   @param  ControllerHandle    Handle of device to test.
 114   @param  RemainingDevicePath Optional parameter use to pick a specific child
 115                               device to start.
 116
 117   @retval EFI_SUCCESS         This driver supports this device.
 118   @retval EFI_ALREADY_STARTED This driver is already running on this device.
 119   @retval other               This driver does not support this device.
 120
 121 **/
 122 EFI_STATUS
 123 EFIAPI
 124 SimpleNetworkDriverSupported (
 125   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 126   IN EFI_HANDLE                     Controller,
 127   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 128   )
 129 {
 130   EFI_STATUS                                Status;
 131   EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *NiiProtocol;
 132   PXE_UNDI                                  *Pxe;
 133
 134   Status = gBS->OpenProtocol (
 135                   Controller,
 136                   &gEfiDevicePathProtocolGuid,
 137                   NULL,
 138                   This->DriverBindingHandle,
 139                   Controller,
 140                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 141                   );
 142   if (EFI_ERROR (Status)) {
 143     return Status;
 144   }
 145
 146   Status = gBS->OpenProtocol (
 147                   Controller,
 148                   &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 149                   (VOID **) &NiiProtocol,
 150                   This->DriverBindingHandle,
 151                   Controller,
 152                   EFI_OPEN_PROTOCOL_BY_DRIVER
 153                   );
 154
 155   if (EFI_ERROR (Status)) {
 156     if (Status == EFI_ALREADY_STARTED) {
 157       DEBUG ((EFI_D_INFO, "Support(): Already Started. on handle %p\n", Controller));
 158     }
 159     return Status;
 160   }
 161
 162   DEBUG ((EFI_D_INFO, "Support(): UNDI3.1 found on handle %p\n", Controller));
 163
 164   //
 165   // check the version, we don't want to connect to the undi16
 166   //
 167   if (NiiProtocol->Type != EfiNetworkInterfaceUndi) {
 168     Status = EFI_UNSUPPORTED;
 169     goto Done;
 170   }
 171   //
 172   // Check to see if !PXE structure is valid. Paragraph alignment of !PXE structure is required.
 173   //
 174   if ((NiiProtocol->Id & 0x0F) != 0) {
 175     DEBUG ((EFI_D_NET, "\n!PXE structure is not paragraph aligned.\n"));
 176     Status = EFI_UNSUPPORTED;
 177     goto Done;
 178   }
 179
 180   Pxe = (PXE_UNDI *) (UINTN) (NiiProtocol->Id);
 181
 182   //
 183   //  Verify !PXE revisions.
 184   //
 185   if (Pxe->hw.Signature != PXE_ROMID_SIGNATURE) {
 186     DEBUG ((EFI_D_NET, "\n!PXE signature is not valid.\n"));
 187     Status = EFI_UNSUPPORTED;
 188     goto Done;
 189   }
 190
 191   if (Pxe->hw.Rev < PXE_ROMID_REV) {
 192     DEBUG ((EFI_D_NET, "\n!PXE.Rev is not supported.\n"));
 193     Status = EFI_UNSUPPORTED;
 194     goto Done;
 195   }
 196
 197   if (Pxe->hw.MajorVer < PXE_ROMID_MAJORVER) {
 198
 199     DEBUG ((EFI_D_NET, "\n!PXE.MajorVer is not supported.\n"));
 200     Status = EFI_UNSUPPORTED;
 201     goto Done;
 202
 203   } else if (Pxe->hw.MajorVer == PXE_ROMID_MAJORVER && Pxe->hw.MinorVer < PXE_ROMID_MINORVER) {
 204     DEBUG ((EFI_D_NET, "\n!PXE.MinorVer is not supported."));
 205     Status = EFI_UNSUPPORTED;
 206     goto Done;
 207   }
 208   //
 209   // Do S/W UNDI specific checks.
 210   //
 211   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_HW_UNDI) == 0) {
 212     if (Pxe->sw.EntryPoint < Pxe->sw.Len) {
 213       DEBUG ((EFI_D_NET, "\n!PXE S/W entry point is not valid."));
 214       Status = EFI_UNSUPPORTED;
 215       goto Done;
 216     }
 217
 218     if (Pxe->sw.BusCnt == 0) {
 219       DEBUG ((EFI_D_NET, "\n!PXE.BusCnt is zero."));
 220       Status = EFI_UNSUPPORTED;
 221       goto Done;
 222     }
 223   }
 224
 225   Status = EFI_SUCCESS;
 226   DEBUG ((EFI_D_INFO, "Support(): supported on %p\n", Controller));
 227
 228 Done:
 229   gBS->CloseProtocol (
 230         Controller,
 231         &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 232         This->DriverBindingHandle,
 233         Controller
 234         );
 235
 236   return Status;
 237 }
 238
 239 /**
 240   Start this driver on ControllerHandle. This service is called by the
 241   EFI boot service ConnectController(). In order to make
 242   drivers as small as possible, there are a few calling restrictions for
 243   this service. ConnectController() must follow these
 244   calling restrictions. If any other agent wishes to call Start() it
 245   must also follow these calling restrictions.
 246
 247   @param  This                 Protocol instance pointer.
 248   @param  ControllerHandle     Handle of device to bind driver to.
 249   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 250                                device to start.
 251
 252   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 253   @retval EFI_DEVICE_ERROR     This driver could not be started due to a device error
 254   @retval other                This driver does not support this device
 255
 256 **/
 257 EFI_STATUS
 258 EFIAPI
 259 SimpleNetworkDriverStart (
 260   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 261   IN EFI_HANDLE                     Controller,
 262   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 263   )
 264 {
 265   EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *Nii;
 266   EFI_DEVICE_PATH_PROTOCOL                  *NiiDevicePath;
 267   EFI_STATUS                                Status;
 268   PXE_UNDI                                  *Pxe;
 269   SNP_DRIVER                                *Snp;
 270   VOID                                      *Address;
 271   EFI_HANDLE                                Handle;
 272   UINT8                                     BarIndex;
 273   PXE_STATFLAGS                             InitStatFlags;
 274   EFI_PCI_IO_PROTOCOL                       *PciIo;
 275   EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR         *BarDesc;
 276   BOOLEAN                                   FoundIoBar;
 277   BOOLEAN                                   FoundMemoryBar;
 278
 279   DEBUG ((EFI_D_NET, "\nSnpNotifyNetworkInterfaceIdentifier()  "));
 280
 281   Status = gBS->OpenProtocol (
 282                   Controller,
 283                   &gEfiDevicePathProtocolGuid,
 284                   (VOID **) &NiiDevicePath,
 285                   This->DriverBindingHandle,
 286                   Controller,
 287                   EFI_OPEN_PROTOCOL_BY_DRIVER
 288                   );
 289
 290   if (EFI_ERROR (Status)) {
 291     return Status;
 292   }
 293
 294   Status = gBS->LocateDevicePath (
 295                   &gEfiPciIoProtocolGuid,
 296                   &NiiDevicePath,
 297                   &Handle
 298                   );
 299
 300   if (EFI_ERROR (Status)) {
 301     return Status;
 302   }
 303
 304   Status = gBS->OpenProtocol (
 305                   Handle,
 306                   &gEfiPciIoProtocolGuid,
 307                   (VOID **) &PciIo,
 308                   This->DriverBindingHandle,
 309                   Controller,
 310                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 311                   );
 312   if (EFI_ERROR (Status)) {
 313     return Status;
 314   }
 315   //
 316   // Get the NII interface.
 317   //
 318   Status = gBS->OpenProtocol (
 319                   Controller,
 320                   &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 321                   (VOID **) &Nii,
 322                   This->DriverBindingHandle,
 323                   Controller,
 324                   EFI_OPEN_PROTOCOL_BY_DRIVER
 325                   );
 326   if (EFI_ERROR (Status)) {
 327     gBS->CloseProtocol (
 328           Controller,
 329           &gEfiDevicePathProtocolGuid,
 330           This->DriverBindingHandle,
 331           Controller
 332           );
 333     return Status;
 334   }
 335
 336   DEBUG ((EFI_D_INFO, "Start(): UNDI3.1 found\n"));
 337
 338   Pxe = (PXE_UNDI *) (UINTN) (Nii->Id);
 339
 340   if (Calc8BitCksum (Pxe, Pxe->hw.Len) != 0) {
 341     DEBUG ((EFI_D_NET, "\n!PXE checksum is not correct.\n"));
 342     goto NiiError;
 343   }
 344
 345   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED) != 0) {
 346     //
 347     //  We can get any packets.
 348     //
 349   } else if ((Pxe->hw.Implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED) != 0) {
 350     //
 351     //  We need to be able to get broadcast packets for DHCP.
 352     //  If we do not have promiscuous support, we must at least have
 353     //  broadcast support or we cannot do DHCP!
 354     //
 355   } else {
 356     DEBUG ((EFI_D_NET, "\nUNDI does not have promiscuous or broadcast support."));
 357     goto NiiError;
 358   }
 359   //
 360   // OK, we like this UNDI, and we know snp is not already there on this handle
 361   // Allocate and initialize a new simple network protocol structure.
 362   //
 363   Status = PciIo->AllocateBuffer (
 364                     PciIo,
 365                     AllocateAnyPages,
 366                     EfiBootServicesData,
 367                     SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
 368                     &Address,
 369                     0
 370                     );
 371
 372   if (Status != EFI_SUCCESS) {
 373     DEBUG ((EFI_D_NET, "\nCould not allocate SNP_DRIVER structure.\n"));
 374     goto NiiError;
 375   }
 376
 377   Snp = (SNP_DRIVER *) (UINTN) Address;
 378
 379   ZeroMem (Snp, sizeof (SNP_DRIVER));
 380
 381   Snp->PciIo      = PciIo;
 382   Snp->Signature  = SNP_DRIVER_SIGNATURE;
 383
 384   EfiInitializeLock (&Snp->Lock, TPL_NOTIFY);
 385
 386   Snp->Snp.Revision       = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION;
 387   Snp->Snp.Start          = SnpUndi32Start;
 388   Snp->Snp.Stop           = SnpUndi32Stop;
 389   Snp->Snp.Initialize     = SnpUndi32Initialize;
 390   Snp->Snp.Reset          = SnpUndi32Reset;
 391   Snp->Snp.Shutdown       = SnpUndi32Shutdown;
 392   Snp->Snp.ReceiveFilters = SnpUndi32ReceiveFilters;
 393   Snp->Snp.StationAddress = SnpUndi32StationAddress;
 394   Snp->Snp.Statistics     = SnpUndi32Statistics;
 395   Snp->Snp.MCastIpToMac   = SnpUndi32McastIpToMac;
 396   Snp->Snp.NvData         = SnpUndi32NvData;
 397   Snp->Snp.GetStatus      = SnpUndi32GetStatus;
 398   Snp->Snp.Transmit       = SnpUndi32Transmit;
 399   Snp->Snp.Receive        = SnpUndi32Receive;
 400   Snp->Snp.WaitForPacket  = NULL;
 401
 402   Snp->Snp.Mode           = &Snp->Mode;
 403
 404   Snp->TxRxBufferSize     = 0;
 405   Snp->TxRxBuffer         = NULL;
 406
 407   if (Nii->Revision >= EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION) {
 408     Snp->IfNum = Nii->IfNum;
 409
 410   } else {
 411     Snp->IfNum = (UINT8) (Nii->IfNum & 0xFF);
 412   }
 413
 414   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_HW_UNDI) != 0) {
 415     Snp->IsSwUndi             = FALSE;
 416     Snp->IssueUndi32Command   = &IssueHwUndiCommand;
 417   } else {
 418     Snp->IsSwUndi = TRUE;
 419
 420     if ((Pxe->sw.Implementation & PXE_ROMID_IMP_SW_VIRT_ADDR) != 0) {
 421       Snp->IssueUndi32Command = (ISSUE_UNDI32_COMMAND) (UINTN) Pxe->sw.EntryPoint;
 422     } else {
 423       Snp->IssueUndi32Command = (ISSUE_UNDI32_COMMAND) (UINTN) ((UINT8) (UINTN) Pxe + Pxe->sw.EntryPoint);
 424     }
 425   }
 426   //
 427   // Allocate a global CPB and DB buffer for this UNDI interface.
 428   // we do this because:
 429   //
 430   // -UNDI 3.0 wants all the addresses passed to it (even the cpb and db) to be
 431   // within 2GB limit, create them here and map them so that when undi calls
 432   // v2p callback to check if the physical address is < 2gb, we will pass.
 433   //
 434   // -This is not a requirement for 3.1 or later UNDIs but the code looks
 435   // simpler if we use the same cpb, db variables for both old and new undi
 436   // interfaces from all the SNP interface calls (we don't map the buffers
 437   // for the newer undi interfaces though)
 438   // .
 439   // -it is OK to allocate one global set of CPB, DB pair for each UNDI
 440   // interface as EFI does not multi-task and so SNP will not be re-entered!
 441   //
 442   Status = PciIo->AllocateBuffer (
 443                     PciIo,
 444                     AllocateAnyPages,
 445                     EfiBootServicesData,
 446                     SNP_MEM_PAGES (4096),
 447                     &Address,
 448                     0
 449                     );
 450
 451   if (Status != EFI_SUCCESS) {
 452     DEBUG ((EFI_D_NET, "\nCould not allocate CPB and DB structures.\n"));
 453     goto Error_DeleteSNP;
 454   }
 455
 456   Snp->Cpb  = (VOID *) (UINTN) Address;
 457   Snp->Db   = (VOID *) ((UINTN) Address + 2048);
 458
 459   //
 460   // Find the correct BAR to do IO.
 461   //
 462   // Enumerate through the PCI BARs for the device to determine which one is
 463   // the IO BAR.  Save the index of the BAR into the adapter info structure.
 464   // for regular 32bit BARs, 0 is memory mapped, 1 is io mapped
 465   //
 466   Snp->MemoryBarIndex = 0;
 467   Snp->IoBarIndex     = 1;
 468   FoundMemoryBar      = FALSE;
 469   FoundIoBar          = FALSE;
 470   for (BarIndex = 0; BarIndex < PCI_MAX_BAR; BarIndex++) {
 471     Status = PciIo->GetBarAttributes (
 472                       PciIo,
 473                       BarIndex,
 474                       NULL,
 475                       (VOID**) &BarDesc
 476                       );
 477     if (Status == EFI_UNSUPPORTED) {
 478       continue;
 479     } else if (EFI_ERROR (Status)) {
 480       goto Error_DeleteSNP;
 481     }
 482
 483     if ((!FoundMemoryBar) && (BarDesc->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM)) {
 484       Snp->MemoryBarIndex = BarIndex;
 485       FoundMemoryBar      = TRUE;
 486     } else if ((!FoundIoBar) && (BarDesc->ResType == ACPI_ADDRESS_SPACE_TYPE_IO)) {
 487       Snp->IoBarIndex = BarIndex;
 488       FoundIoBar      = TRUE;
 489     }
 490
 491     FreePool (BarDesc);
 492
 493     if (FoundMemoryBar && FoundIoBar) {
 494       break;
 495     }
 496   }
 497
 498   Status = PxeStart (Snp);
 499
 500   if (Status != EFI_SUCCESS) {
 501     goto Error_DeleteSNP;
 502   }
 503
 504   Snp->Cdb.OpCode     = PXE_OPCODE_GET_INIT_INFO;
 505   Snp->Cdb.OpFlags    = PXE_OPFLAGS_NOT_USED;
 506
 507   Snp->Cdb.CPBsize    = PXE_CPBSIZE_NOT_USED;
 508   Snp->Cdb.CPBaddr    = PXE_DBADDR_NOT_USED;
 509
 510   Snp->Cdb.DBsize     = (UINT16) sizeof (Snp->InitInfo);
 511   Snp->Cdb.DBaddr     = (UINT64)(UINTN) (&Snp->InitInfo);
 512
 513   Snp->Cdb.StatCode   = PXE_STATCODE_INITIALIZE;
 514   Snp->Cdb.StatFlags  = PXE_STATFLAGS_INITIALIZE;
 515
 516   Snp->Cdb.IFnum      = Snp->IfNum;
 517   Snp->Cdb.Control    = PXE_CONTROL_LAST_CDB_IN_LIST;
 518
 519   DEBUG ((EFI_D_NET, "\nSnp->undi.get_init_info()  "));
 520
 521   (*Snp->IssueUndi32Command) ((UINT64)(UINTN) &Snp->Cdb);
 522
 523   //
 524   // Save the INIT Stat Code...
 525   //
 526   InitStatFlags = Snp->Cdb.StatFlags;
 527
 528   if (Snp->Cdb.StatCode != PXE_STATCODE_SUCCESS) {
 529     DEBUG ((EFI_D_NET, "\nSnp->undi.init_info()  %xh:%xh\n", Snp->Cdb.StatFlags, Snp->Cdb.StatCode));
 530     PxeStop (Snp);
 531     goto Error_DeleteSNP;
 532   }
 533
 534   //
 535   //  Initialize simple network protocol mode structure
 536   //
 537   Snp->Mode.State               = EfiSimpleNetworkStopped;
 538   Snp->Mode.HwAddressSize       = Snp->InitInfo.HWaddrLen;
 539   Snp->Mode.MediaHeaderSize     = Snp->InitInfo.MediaHeaderLen;
 540   Snp->Mode.MaxPacketSize       = Snp->InitInfo.FrameDataLen;
 541   Snp->Mode.NvRamAccessSize     = Snp->InitInfo.NvWidth;
 542   Snp->Mode.NvRamSize           = Snp->InitInfo.NvCount * Snp->Mode.NvRamAccessSize;
 543   Snp->Mode.IfType              = Snp->InitInfo.IFtype;
 544   Snp->Mode.MaxMCastFilterCount = Snp->InitInfo.MCastFilterCnt;
 545   Snp->Mode.MCastFilterCount    = 0;
 546
 547   switch (InitStatFlags & PXE_STATFLAGS_CABLE_DETECT_MASK) {
 548   case PXE_STATFLAGS_CABLE_DETECT_SUPPORTED:
 549     Snp->Mode.MediaPresentSupported = TRUE;
 550     break;
 551
 552   case PXE_STATFLAGS_CABLE_DETECT_NOT_SUPPORTED:
 553   default:
 554     Snp->Mode.MediaPresentSupported = FALSE;
 555   }
 556
 557   switch (InitStatFlags & PXE_STATFLAGS_GET_STATUS_NO_MEDIA_MASK) {
 558   case PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED:
 559     Snp->MediaStatusSupported = TRUE;
 560     break;
 561
 562   case PXE_STATFLAGS_GET_STATUS_NO_MEDIA_NOT_SUPPORTED:
 563   default:
 564     Snp->MediaStatusSupported = FALSE;
 565   }
 566
 567   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_STATION_ADDR_SETTABLE) != 0) {
 568     Snp->Mode.MacAddressChangeable = TRUE;
 569   } else {
 570     Snp->Mode.MacAddressChangeable = FALSE;
 571   }
 572
 573   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_MULTI_FRAME_SUPPORTED) != 0) {
 574     Snp->Mode.MultipleTxSupported = TRUE;
 575   } else {
 576     Snp->Mode.MultipleTxSupported = FALSE;
 577   }
 578
 579   Snp->Mode.ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST;
 580
 581   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED) != 0) {
 582     Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
 583
 584   }
 585
 586   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_RX_SUPPORTED) != 0) {
 587     Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;
 588
 589   }
 590
 591   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_BROADCAST_RX_SUPPORTED) != 0) {
 592     Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;
 593
 594   }
 595
 596   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_FILTERED_MULTICAST_RX_SUPPORTED) != 0) {
 597     Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST;
 598
 599   }
 600
 601   if ((Pxe->hw.Implementation & PXE_ROMID_IMP_PROMISCUOUS_MULTICAST_RX_SUPPORTED) != 0) {
 602     Snp->Mode.ReceiveFilterMask |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
 603
 604   }
 605
 606   Snp->Mode.ReceiveFilterSetting = 0;
 607
 608   //
 609   //  need to get the station address to save in the mode structure. we need to
 610   // initialize the UNDI first for this.
 611   //
 612   Snp->TxRxBufferSize = Snp->InitInfo.MemoryRequired;
 613   Status              = PxeInit (Snp, PXE_OPFLAGS_INITIALIZE_DO_NOT_DETECT_CABLE);
 614
 615   if (EFI_ERROR (Status)) {
 616     PxeStop (Snp);
 617     goto Error_DeleteSNP;
 618   }
 619
 620   Status = PxeGetStnAddr (Snp);
 621
 622   if (Status != EFI_SUCCESS) {
 623     DEBUG ((EFI_D_ERROR, "\nSnp->undi.get_station_addr() failed.\n"));
 624     PxeShutdown (Snp);
 625     PxeStop (Snp);
 626     goto Error_DeleteSNP;
 627   }
 628
 629   Snp->Mode.MediaPresent = FALSE;
 630
 631   //
 632   // We should not leave UNDI started and initialized here. this DriverStart()
 633   // routine must only find and attach the SNP interface to UNDI layer that it
 634   // finds on the given handle!
 635   // The UNDI layer will be started when upper layers call Snp->start.
 636   // How ever, this DriverStart() must fill up the snp mode structure which
 637   // contains the MAC address of the NIC. For this reason we started and
 638   // initialized UNDI here, now we are done, do a shutdown and stop of the
 639   // UNDI interface!
 640   //
 641   PxeShutdown (Snp);
 642   PxeStop (Snp);
 643
 644   //
 645   // Create EXIT_BOOT_SERIVES Event
 646   //
 647   Status = gBS->CreateEventEx (
 648                   EVT_NOTIFY_SIGNAL,
 649                   TPL_NOTIFY,
 650                   SnpNotifyExitBootServices,
 651                   Snp,
 652                   &gEfiEventExitBootServicesGuid,
 653                   &Snp->ExitBootServicesEvent
 654                   );
 655   if (EFI_ERROR (Status)) {
 656     goto Error_DeleteSNP;
 657   }
 658
 659   //
 660   //  add SNP to the undi handle
 661   //
 662   Status = gBS->InstallProtocolInterface (
 663                   &Controller,
 664                   &gEfiSimpleNetworkProtocolGuid,
 665                   EFI_NATIVE_INTERFACE,
 666                   &(Snp->Snp)
 667                   );
 668
 669   if (!EFI_ERROR (Status)) {
 670     return Status;
 671   }
 672
 673   PciIo->FreeBuffer (
 674            PciIo,
 675            SNP_MEM_PAGES (4096),
 676            Snp->Cpb
 677            );
 678
 679 Error_DeleteSNP:
 680
 681   PciIo->FreeBuffer (
 682            PciIo,
 683            SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
 684            Snp
 685            );
 686 NiiError:
 687   gBS->CloseProtocol (
 688         Controller,
 689         &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 690         This->DriverBindingHandle,
 691         Controller
 692         );
 693
 694   gBS->CloseProtocol (
 695         Controller,
 696         &gEfiDevicePathProtocolGuid,
 697         This->DriverBindingHandle,
 698         Controller
 699         );
 700
 701   //
 702   // If we got here that means we are in error state.
 703   //
 704   if (!EFI_ERROR (Status)) {
 705     Status = EFI_DEVICE_ERROR;
 706   }
 707
 708   return Status;
 709 }
 710
 711 /**
 712   Stop this driver on ControllerHandle. This service is called by the
 713   EFI boot service DisconnectController(). In order to
 714   make drivers as small as possible, there are a few calling
 715   restrictions for this service. DisconnectController()
 716   must follow these calling restrictions. If any other agent wishes
 717   to call Stop() it must also follow these calling restrictions.
 718
 719   @param  This              Protocol instance pointer.
 720   @param  ControllerHandle  Handle of device to stop driver on
 721   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 722                             children is zero stop the entire bus driver.
 723   @param  ChildHandleBuffer List of Child Handles to Stop.
 724
 725   @retval EFI_SUCCESS       This driver is removed ControllerHandle
 726   @retval other             This driver was not removed from this device
 727
 728 **/
 729 EFI_STATUS
 730 EFIAPI
 731 SimpleNetworkDriverStop (
 732   IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
 733   IN  EFI_HANDLE                     Controller,
 734   IN  UINTN                          NumberOfChildren,
 735   IN  EFI_HANDLE                     *ChildHandleBuffer
 736   )
 737 {
 738   EFI_STATUS                  Status;
 739   EFI_SIMPLE_NETWORK_PROTOCOL *SnpProtocol;
 740   SNP_DRIVER                  *Snp;
 741   EFI_PCI_IO_PROTOCOL         *PciIo;
 742
 743   //
 744   // Get our context back.
 745   //
 746   Status = gBS->OpenProtocol (
 747                   Controller,
 748                   &gEfiSimpleNetworkProtocolGuid,
 749                   (VOID **) &SnpProtocol,
 750                   This->DriverBindingHandle,
 751                   Controller,
 752                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 753                   );
 754
 755   if (EFI_ERROR (Status)) {
 756     return EFI_UNSUPPORTED;
 757   }
 758
 759   Snp = EFI_SIMPLE_NETWORK_DEV_FROM_THIS (SnpProtocol);
 760
 761   Status = gBS->UninstallProtocolInterface (
 762                   Controller,
 763                   &gEfiSimpleNetworkProtocolGuid,
 764                   &Snp->Snp
 765                   );
 766
 767   if (EFI_ERROR (Status)) {
 768     return Status;
 769   }
 770
 771   //
 772   // Close EXIT_BOOT_SERIVES Event
 773   //
 774   gBS->CloseEvent (Snp->ExitBootServicesEvent);
 775
 776   Status = gBS->CloseProtocol (
 777                   Controller,
 778                   &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
 779                   This->DriverBindingHandle,
 780                   Controller
 781                   );
 782
 783   Status = gBS->CloseProtocol (
 784                   Controller,
 785                   &gEfiDevicePathProtocolGuid,
 786                   This->DriverBindingHandle,
 787                   Controller
 788                   );
 789
 790   PxeShutdown (Snp);
 791   PxeStop (Snp);
 792
 793   PciIo = Snp->PciIo;
 794   PciIo->FreeBuffer (
 795            PciIo,
 796            SNP_MEM_PAGES (4096),
 797            Snp->Cpb
 798            );
 799
 800   PciIo->FreeBuffer (
 801            PciIo,
 802            SNP_MEM_PAGES (sizeof (SNP_DRIVER)),
 803            Snp
 804            );
 805
 806   return Status;
 807 }
 808
 809 //
 810 // Simple Network Protocol Driver Global Variables
 811 //
 812 EFI_DRIVER_BINDING_PROTOCOL gSimpleNetworkDriverBinding = {
 813   SimpleNetworkDriverSupported,
 814   SimpleNetworkDriverStart,
 815   SimpleNetworkDriverStop,
 816   0xa,
 817   NULL,
 818   NULL
 819 };
 820
 821 /**
 822   The SNP driver entry point.
 823
 824   @param ImageHandle       The driver image handle.
 825   @param SystemTable       The system table.
 826
 827   @retval EFI_SUCEESS      Initialization routine has found UNDI hardware,
 828                            loaded it's ROM, and installed a notify event for
 829                            the Network Indentifier Interface Protocol
 830                            successfully.
 831   @retval Other            Return value from HandleProtocol for
 832                            DeviceIoProtocol or LoadedImageProtocol
 833
 834 **/
 835 EFI_STATUS
 836 EFIAPI
 837 InitializeSnpNiiDriver (
 838   IN EFI_HANDLE       ImageHandle,
 839   IN EFI_SYSTEM_TABLE *SystemTable
 840   )
 841 {
 842   return EfiLibInstallDriverBindingComponentName2 (
 843            ImageHandle,
 844            SystemTable,
 845            &gSimpleNetworkDriverBinding,
 846            ImageHandle,
 847            &gSimpleNetworkComponentName,
 848            &gSimpleNetworkComponentName2
 849            );
 850 }