1 /** @file 2 3 Driver Binding code and its private helpers for the virtio-net driver. 4 5 Copyright (C) 2013, Red Hat, Inc. 6 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR> 7 8 This program and the accompanying materials are licensed and made available 9 under the terms and conditions of the BSD License which accompanies this 10 distribution. The full text of the license may be found at 11 http://opensource.org/licenses/bsd-license.php 12 13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT 14 WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 15 16 **/ 17 18 #include <Library/BaseMemoryLib.h> 19 #include <Library/DevicePathLib.h> 20 #include <Library/MemoryAllocationLib.h> 21 #include <Library/UefiBootServicesTableLib.h> 22 23 #include "VirtioNet.h" 24 25 #define RECEIVE_FILTERS_NO_MCAST ((UINT32) ( \ 26 EFI_SIMPLE_NETWORK_RECEIVE_UNICAST | \ 27 EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST | \ 28 EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS \ 29 )) 30 31 /* 32 Temporarily enable then reset the virtio-net device in order to retrieve 33 configuration values needed by Simple Network Protocol and Simple Network 34 Mode fields. 35 36 Only VirtioNetSnpPopulate() may call this function. 37 38 If the function fails for any reason, the virtio-net device is moved to 39 VSTAT_FAILED instead of being reset. This serves only informative purposes 40 for the host side. 41 42 param[in,out] Dev The VNET_DEV structure being created for 43 the virtio-net device. 44 param[out] MacAddress MAC address configured by the host. 45 param[out] MediaPresentSupported Link status is made available by the host. 46 param[out] MediaPresent If link status is made available by the 47 host, the current link status is stored in 48 *MediaPresent. Otherwise MediaPresent is 49 unused. 50 51 @retval EFI_UNSUPPORTED The host doesn't supply a MAC address. 52 @return Status codes from VirtIo protocol members. 53 @retval EFI_SUCCESS Configuration values retrieved. 54 */ 55 STATIC 56 EFI_STATUS 57 EFIAPI 58 VirtioNetGetFeatures ( 59 IN OUT VNET_DEV *Dev, 60 OUT EFI_MAC_ADDRESS *MacAddress, 61 OUT BOOLEAN *MediaPresentSupported, 62 OUT BOOLEAN *MediaPresent 63 ) 64 { 65 EFI_STATUS Status; 66 UINT8 NextDevStat; 67 UINT64 Features; 68 UINTN MacIdx; 69 UINT16 LinkStatus; 70 71 // 72 // Interrogate the device for features (virtio-0.9.5, 2.2.1 Device 73 // Initialization Sequence), but don't complete setting it up. 74 // 75 NextDevStat = 0; // step 1 -- reset device 76 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat); 77 if (EFI_ERROR (Status)) { 78 return Status; 79 } 80 81 NextDevStat |= VSTAT_ACK; // step 2 -- acknowledge device presence 82 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat); 83 if (EFI_ERROR (Status)) { 84 goto YieldDevice; 85 } 86 87 NextDevStat |= VSTAT_DRIVER; // step 3 -- we know how to drive it 88 Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat); 89 if (EFI_ERROR (Status)) { 90 goto YieldDevice; 91 } 92 93 // 94 // step 4a -- retrieve and validate features 95 // 96 Status = Dev->VirtIo->GetDeviceFeatures (Dev->VirtIo, &Features); 97 if (EFI_ERROR (Status)) { 98 goto YieldDevice; 99 } 100 101 // 102 // get MAC address byte-wise 103 // 104 if ((Features & VIRTIO_NET_F_MAC) == 0) { 105 Status = EFI_UNSUPPORTED; 106 goto YieldDevice; 107 } 108 for (MacIdx = 0; MacIdx < SIZE_OF_VNET (Mac); ++MacIdx) { 109 Status = Dev->VirtIo->ReadDevice (Dev->VirtIo, 110 OFFSET_OF_VNET (Mac) + MacIdx, // Offset 111 1, // FieldSize 112 1, // BufferSize 113 &MacAddress->Addr[MacIdx] // Buffer 114 ); 115 if (EFI_ERROR (Status)) { 116 goto YieldDevice; 117 } 118 } 119 120 // 121 // check if link status is reported, and if so, what the link status is 122 // 123 if ((Features & VIRTIO_NET_F_STATUS) == 0) { 124 *MediaPresentSupported = FALSE; 125 } 126 else { 127 *MediaPresentSupported = TRUE; 128 Status = VIRTIO_CFG_READ (Dev, LinkStatus, &LinkStatus); 129 if (EFI_ERROR (Status)) { 130 goto YieldDevice; 131 } 132 *MediaPresent = (BOOLEAN) ((LinkStatus & VIRTIO_NET_S_LINK_UP) != 0); 133 } 134 135 YieldDevice: 136 Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 137 EFI_ERROR (Status) ? VSTAT_FAILED : 0); 138 139 return Status; 140 } 141 142 143 /** 144 Set up the Simple Network Protocol fields, the Simple Network Mode fields, 145 and the Exit Boot Services Event of the virtio-net driver instance. 146 147 This function may only be called by VirtioNetDriverBindingStart(). 148 149 @param[in,out] Dev The VNET_DEV driver instance being created for the 150 virtio-net device. 151 152 @return Status codes from the CreateEvent() boot service or the 153 VirtioNetGetFeatures() function. 154 @retval EFI_SUCCESS Configuration successful. 155 */ 156 STATIC 157 EFI_STATUS 158 EFIAPI 159 VirtioNetSnpPopulate ( 160 IN OUT VNET_DEV *Dev 161 ) 162 { 163 EFI_STATUS Status; 164 165 // 166 // We set up a function here that is asynchronously callable by an 167 // external application to check if there are any packets available for 168 // reception. The least urgent task priority level we can specify for such a 169 // "software interrupt" is TPL_CALLBACK. 170 // 171 // TPL_CALLBACK is also the maximum TPL an SNP implementation is allowed to 172 // run at (see 6.1 Event, Timer, and Task Priority Services in the UEFI 173 // Specification 2.3.1+errC). 174 // 175 // Since we raise our TPL to TPL_CALLBACK in every single function that 176 // accesses the device, and the external application also queues its interest 177 // for received packets at the same TPL_CALLBACK, in effect the 178 // VirtioNetIsPacketAvailable() function will never interrupt any 179 // device-accessing driver function, it will be scheduled in isolation. 180 // 181 // TPL_CALLBACK (which basically this entire driver runs at) is allowed 182 // for "[l]ong term operations (such as file system operations and disk 183 // I/O)". Because none of our functions block, we'd satisfy an even stronger 184 // requirement. 185 // 186 Status = gBS->CreateEvent (EVT_NOTIFY_WAIT, TPL_CALLBACK, 187 &VirtioNetIsPacketAvailable, Dev, &Dev->Snp.WaitForPacket); 188 if (EFI_ERROR (Status)) { 189 return Status; 190 } 191 192 Dev->Snp.Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION; 193 Dev->Snp.Start = &VirtioNetStart; 194 Dev->Snp.Stop = &VirtioNetStop; 195 Dev->Snp.Initialize = &VirtioNetInitialize; 196 Dev->Snp.Reset = &VirtioNetReset; 197 Dev->Snp.Shutdown = &VirtioNetShutdown; 198 Dev->Snp.ReceiveFilters = &VirtioNetReceiveFilters; 199 Dev->Snp.StationAddress = &VirtioNetStationAddress; 200 Dev->Snp.Statistics = &VirtioNetStatistics; 201 Dev->Snp.MCastIpToMac = &VirtioNetMcastIpToMac; 202 Dev->Snp.NvData = &VirtioNetNvData; 203 Dev->Snp.GetStatus = &VirtioNetGetStatus; 204 Dev->Snp.Transmit = &VirtioNetTransmit; 205 Dev->Snp.Receive = &VirtioNetReceive; 206 Dev->Snp.Mode = &Dev->Snm; 207 208 Dev->Snm.State = EfiSimpleNetworkStopped; 209 Dev->Snm.HwAddressSize = SIZE_OF_VNET (Mac); 210 Dev->Snm.MediaHeaderSize = SIZE_OF_VNET (Mac) + // dst MAC 211 SIZE_OF_VNET (Mac) + // src MAC 212 2; // Ethertype 213 Dev->Snm.MaxPacketSize = 1500; 214 Dev->Snm.NvRamSize = 0; 215 Dev->Snm.NvRamAccessSize = 0; 216 Dev->Snm.ReceiveFilterMask = RECEIVE_FILTERS_NO_MCAST; 217 Dev->Snm.ReceiveFilterSetting = RECEIVE_FILTERS_NO_MCAST; 218 Dev->Snm.MaxMCastFilterCount = 0; 219 Dev->Snm.MCastFilterCount = 0; 220 Dev->Snm.IfType = 1; // ethernet 221 Dev->Snm.MacAddressChangeable = FALSE; 222 Dev->Snm.MultipleTxSupported = TRUE; 223 224 ASSERT (SIZE_OF_VNET (Mac) <= sizeof (EFI_MAC_ADDRESS)); 225 226 Status = VirtioNetGetFeatures (Dev, &Dev->Snm.CurrentAddress, 227 &Dev->Snm.MediaPresentSupported, &Dev->Snm.MediaPresent); 228 if (EFI_ERROR (Status)) { 229 goto CloseWaitForPacket; 230 } 231 CopyMem (&Dev->Snm.PermanentAddress, &Dev->Snm.CurrentAddress, 232 SIZE_OF_VNET (Mac)); 233 SetMem (&Dev->Snm.BroadcastAddress, SIZE_OF_VNET (Mac), 0xFF); 234 235 // 236 // VirtioNetExitBoot() is queued by ExitBootServices(); its purpose is to 237 // cancel any pending virtio requests. The TPL_CALLBACK reasoning is 238 // identical to the one above. There's one difference: this kind of 239 // event is "globally visible", which means it can be signalled as soon as 240 // we create it. We haven't raised our TPL here, hence VirtioNetExitBoot() 241 // could be entered immediately. VirtioNetExitBoot() checks Dev->Snm.State, 242 // so we're safe. 243 // 244 Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK, 245 &VirtioNetExitBoot, Dev, &Dev->ExitBoot); 246 if (EFI_ERROR (Status)) { 247 goto CloseWaitForPacket; 248 } 249 250 return EFI_SUCCESS; 251 252 CloseWaitForPacket: 253 gBS->CloseEvent (Dev->Snp.WaitForPacket); 254 return Status; 255 } 256 257 258 /** 259 Release any resources allocated by VirtioNetSnpPopulate(). 260 261 This function may only be called by VirtioNetDriverBindingStart(), when 262 rolling back a partial, failed driver instance creation, and by 263 VirtioNetDriverBindingStop(), when disconnecting a virtio-net device from the 264 driver. 265 266 @param[in,out] Dev The VNET_DEV driver instance being destroyed. 267 */ 268 STATIC 269 VOID 270 EFIAPI 271 VirtioNetSnpEvacuate ( 272 IN OUT VNET_DEV *Dev 273 ) 274 { 275 // 276 // This function runs either at TPL_CALLBACK already (from 277 // VirtioNetDriverBindingStop()), or it is part of a teardown following 278 // a partial, failed construction in VirtioNetDriverBindingStart(), when 279 // WaitForPacket was never accessible to the world. 280 // 281 gBS->CloseEvent (Dev->ExitBoot); 282 gBS->CloseEvent (Dev->Snp.WaitForPacket); 283 } 284 285 286 /** 287 Tests to see if this driver supports a given controller. If a child device is 288 provided, it further tests to see if this driver supports creating a handle 289 for the specified child device. 290 291 This function checks to see if the driver specified by This supports the 292 device specified by ControllerHandle. Drivers will typically use the device 293 path attached to ControllerHandle and/or the services from the bus I/O 294 abstraction attached to ControllerHandle to determine if the driver supports 295 ControllerHandle. This function may be called many times during platform 296 initialization. In order to reduce boot times, the tests performed by this 297 function must be very small, and take as little time as possible to execute. 298 This function must not change the state of any hardware devices, and this 299 function must be aware that the device specified by ControllerHandle may 300 already be managed by the same driver or a different driver. This function 301 must match its calls to AllocatePages() with FreePages(), AllocatePool() with 302 FreePool(), and OpenProtocol() with CloseProtocol(). Because ControllerHandle 303 may have been previously started by the same driver, if a protocol is already 304 in the opened state, then it must not be closed with CloseProtocol(). This is 305 required to guarantee the state of ControllerHandle is not modified by this 306 function. 307 308 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL 309 instance. 310 @param[in] ControllerHandle The handle of the controller to test. This 311 handle must support a protocol interface 312 that supplies an I/O abstraction to the 313 driver. 314 @param[in] RemainingDevicePath A pointer to the remaining portion of a 315 device path. This parameter is ignored by 316 device drivers, and is optional for bus 317 drivers. For bus drivers, if this parameter 318 is not NULL, then the bus driver must 319 determine if the bus controller specified by 320 ControllerHandle and the child controller 321 specified by RemainingDevicePath are both 322 supported by this bus driver. 323 324 @retval EFI_SUCCESS The device specified by ControllerHandle and 325 RemainingDevicePath is supported by the 326 driver specified by This. 327 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and 328 RemainingDevicePath is already being managed 329 by the driver specified by This. 330 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and 331 RemainingDevicePath is already being managed 332 by a different driver or an application that 333 requires exclusive access. Currently not 334 implemented. 335 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and 336 RemainingDevicePath is not supported by the 337 driver specified by This. 338 **/ 339 340 STATIC 341 EFI_STATUS 342 EFIAPI 343 VirtioNetDriverBindingSupported ( 344 IN EFI_DRIVER_BINDING_PROTOCOL *This, 345 IN EFI_HANDLE DeviceHandle, 346 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 347 ) 348 { 349 EFI_STATUS Status; 350 VIRTIO_DEVICE_PROTOCOL *VirtIo; 351 352 // 353 // Attempt to open the device with the VirtIo set of interfaces. On success, 354 // the protocol is "instantiated" for the VirtIo device. Covers duplicate open 355 // attempts (EFI_ALREADY_STARTED). 356 // 357 Status = gBS->OpenProtocol ( 358 DeviceHandle, // candidate device 359 &gVirtioDeviceProtocolGuid, // for generic VirtIo access 360 (VOID **)&VirtIo, // handle to instantiate 361 This->DriverBindingHandle, // requestor driver identity 362 DeviceHandle, // ControllerHandle, according to 363 // the UEFI Driver Model 364 EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive VirtIo access to 365 // the device; to be released 366 ); 367 if (EFI_ERROR (Status)) { 368 return Status; 369 } 370 371 if (VirtIo->SubSystemDeviceId != VIRTIO_SUBSYSTEM_NETWORK_CARD) { 372 Status = EFI_UNSUPPORTED; 373 } 374 375 // 376 // We needed VirtIo access only transitorily, to see whether we support the 377 // device or not. 378 // 379 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, 380 This->DriverBindingHandle, DeviceHandle); 381 return Status; 382 } 383 384 385 /** 386 Starts a device controller or a bus controller. 387 388 The Start() function is designed to be invoked from the EFI boot service 389 ConnectController(). As a result, much of the error checking on the 390 parameters to Start() has been moved into this common boot service. It is 391 legal to call Start() from other locations, but the following calling 392 restrictions must be followed, or the system behavior will not be 393 deterministic. 394 1. ControllerHandle must be a valid EFI_HANDLE. 395 2. If RemainingDevicePath is not NULL, then it must be a pointer to a 396 naturally aligned EFI_DEVICE_PATH_PROTOCOL. 397 3. Prior to calling Start(), the Supported() function for the driver 398 specified by This must have been called with the same calling parameters, 399 and Supported() must have returned EFI_SUCCESS. 400 401 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL 402 instance. 403 @param[in] ControllerHandle The handle of the controller to start. This 404 handle must support a protocol interface 405 that supplies an I/O abstraction to the 406 driver. 407 @param[in] RemainingDevicePath A pointer to the remaining portion of a 408 device path. This parameter is ignored by 409 device drivers, and is optional for bus 410 drivers. For a bus driver, if this parameter 411 is NULL, then handles for all the children 412 of Controller are created by this driver. 413 If this parameter is not NULL and the first 414 Device Path Node is not the End of Device 415 Path Node, then only the handle for the 416 child device specified by the first Device 417 Path Node of RemainingDevicePath is created 418 by this driver. If the first Device Path 419 Node of RemainingDevicePath is the End of 420 Device Path Node, no child handle is created 421 by this driver. 422 423 @retval EFI_SUCCESS The device was started. 424 @retval EFI_DEVICE_ERROR The device could not be started due to a 425 device error.Currently not implemented. 426 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a 427 lack of resources. 428 @retval Others The driver failded to start the device. 429 430 **/ 431 432 STATIC 433 EFI_STATUS 434 EFIAPI 435 VirtioNetDriverBindingStart ( 436 IN EFI_DRIVER_BINDING_PROTOCOL *This, 437 IN EFI_HANDLE DeviceHandle, 438 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 439 ) 440 { 441 EFI_STATUS Status; 442 VNET_DEV *Dev; 443 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 444 MAC_ADDR_DEVICE_PATH MacNode; 445 VOID *ChildVirtIo; 446 447 // 448 // allocate space for the driver instance 449 // 450 Dev = (VNET_DEV *) AllocateZeroPool (sizeof *Dev); 451 if (Dev == NULL) { 452 return EFI_OUT_OF_RESOURCES; 453 } 454 Dev->Signature = VNET_SIG; 455 456 Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, 457 (VOID **)&Dev->VirtIo, This->DriverBindingHandle, 458 DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER); 459 if (EFI_ERROR (Status)) { 460 goto FreeVirtioNet; 461 } 462 463 // 464 // now we can run a basic one-shot virtio-net initialization required to 465 // retrieve the MAC address 466 // 467 Status = VirtioNetSnpPopulate (Dev); 468 if (EFI_ERROR (Status)) { 469 goto CloseVirtIo; 470 } 471 472 // 473 // get the device path of the virtio-net device -- one-shot open 474 // 475 Status = gBS->OpenProtocol (DeviceHandle, &gEfiDevicePathProtocolGuid, 476 (VOID **)&DevicePath, This->DriverBindingHandle, 477 DeviceHandle, EFI_OPEN_PROTOCOL_GET_PROTOCOL); 478 if (EFI_ERROR (Status)) { 479 goto Evacuate; 480 } 481 482 // 483 // create another device path that has the MAC address appended 484 // 485 MacNode.Header.Type = MESSAGING_DEVICE_PATH; 486 MacNode.Header.SubType = MSG_MAC_ADDR_DP; 487 SetDevicePathNodeLength (&MacNode, sizeof MacNode); 488 CopyMem (&MacNode.MacAddress, &Dev->Snm.CurrentAddress, 489 sizeof (EFI_MAC_ADDRESS)); 490 MacNode.IfType = Dev->Snm.IfType; 491 492 Dev->MacDevicePath = AppendDevicePathNode (DevicePath, &MacNode.Header); 493 if (Dev->MacDevicePath == NULL) { 494 Status = EFI_OUT_OF_RESOURCES; 495 goto Evacuate; 496 } 497 498 // 499 // create a child handle with the Simple Network Protocol and the new 500 // device path installed on it 501 // 502 Status = gBS->InstallMultipleProtocolInterfaces (&Dev->MacHandle, 503 &gEfiSimpleNetworkProtocolGuid, &Dev->Snp, 504 &gEfiDevicePathProtocolGuid, Dev->MacDevicePath, 505 NULL); 506 if (EFI_ERROR (Status)) { 507 goto FreeMacDevicePath; 508 } 509 510 // 511 // make a note that we keep this device open with VirtIo for the sake of this 512 // child 513 // 514 Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, 515 &ChildVirtIo, This->DriverBindingHandle, 516 Dev->MacHandle, EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER); 517 if (EFI_ERROR (Status)) { 518 goto UninstallMultiple; 519 } 520 521 return EFI_SUCCESS; 522 523 UninstallMultiple: 524 gBS->UninstallMultipleProtocolInterfaces (Dev->MacHandle, 525 &gEfiDevicePathProtocolGuid, Dev->MacDevicePath, 526 &gEfiSimpleNetworkProtocolGuid, &Dev->Snp, 527 NULL); 528 529 FreeMacDevicePath: 530 FreePool (Dev->MacDevicePath); 531 532 Evacuate: 533 VirtioNetSnpEvacuate (Dev); 534 535 CloseVirtIo: 536 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, 537 This->DriverBindingHandle, DeviceHandle); 538 539 FreeVirtioNet: 540 FreePool (Dev); 541 542 return Status; 543 } 544 545 546 /** 547 Stops a device controller or a bus controller. 548 549 The Stop() function is designed to be invoked from the EFI boot service 550 DisconnectController(). As a result, much of the error checking on the 551 parameters to Stop() has been moved into this common boot service. It is 552 legal to call Stop() from other locations, but the following calling 553 restrictions must be followed, or the system behavior will not be 554 deterministic. 555 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous 556 call to this same driver's Start() function. 557 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a 558 valid EFI_HANDLE. In addition, all of these handles must have been created 559 in this driver's Start() function, and the Start() function must have 560 called OpenProtocol() on ControllerHandle with an Attribute of 561 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER. 562 563 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL 564 instance. 565 @param[in] ControllerHandle A handle to the device being stopped. The 566 handle must support a bus specific I/O 567 protocol for the driver to use to stop the 568 device. 569 @param[in] NumberOfChildren The number of child device handles in 570 ChildHandleBuffer. 571 @param[in] ChildHandleBuffer An array of child handles to be freed. May be 572 NULL if NumberOfChildren is 0. 573 574 @retval EFI_SUCCESS The device was stopped. 575 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device 576 error. 577 578 **/ 579 STATIC 580 EFI_STATUS 581 EFIAPI 582 VirtioNetDriverBindingStop ( 583 IN EFI_DRIVER_BINDING_PROTOCOL *This, 584 IN EFI_HANDLE DeviceHandle, 585 IN UINTN NumberOfChildren, 586 IN EFI_HANDLE *ChildHandleBuffer 587 ) 588 { 589 if (NumberOfChildren > 0) { 590 // 591 // free all resources for whose access we need the child handle, because 592 // the child handle is going away 593 // 594 EFI_STATUS Status; 595 EFI_SIMPLE_NETWORK_PROTOCOL *Snp; 596 VNET_DEV *Dev; 597 EFI_TPL OldTpl; 598 599 ASSERT (NumberOfChildren == 1); 600 601 Status = gBS->OpenProtocol (ChildHandleBuffer[0], 602 &gEfiSimpleNetworkProtocolGuid, (VOID **)&Snp, 603 This->DriverBindingHandle, DeviceHandle, 604 EFI_OPEN_PROTOCOL_GET_PROTOCOL); 605 ASSERT_EFI_ERROR (Status); 606 Dev = VIRTIO_NET_FROM_SNP (Snp); 607 608 // 609 // prevent any interference with WaitForPacket 610 // 611 OldTpl = gBS->RaiseTPL (TPL_CALLBACK); 612 613 ASSERT (Dev->MacHandle == ChildHandleBuffer[0]); 614 if (Dev->Snm.State != EfiSimpleNetworkStopped) { 615 // 616 // device in use, cannot stop driver instance 617 // 618 Status = EFI_DEVICE_ERROR; 619 } 620 else { 621 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, 622 This->DriverBindingHandle, Dev->MacHandle); 623 gBS->UninstallMultipleProtocolInterfaces (Dev->MacHandle, 624 &gEfiDevicePathProtocolGuid, Dev->MacDevicePath, 625 &gEfiSimpleNetworkProtocolGuid, &Dev->Snp, 626 NULL); 627 FreePool (Dev->MacDevicePath); 628 VirtioNetSnpEvacuate (Dev); 629 FreePool (Dev); 630 } 631 632 gBS->RestoreTPL (OldTpl); 633 return Status; 634 } 635 636 // 637 // release remaining resources, tied directly to the parent handle 638 // 639 gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid, 640 This->DriverBindingHandle, DeviceHandle); 641 642 return EFI_SUCCESS; 643 } 644 645 646 EFI_DRIVER_BINDING_PROTOCOL gVirtioNetDriverBinding = { 647 &VirtioNetDriverBindingSupported, 648 &VirtioNetDriverBindingStart, 649 &VirtioNetDriverBindingStop, 650 0x10, 651 NULL, 652 NULL 653 }; 654