OvmfPkg/VirtioBlkDxe/VirtioBlk.c

   1 /** @file
   2
   3   This driver produces Block I/O Protocol instances for virtio-blk devices.
   4
   5   The implementation is basic:
   6
   7   - No attach/detach (ie. removable media).
   8
   9   - Although the non-blocking interfaces of EFI_BLOCK_IO2_PROTOCOL could be a
  10     good match for multiple in-flight virtio-blk requests, we stick to
  11     synchronous requests and EFI_BLOCK_IO_PROTOCOL for now.
  12
  13   Copyright (C) 2012, Red Hat, Inc.
  14   Copyright (c) 2012 - 2018, Intel Corporation. All rights reserved.<BR>
  15   Copyright (c) 2017, AMD Inc, All rights reserved.<BR>
  16
  17   SPDX-License-Identifier: BSD-2-Clause-Patent
  18
  19 **/
  20
  21 #include <IndustryStandard/VirtioBlk.h>
  22 #include <Library/BaseMemoryLib.h>
  23 #include <Library/DebugLib.h>
  24 #include <Library/MemoryAllocationLib.h>
  25 #include <Library/UefiBootServicesTableLib.h>
  26 #include <Library/UefiLib.h>
  27 #include <Library/VirtioLib.h>
  28
  29 #include "VirtioBlk.h"
  30
  31 /**
  32
  33   Convenience macros to read and write region 0 IO space elements of the
  34   virtio-blk device, for configuration purposes.
  35
  36   The following macros make it possible to specify only the "core parameters"
  37   for such accesses and to derive the rest. By the time VIRTIO_CFG_WRITE()
  38   returns, the transaction will have been completed.
  39
  40   @param[in] Dev       Pointer to the VBLK_DEV structure whose VirtIo space
  41                        we're accessing. Dev->VirtIo must be valid.
  42
  43   @param[in] Field     A field name from VBLK_HDR, identifying the virtio-blk
  44                        configuration item to access.
  45
  46   @param[in] Value     (VIRTIO_CFG_WRITE() only.) The value to write to the
  47                        selected configuration item.
  48
  49   @param[out] Pointer  (VIRTIO_CFG_READ() only.) The object to receive the
  50                        value read from the configuration item. Its type must be
  51                        one of UINT8, UINT16, UINT32, UINT64.
  52
  53
  54   @return  Status code returned by Virtio->WriteDevice() /
  55            Virtio->ReadDevice().
  56
  57 **/
  58
  59 #define VIRTIO_CFG_WRITE(Dev, Field, Value)  ((Dev)->VirtIo->WriteDevice ( \
  60                                                 (Dev)->VirtIo,             \
  61                                                 OFFSET_OF_VBLK (Field),    \
  62                                                 SIZE_OF_VBLK (Field),      \
  63                                                 (Value)                    \
  64                                                 ))
  65
  66 #define VIRTIO_CFG_READ(Dev, Field, Pointer) ((Dev)->VirtIo->ReadDevice (  \
  67                                                 (Dev)->VirtIo,             \
  68                                                 OFFSET_OF_VBLK (Field),    \
  69                                                 SIZE_OF_VBLK (Field),      \
  70                                                 sizeof *(Pointer),         \
  71                                                 (Pointer)                  \
  72                                                 ))
  73
  74
  75 //
  76 // UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol
  77 // Driver Writer's Guide for UEFI 2.3.1 v1.01,
  78 //   24.2 Block I/O Protocol Implementations
  79 //
  80 EFI_STATUS
  81 EFIAPI
  82 VirtioBlkReset (
  83   IN EFI_BLOCK_IO_PROTOCOL *This,
  84   IN BOOLEAN               ExtendedVerification
  85   )
  86 {
  87   //
  88   // If we managed to initialize and install the driver, then the device is
  89   // working correctly.
  90   //
  91   return EFI_SUCCESS;
  92 }
  93
  94 /**
  95
  96   Verify correctness of the read/write (not flush) request submitted to the
  97   EFI_BLOCK_IO_PROTOCOL instance.
  98
  99   This function provides most verification steps described in:
 100
 101     UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 102     Protocol,
 103     - EFI_BLOCK_IO_PROTOCOL.ReadBlocks()
 104     - EFI_BLOCK_IO_PROTOCOL.WriteBlocks()
 105
 106     Driver Writer's Guide for UEFI 2.3.1 v1.01,
 107     - 24.2.2. ReadBlocks() and ReadBlocksEx() Implementation
 108     - 24.2.3 WriteBlocks() and WriteBlockEx() Implementation
 109
 110   Request sizes are limited to 1 GB (checked). This is not a practical
 111   limitation, just conformance to virtio-0.9.5, 2.3.2 Descriptor Table: "no
 112   descriptor chain may be more than 2^32 bytes long in total".
 113
 114   Some Media characteristics are hardcoded in VirtioBlkInit() below (like
 115   non-removable media, no restriction on buffer alignment etc); we rely on
 116   those here without explicit mention.
 117
 118   @param[in] Media               The EFI_BLOCK_IO_MEDIA characteristics for
 119                                  this driver instance, extracted from the
 120                                  underlying virtio-blk device at initialization
 121                                  time. We validate the request against this set
 122                                  of attributes.
 123
 124
 125   @param[in] Lba                 Logical Block Address: number of logical
 126                                  blocks to skip from the beginning of the
 127                                  device.
 128
 129   @param[in] PositiveBufferSize  Size of buffer to transfer, in bytes. The
 130                                  caller is responsible to ensure this parameter
 131                                  is positive.
 132
 133   @param[in] RequestIsWrite      TRUE iff data transfer goes from guest to
 134                                  device.
 135
 136
 137   @@return                       Validation result to be forwarded outwards by
 138                                  ReadBlocks() and WriteBlocks, as required by
 139                                  the specs above.
 140
 141 **/
 142 STATIC
 143 EFI_STATUS
 144 EFIAPI
 145 VerifyReadWriteRequest (
 146   IN  EFI_BLOCK_IO_MEDIA *Media,
 147   IN  EFI_LBA            Lba,
 148   IN  UINTN              PositiveBufferSize,
 149   IN  BOOLEAN            RequestIsWrite
 150   )
 151 {
 152   UINTN BlockCount;
 153
 154   ASSERT (PositiveBufferSize > 0);
 155
 156   if (PositiveBufferSize > SIZE_1GB ||
 157       PositiveBufferSize % Media->BlockSize > 0) {
 158     return EFI_BAD_BUFFER_SIZE;
 159   }
 160   BlockCount = PositiveBufferSize / Media->BlockSize;
 161
 162   //
 163   // Avoid unsigned wraparound on either side in the second comparison.
 164   //
 165   if (Lba > Media->LastBlock || BlockCount - 1 > Media->LastBlock - Lba) {
 166     return EFI_INVALID_PARAMETER;
 167   }
 168
 169   if (RequestIsWrite && Media->ReadOnly) {
 170     return EFI_WRITE_PROTECTED;
 171   }
 172
 173   return EFI_SUCCESS;
 174 }
 175
 176
 177
 178
 179 /**
 180
 181   Format a read / write / flush request as three consecutive virtio
 182   descriptors, push them to the host, and poll for the response.
 183
 184   This is the main workhorse function. Two use cases are supported, read/write
 185   and flush. The function may only be called after the request parameters have
 186   been verified by
 187   - specific checks in ReadBlocks() / WriteBlocks() / FlushBlocks(), and
 188   - VerifyReadWriteRequest() (for read/write only).
 189
 190   Parameters handled commonly:
 191
 192     @param[in] Dev             The virtio-blk device the request is targeted
 193                                at.
 194
 195   Flush request:
 196
 197     @param[in] Lba             Must be zero.
 198
 199     @param[in] BufferSize      Must be zero.
 200
 201     @param[in out] Buffer      Ignored by the function.
 202
 203     @param[in] RequestIsWrite  Must be TRUE.
 204
 205   Read/Write request:
 206
 207     @param[in] Lba             Logical Block Address: number of logical blocks
 208                                to skip from the beginning of the device.
 209
 210     @param[in] BufferSize      Size of buffer to transfer, in bytes. The caller
 211                                is responsible to ensure this parameter is
 212                                positive.
 213
 214     @param[in out] Buffer      The guest side area to read data from the device
 215                                into, or write data to the device from.
 216
 217     @param[in] RequestIsWrite  TRUE iff data transfer goes from guest to
 218                                device.
 219
 220   Return values are common to both use cases, and are appropriate to be
 221   forwarded by the EFI_BLOCK_IO_PROTOCOL functions (ReadBlocks(),
 222   WriteBlocks(), FlushBlocks()).
 223
 224
 225   @retval EFI_SUCCESS          Transfer complete.
 226
 227   @retval EFI_DEVICE_ERROR     Failed to notify host side via VirtIo write, or
 228                                unable to parse host response, or host response
 229                                is not VIRTIO_BLK_S_OK or failed to map Buffer
 230                                for a bus master operation.
 231
 232 **/
 233
 234 STATIC
 235 EFI_STATUS
 236 EFIAPI
 237 SynchronousRequest (
 238   IN              VBLK_DEV *Dev,
 239   IN              EFI_LBA  Lba,
 240   IN              UINTN    BufferSize,
 241   IN OUT volatile VOID     *Buffer,
 242   IN              BOOLEAN  RequestIsWrite
 243   )
 244 {
 245   UINT32                  BlockSize;
 246   volatile VIRTIO_BLK_REQ Request;
 247   volatile UINT8          *HostStatus;
 248   VOID                    *HostStatusBuffer;
 249   DESC_INDICES            Indices;
 250   VOID                    *RequestMapping;
 251   VOID                    *StatusMapping;
 252   VOID                    *BufferMapping;
 253   EFI_PHYSICAL_ADDRESS    BufferDeviceAddress;
 254   EFI_PHYSICAL_ADDRESS    HostStatusDeviceAddress;
 255   EFI_PHYSICAL_ADDRESS    RequestDeviceAddress;
 256   EFI_STATUS              Status;
 257   EFI_STATUS              UnmapStatus;
 258
 259   BlockSize = Dev->BlockIoMedia.BlockSize;
 260
 261   //
 262   // Set BufferMapping and BufferDeviceAddress to suppress incorrect
 263   // compiler/analyzer warnings.
 264   //
 265   BufferMapping       = NULL;
 266   BufferDeviceAddress = 0;
 267
 268   //
 269   // ensured by VirtioBlkInit()
 270   //
 271   ASSERT (BlockSize > 0);
 272   ASSERT (BlockSize % 512 == 0);
 273
 274   //
 275   // ensured by contract above, plus VerifyReadWriteRequest()
 276   //
 277   ASSERT (BufferSize % BlockSize == 0);
 278
 279   //
 280   // Prepare virtio-blk request header, setting zero size for flush.
 281   // IO Priority is homogeneously 0.
 282   //
 283   Request.Type   = RequestIsWrite ?
 284                    (BufferSize == 0 ? VIRTIO_BLK_T_FLUSH : VIRTIO_BLK_T_OUT) :
 285                    VIRTIO_BLK_T_IN;
 286   Request.IoPrio = 0;
 287   Request.Sector = MultU64x32(Lba, BlockSize / 512);
 288
 289   //
 290   // Host status is bi-directional (we preset with a value and expect the
 291   // device to update it). Allocate a host status buffer which can be mapped
 292   // to access equally by both processor and the device.
 293   //
 294   Status = Dev->VirtIo->AllocateSharedPages (
 295                           Dev->VirtIo,
 296                           EFI_SIZE_TO_PAGES (sizeof *HostStatus),
 297                           &HostStatusBuffer
 298                           );
 299   if (EFI_ERROR (Status)) {
 300     return EFI_DEVICE_ERROR;
 301   }
 302
 303   HostStatus = HostStatusBuffer;
 304
 305   //
 306   // Map virtio-blk request header (must be done after request header is
 307   // populated)
 308   //
 309   Status = VirtioMapAllBytesInSharedBuffer (
 310              Dev->VirtIo,
 311              VirtioOperationBusMasterRead,
 312              (VOID *) &Request,
 313              sizeof Request,
 314              &RequestDeviceAddress,
 315              &RequestMapping
 316              );
 317   if (EFI_ERROR (Status)) {
 318     Status = EFI_DEVICE_ERROR;
 319     goto FreeHostStatusBuffer;
 320   }
 321
 322   //
 323   // Map data buffer
 324   //
 325   if (BufferSize > 0) {
 326     Status = VirtioMapAllBytesInSharedBuffer (
 327                Dev->VirtIo,
 328                (RequestIsWrite ?
 329                 VirtioOperationBusMasterRead :
 330                 VirtioOperationBusMasterWrite),
 331                (VOID *) Buffer,
 332                BufferSize,
 333                &BufferDeviceAddress,
 334                &BufferMapping
 335                );
 336     if (EFI_ERROR (Status)) {
 337       Status = EFI_DEVICE_ERROR;
 338       goto UnmapRequestBuffer;
 339     }
 340   }
 341
 342   //
 343   // preset a host status for ourselves that we do not accept as success
 344   //
 345   *HostStatus = VIRTIO_BLK_S_IOERR;
 346
 347   //
 348   // Map the Status Buffer with VirtioOperationBusMasterCommonBuffer so that
 349   // both processor and device can access it.
 350   //
 351   Status = VirtioMapAllBytesInSharedBuffer (
 352              Dev->VirtIo,
 353              VirtioOperationBusMasterCommonBuffer,
 354              HostStatusBuffer,
 355              sizeof *HostStatus,
 356              &HostStatusDeviceAddress,
 357              &StatusMapping
 358              );
 359   if (EFI_ERROR (Status)) {
 360     Status = EFI_DEVICE_ERROR;
 361     goto UnmapDataBuffer;
 362   }
 363
 364   VirtioPrepare (&Dev->Ring, &Indices);
 365
 366   //
 367   // ensured by VirtioBlkInit() -- this predicate, in combination with the
 368   // lock-step progress, ensures we don't have to track free descriptors.
 369   //
 370   ASSERT (Dev->Ring.QueueSize >= 3);
 371
 372   //
 373   // virtio-blk header in first desc
 374   //
 375   VirtioAppendDesc (
 376     &Dev->Ring,
 377     RequestDeviceAddress,
 378     sizeof Request,
 379     VRING_DESC_F_NEXT,
 380     &Indices
 381     );
 382
 383   //
 384   // data buffer for read/write in second desc
 385   //
 386   if (BufferSize > 0) {
 387     //
 388     // From virtio-0.9.5, 2.3.2 Descriptor Table:
 389     // "no descriptor chain may be more than 2^32 bytes long in total".
 390     //
 391     // The predicate is ensured by the call contract above (for flush), or
 392     // VerifyReadWriteRequest() (for read/write). It also implies that
 393     // converting BufferSize to UINT32 will not truncate it.
 394     //
 395     ASSERT (BufferSize <= SIZE_1GB);
 396
 397     //
 398     // VRING_DESC_F_WRITE is interpreted from the host's point of view.
 399     //
 400     VirtioAppendDesc (
 401       &Dev->Ring,
 402       BufferDeviceAddress,
 403       (UINT32) BufferSize,
 404       VRING_DESC_F_NEXT | (RequestIsWrite ? 0 : VRING_DESC_F_WRITE),
 405       &Indices
 406       );
 407   }
 408
 409   //
 410   // host status in last (second or third) desc
 411   //
 412   VirtioAppendDesc (
 413     &Dev->Ring,
 414     HostStatusDeviceAddress,
 415     sizeof *HostStatus,
 416     VRING_DESC_F_WRITE,
 417     &Indices
 418     );
 419
 420   //
 421   // virtio-blk's only virtqueue is #0, called "requestq" (see Appendix D).
 422   //
 423   if (VirtioFlush (Dev->VirtIo, 0, &Dev->Ring, &Indices,
 424         NULL) == EFI_SUCCESS &&
 425       *HostStatus == VIRTIO_BLK_S_OK) {
 426     Status = EFI_SUCCESS;
 427   } else {
 428     Status = EFI_DEVICE_ERROR;
 429   }
 430
 431   Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, StatusMapping);
 432
 433 UnmapDataBuffer:
 434   if (BufferSize > 0) {
 435     UnmapStatus = Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, BufferMapping);
 436     if (EFI_ERROR (UnmapStatus) && !RequestIsWrite && !EFI_ERROR (Status)) {
 437       //
 438       // Data from the bus master may not reach the caller; fail the request.
 439       //
 440       Status = EFI_DEVICE_ERROR;
 441     }
 442   }
 443
 444 UnmapRequestBuffer:
 445   Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, RequestMapping);
 446
 447 FreeHostStatusBuffer:
 448   Dev->VirtIo->FreeSharedPages (
 449                  Dev->VirtIo,
 450                  EFI_SIZE_TO_PAGES (sizeof *HostStatus),
 451                  HostStatusBuffer
 452                  );
 453
 454   return Status;
 455 }
 456
 457
 458 /**
 459
 460   ReadBlocks() operation for virtio-blk.
 461
 462   See
 463   - UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 464     Protocol, EFI_BLOCK_IO_PROTOCOL.ReadBlocks().
 465   - Driver Writer's Guide for UEFI 2.3.1 v1.01, 24.2.2. ReadBlocks() and
 466     ReadBlocksEx() Implementation.
 467
 468   Parameter checks and conformant return values are implemented in
 469   VerifyReadWriteRequest() and SynchronousRequest().
 470
 471   A zero BufferSize doesn't seem to be prohibited, so do nothing in that case,
 472   successfully.
 473
 474 **/
 475
 476 EFI_STATUS
 477 EFIAPI
 478 VirtioBlkReadBlocks (
 479   IN  EFI_BLOCK_IO_PROTOCOL *This,
 480   IN  UINT32                MediaId,
 481   IN  EFI_LBA               Lba,
 482   IN  UINTN                 BufferSize,
 483   OUT VOID                  *Buffer
 484   )
 485 {
 486   VBLK_DEV   *Dev;
 487   EFI_STATUS Status;
 488
 489   if (BufferSize == 0) {
 490     return EFI_SUCCESS;
 491   }
 492
 493   Dev = VIRTIO_BLK_FROM_BLOCK_IO (This);
 494   Status = VerifyReadWriteRequest (
 495              &Dev->BlockIoMedia,
 496              Lba,
 497              BufferSize,
 498              FALSE               // RequestIsWrite
 499              );
 500   if (EFI_ERROR (Status)) {
 501     return Status;
 502   }
 503
 504   return SynchronousRequest (
 505            Dev,
 506            Lba,
 507            BufferSize,
 508            Buffer,
 509            FALSE       // RequestIsWrite
 510            );
 511 }
 512
 513 /**
 514
 515   WriteBlocks() operation for virtio-blk.
 516
 517   See
 518   - UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 519     Protocol, EFI_BLOCK_IO_PROTOCOL.WriteBlocks().
 520   - Driver Writer's Guide for UEFI 2.3.1 v1.01, 24.2.3 WriteBlocks() and
 521     WriteBlockEx() Implementation.
 522
 523   Parameter checks and conformant return values are implemented in
 524   VerifyReadWriteRequest() and SynchronousRequest().
 525
 526   A zero BufferSize doesn't seem to be prohibited, so do nothing in that case,
 527   successfully.
 528
 529 **/
 530
 531 EFI_STATUS
 532 EFIAPI
 533 VirtioBlkWriteBlocks (
 534   IN EFI_BLOCK_IO_PROTOCOL *This,
 535   IN UINT32                MediaId,
 536   IN EFI_LBA               Lba,
 537   IN UINTN                 BufferSize,
 538   IN VOID                  *Buffer
 539   )
 540 {
 541   VBLK_DEV   *Dev;
 542   EFI_STATUS Status;
 543
 544   if (BufferSize == 0) {
 545     return EFI_SUCCESS;
 546   }
 547
 548   Dev = VIRTIO_BLK_FROM_BLOCK_IO (This);
 549   Status = VerifyReadWriteRequest (
 550              &Dev->BlockIoMedia,
 551              Lba,
 552              BufferSize,
 553              TRUE                // RequestIsWrite
 554              );
 555   if (EFI_ERROR (Status)) {
 556     return Status;
 557   }
 558
 559   return SynchronousRequest (
 560            Dev,
 561            Lba,
 562            BufferSize,
 563            Buffer,
 564            TRUE        // RequestIsWrite
 565            );
 566 }
 567
 568
 569 /**
 570
 571   FlushBlocks() operation for virtio-blk.
 572
 573   See
 574   - UEFI Spec 2.3.1 + Errata C, 12.8 EFI Block I/O Protocol, 12.8 EFI Block I/O
 575     Protocol, EFI_BLOCK_IO_PROTOCOL.FlushBlocks().
 576   - Driver Writer's Guide for UEFI 2.3.1 v1.01, 24.2.4 FlushBlocks() and
 577     FlushBlocksEx() Implementation.
 578
 579   If the underlying virtio-blk device doesn't support flushing (ie.
 580   write-caching), then this function should not be called by higher layers,
 581   according to EFI_BLOCK_IO_MEDIA characteristics set in VirtioBlkInit().
 582   Should they do nonetheless, we do nothing, successfully.
 583
 584 **/
 585
 586 EFI_STATUS
 587 EFIAPI
 588 VirtioBlkFlushBlocks (
 589   IN EFI_BLOCK_IO_PROTOCOL *This
 590   )
 591 {
 592   VBLK_DEV *Dev;
 593
 594   Dev = VIRTIO_BLK_FROM_BLOCK_IO (This);
 595   return Dev->BlockIoMedia.WriteCaching ?
 596            SynchronousRequest (
 597              Dev,
 598              0,    // Lba
 599              0,    // BufferSize
 600              NULL, // Buffer
 601              TRUE  // RequestIsWrite
 602              ) :
 603            EFI_SUCCESS;
 604 }
 605
 606
 607 /**
 608
 609   Device probe function for this driver.
 610
 611   The DXE core calls this function for any given device in order to see if the
 612   driver can drive the device.
 613
 614   Specs relevant in the general sense:
 615
 616   - UEFI Spec 2.3.1 + Errata C:
 617     - 6.3 Protocol Handler Services -- for accessing the underlying device
 618     - 10.1 EFI Driver Binding Protocol -- for exporting ourselves
 619
 620   - Driver Writer's Guide for UEFI 2.3.1 v1.01:
 621     - 5.1.3.4 OpenProtocol() and CloseProtocol() -- for accessing the
 622       underlying device
 623     - 9 Driver Binding Protocol -- for exporting ourselves
 624
 625   @param[in]  This                The EFI_DRIVER_BINDING_PROTOCOL object
 626                                   incorporating this driver (independently of
 627                                   any device).
 628
 629   @param[in] DeviceHandle         The device to probe.
 630
 631   @param[in] RemainingDevicePath  Relevant only for bus drivers, ignored.
 632
 633
 634   @retval EFI_SUCCESS      The driver supports the device being probed.
 635
 636   @retval EFI_UNSUPPORTED  Based on virtio-blk discovery, we do not support
 637                            the device.
 638
 639   @return                  Error codes from the OpenProtocol() boot service or
 640                            the VirtIo protocol.
 641
 642 **/
 643
 644 EFI_STATUS
 645 EFIAPI
 646 VirtioBlkDriverBindingSupported (
 647   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 648   IN EFI_HANDLE                  DeviceHandle,
 649   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath
 650   )
 651 {
 652   EFI_STATUS          Status;
 653   VIRTIO_DEVICE_PROTOCOL *VirtIo;
 654
 655   //
 656   // Attempt to open the device with the VirtIo set of interfaces. On success,
 657   // the protocol is "instantiated" for the VirtIo device. Covers duplicate
 658   // open attempts (EFI_ALREADY_STARTED).
 659   //
 660   Status = gBS->OpenProtocol (
 661                   DeviceHandle,               // candidate device
 662                   &gVirtioDeviceProtocolGuid, // for generic VirtIo access
 663                   (VOID **)&VirtIo,           // handle to instantiate
 664                   This->DriverBindingHandle,  // requestor driver identity
 665                   DeviceHandle,               // ControllerHandle, according to
 666                                               // the UEFI Driver Model
 667                   EFI_OPEN_PROTOCOL_BY_DRIVER // get exclusive VirtIo access to
 668                                               // the device; to be released
 669                   );
 670   if (EFI_ERROR (Status)) {
 671     return Status;
 672   }
 673
 674   if (VirtIo->SubSystemDeviceId != VIRTIO_SUBSYSTEM_BLOCK_DEVICE) {
 675     Status = EFI_UNSUPPORTED;
 676   }
 677
 678   //
 679   // We needed VirtIo access only transitorily, to see whether we support the
 680   // device or not.
 681   //
 682   gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
 683          This->DriverBindingHandle, DeviceHandle);
 684   return Status;
 685 }
 686
 687
 688 /**
 689
 690   Set up all BlockIo and virtio-blk aspects of this driver for the specified
 691   device.
 692
 693   @param[in out] Dev  The driver instance to configure. The caller is
 694                       responsible for Dev->VirtIo's validity (ie. working IO
 695                       access to the underlying virtio-blk device).
 696
 697   @retval EFI_SUCCESS      Setup complete.
 698
 699   @retval EFI_UNSUPPORTED  The driver is unable to work with the virtio ring or
 700                            virtio-blk attributes the host provides.
 701
 702   @return                  Error codes from VirtioRingInit() or
 703                            VIRTIO_CFG_READ() / VIRTIO_CFG_WRITE or
 704                            VirtioRingMap().
 705
 706 **/
 707
 708 STATIC
 709 EFI_STATUS
 710 EFIAPI
 711 VirtioBlkInit (
 712   IN OUT VBLK_DEV *Dev
 713   )
 714 {
 715   UINT8      NextDevStat;
 716   EFI_STATUS Status;
 717
 718   UINT64     Features;
 719   UINT64     NumSectors;
 720   UINT32     BlockSize;
 721   UINT8      PhysicalBlockExp;
 722   UINT8      AlignmentOffset;
 723   UINT32     OptIoSize;
 724   UINT16     QueueSize;
 725   UINT64     RingBaseShift;
 726
 727   PhysicalBlockExp = 0;
 728   AlignmentOffset = 0;
 729   OptIoSize = 0;
 730
 731   //
 732   // Execute virtio-0.9.5, 2.2.1 Device Initialization Sequence.
 733   //
 734   NextDevStat = 0;             // step 1 -- reset device
 735   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 736   if (EFI_ERROR (Status)) {
 737     goto Failed;
 738   }
 739
 740   NextDevStat |= VSTAT_ACK;    // step 2 -- acknowledge device presence
 741   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 742   if (EFI_ERROR (Status)) {
 743     goto Failed;
 744   }
 745
 746   NextDevStat |= VSTAT_DRIVER; // step 3 -- we know how to drive it
 747   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 748   if (EFI_ERROR (Status)) {
 749     goto Failed;
 750   }
 751
 752   //
 753   // Set Page Size - MMIO VirtIo Specific
 754   //
 755   Status = Dev->VirtIo->SetPageSize (Dev->VirtIo, EFI_PAGE_SIZE);
 756   if (EFI_ERROR (Status)) {
 757     goto Failed;
 758   }
 759
 760   //
 761   // step 4a -- retrieve and validate features
 762   //
 763   Status = Dev->VirtIo->GetDeviceFeatures (Dev->VirtIo, &Features);
 764   if (EFI_ERROR (Status)) {
 765     goto Failed;
 766   }
 767
 768   Status = VIRTIO_CFG_READ (Dev, Capacity, &NumSectors);
 769   if (EFI_ERROR (Status)) {
 770     goto Failed;
 771   }
 772   if (NumSectors == 0) {
 773     Status = EFI_UNSUPPORTED;
 774     goto Failed;
 775   }
 776
 777   if (Features & VIRTIO_BLK_F_BLK_SIZE) {
 778     Status = VIRTIO_CFG_READ (Dev, BlkSize, &BlockSize);
 779     if (EFI_ERROR (Status)) {
 780       goto Failed;
 781     }
 782     if (BlockSize == 0 || BlockSize % 512 != 0 ||
 783         ModU64x32 (NumSectors, BlockSize / 512) != 0) {
 784       //
 785       // We can only handle a logical block consisting of whole sectors,
 786       // and only a disk composed of whole logical blocks.
 787       //
 788       Status = EFI_UNSUPPORTED;
 789       goto Failed;
 790     }
 791   }
 792   else {
 793     BlockSize = 512;
 794   }
 795
 796   if (Features & VIRTIO_BLK_F_TOPOLOGY) {
 797     Status = VIRTIO_CFG_READ (Dev, Topology.PhysicalBlockExp,
 798                &PhysicalBlockExp);
 799     if (EFI_ERROR (Status)) {
 800       goto Failed;
 801     }
 802     if (PhysicalBlockExp >= 32) {
 803       Status = EFI_UNSUPPORTED;
 804       goto Failed;
 805     }
 806
 807     Status = VIRTIO_CFG_READ (Dev, Topology.AlignmentOffset, &AlignmentOffset);
 808     if (EFI_ERROR (Status)) {
 809       goto Failed;
 810     }
 811
 812     Status = VIRTIO_CFG_READ (Dev, Topology.OptIoSize, &OptIoSize);
 813     if (EFI_ERROR (Status)) {
 814       goto Failed;
 815     }
 816   }
 817
 818   Features &= VIRTIO_BLK_F_BLK_SIZE | VIRTIO_BLK_F_TOPOLOGY | VIRTIO_BLK_F_RO |
 819               VIRTIO_BLK_F_FLUSH | VIRTIO_F_VERSION_1 |
 820               VIRTIO_F_IOMMU_PLATFORM;
 821
 822   //
 823   // In virtio-1.0, feature negotiation is expected to complete before queue
 824   // discovery, and the device can also reject the selected set of features.
 825   //
 826   if (Dev->VirtIo->Revision >= VIRTIO_SPEC_REVISION (1, 0, 0)) {
 827     Status = Virtio10WriteFeatures (Dev->VirtIo, Features, &NextDevStat);
 828     if (EFI_ERROR (Status)) {
 829       goto Failed;
 830     }
 831   }
 832
 833   //
 834   // step 4b -- allocate virtqueue
 835   //
 836   Status = Dev->VirtIo->SetQueueSel (Dev->VirtIo, 0);
 837   if (EFI_ERROR (Status)) {
 838     goto Failed;
 839   }
 840   Status = Dev->VirtIo->GetQueueNumMax (Dev->VirtIo, &QueueSize);
 841   if (EFI_ERROR (Status)) {
 842     goto Failed;
 843   }
 844   if (QueueSize < 3) { // SynchronousRequest() uses at most three descriptors
 845     Status = EFI_UNSUPPORTED;
 846     goto Failed;
 847   }
 848
 849   Status = VirtioRingInit (Dev->VirtIo, QueueSize, &Dev->Ring);
 850   if (EFI_ERROR (Status)) {
 851     goto Failed;
 852   }
 853
 854   //
 855   // If anything fails from here on, we must release the ring resources
 856   //
 857   Status = VirtioRingMap (
 858              Dev->VirtIo,
 859              &Dev->Ring,
 860              &RingBaseShift,
 861              &Dev->RingMap
 862              );
 863   if (EFI_ERROR (Status)) {
 864     goto ReleaseQueue;
 865   }
 866
 867   //
 868   // Additional steps for MMIO: align the queue appropriately, and set the
 869   // size. If anything fails from here on, we must unmap the ring resources.
 870   //
 871   Status = Dev->VirtIo->SetQueueNum (Dev->VirtIo, QueueSize);
 872   if (EFI_ERROR (Status)) {
 873     goto UnmapQueue;
 874   }
 875
 876   Status = Dev->VirtIo->SetQueueAlign (Dev->VirtIo, EFI_PAGE_SIZE);
 877   if (EFI_ERROR (Status)) {
 878     goto UnmapQueue;
 879   }
 880
 881   //
 882   // step 4c -- Report GPFN (guest-physical frame number) of queue.
 883   //
 884   Status = Dev->VirtIo->SetQueueAddress (
 885                           Dev->VirtIo,
 886                           &Dev->Ring,
 887                           RingBaseShift
 888                           );
 889   if (EFI_ERROR (Status)) {
 890     goto UnmapQueue;
 891   }
 892
 893
 894   //
 895   // step 5 -- Report understood features.
 896   //
 897   if (Dev->VirtIo->Revision < VIRTIO_SPEC_REVISION (1, 0, 0)) {
 898     Features &= ~(UINT64)(VIRTIO_F_VERSION_1 | VIRTIO_F_IOMMU_PLATFORM);
 899     Status = Dev->VirtIo->SetGuestFeatures (Dev->VirtIo, Features);
 900     if (EFI_ERROR (Status)) {
 901       goto UnmapQueue;
 902     }
 903   }
 904
 905   //
 906   // step 6 -- initialization complete
 907   //
 908   NextDevStat |= VSTAT_DRIVER_OK;
 909   Status = Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 910   if (EFI_ERROR (Status)) {
 911     goto UnmapQueue;
 912   }
 913
 914   //
 915   // Populate the exported interface's attributes; see UEFI spec v2.4, 12.9 EFI
 916   // Block I/O Protocol.
 917   //
 918   Dev->BlockIo.Revision              = 0;
 919   Dev->BlockIo.Media                 = &Dev->BlockIoMedia;
 920   Dev->BlockIo.Reset                 = &VirtioBlkReset;
 921   Dev->BlockIo.ReadBlocks            = &VirtioBlkReadBlocks;
 922   Dev->BlockIo.WriteBlocks           = &VirtioBlkWriteBlocks;
 923   Dev->BlockIo.FlushBlocks           = &VirtioBlkFlushBlocks;
 924   Dev->BlockIoMedia.MediaId          = 0;
 925   Dev->BlockIoMedia.RemovableMedia   = FALSE;
 926   Dev->BlockIoMedia.MediaPresent     = TRUE;
 927   Dev->BlockIoMedia.LogicalPartition = FALSE;
 928   Dev->BlockIoMedia.ReadOnly         = (BOOLEAN) ((Features & VIRTIO_BLK_F_RO) != 0);
 929   Dev->BlockIoMedia.WriteCaching     = (BOOLEAN) ((Features & VIRTIO_BLK_F_FLUSH) != 0);
 930   Dev->BlockIoMedia.BlockSize        = BlockSize;
 931   Dev->BlockIoMedia.IoAlign          = 0;
 932   Dev->BlockIoMedia.LastBlock        = DivU64x32 (NumSectors,
 933                                          BlockSize / 512) - 1;
 934
 935   DEBUG ((DEBUG_INFO, "%a: LbaSize=0x%x[B] NumBlocks=0x%Lx[Lba]\n",
 936     __FUNCTION__, Dev->BlockIoMedia.BlockSize,
 937     Dev->BlockIoMedia.LastBlock + 1));
 938
 939   if (Features & VIRTIO_BLK_F_TOPOLOGY) {
 940     Dev->BlockIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
 941
 942     Dev->BlockIoMedia.LowestAlignedLba = AlignmentOffset;
 943     Dev->BlockIoMedia.LogicalBlocksPerPhysicalBlock = 1u << PhysicalBlockExp;
 944     Dev->BlockIoMedia.OptimalTransferLengthGranularity = OptIoSize;
 945
 946     DEBUG ((DEBUG_INFO, "%a: FirstAligned=0x%Lx[Lba] PhysBlkSize=0x%x[Lba]\n",
 947       __FUNCTION__, Dev->BlockIoMedia.LowestAlignedLba,
 948       Dev->BlockIoMedia.LogicalBlocksPerPhysicalBlock));
 949     DEBUG ((DEBUG_INFO, "%a: OptimalTransferLengthGranularity=0x%x[Lba]\n",
 950       __FUNCTION__, Dev->BlockIoMedia.OptimalTransferLengthGranularity));
 951   }
 952   return EFI_SUCCESS;
 953
 954 UnmapQueue:
 955   Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RingMap);
 956
 957 ReleaseQueue:
 958   VirtioRingUninit (Dev->VirtIo, &Dev->Ring);
 959
 960 Failed:
 961   //
 962   // Notify the host about our failure to setup: virtio-0.9.5, 2.2.2.1 Device
 963   // Status. VirtIo access failure here should not mask the original error.
 964   //
 965   NextDevStat |= VSTAT_FAILED;
 966   Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, NextDevStat);
 967
 968   return Status; // reached only via Failed above
 969 }
 970
 971
 972 /**
 973
 974   Uninitialize the internals of a virtio-blk device that has been successfully
 975   set up with VirtioBlkInit().
 976
 977   @param[in out]  Dev  The device to clean up.
 978
 979 **/
 980
 981 STATIC
 982 VOID
 983 EFIAPI
 984 VirtioBlkUninit (
 985   IN OUT VBLK_DEV *Dev
 986   )
 987 {
 988   //
 989   // Reset the virtual device -- see virtio-0.9.5, 2.2.2.1 Device Status. When
 990   // VIRTIO_CFG_WRITE() returns, the host will have learned to stay away from
 991   // the old comms area.
 992   //
 993   Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);
 994
 995   Dev->VirtIo->UnmapSharedBuffer (Dev->VirtIo, Dev->RingMap);
 996   VirtioRingUninit (Dev->VirtIo, &Dev->Ring);
 997
 998   SetMem (&Dev->BlockIo,      sizeof Dev->BlockIo,      0x00);
 999   SetMem (&Dev->BlockIoMedia, sizeof Dev->BlockIoMedia, 0x00);
1000 }
1001
1002
1003 /**
1004
1005   Event notification function enqueued by ExitBootServices().
1006
1007   @param[in] Event    Event whose notification function is being invoked.
1008
1009   @param[in] Context  Pointer to the VBLK_DEV structure.
1010
1011 **/
1012
1013 STATIC
1014 VOID
1015 EFIAPI
1016 VirtioBlkExitBoot (
1017   IN  EFI_EVENT Event,
1018   IN  VOID      *Context
1019   )
1020 {
1021   VBLK_DEV *Dev;
1022
1023   DEBUG ((DEBUG_VERBOSE, "%a: Context=0x%p\n", __FUNCTION__, Context));
1024   //
1025   // Reset the device. This causes the hypervisor to forget about the virtio
1026   // ring.
1027   //
1028   // We allocated said ring in EfiBootServicesData type memory, and code
1029   // executing after ExitBootServices() is permitted to overwrite it.
1030   //
1031   Dev = Context;
1032   Dev->VirtIo->SetDeviceStatus (Dev->VirtIo, 0);
1033 }
1034
1035 /**
1036
1037   After we've pronounced support for a specific device in
1038   DriverBindingSupported(), we start managing said device (passed in by the
1039   Driver Execution Environment) with the following service.
1040
1041   See DriverBindingSupported() for specification references.
1042
1043   @param[in]  This                The EFI_DRIVER_BINDING_PROTOCOL object
1044                                   incorporating this driver (independently of
1045                                   any device).
1046
1047   @param[in] DeviceHandle         The supported device to drive.
1048
1049   @param[in] RemainingDevicePath  Relevant only for bus drivers, ignored.
1050
1051
1052   @retval EFI_SUCCESS           Driver instance has been created and
1053                                 initialized  for the virtio-blk device, it
1054                                 is now accessible via EFI_BLOCK_IO_PROTOCOL.
1055
1056   @retval EFI_OUT_OF_RESOURCES  Memory allocation failed.
1057
1058   @return                       Error codes from the OpenProtocol() boot
1059                                 service, the VirtIo protocol, VirtioBlkInit(),
1060                                 or the InstallProtocolInterface() boot service.
1061
1062 **/
1063
1064 EFI_STATUS
1065 EFIAPI
1066 VirtioBlkDriverBindingStart (
1067   IN EFI_DRIVER_BINDING_PROTOCOL *This,
1068   IN EFI_HANDLE                  DeviceHandle,
1069   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath
1070   )
1071 {
1072   VBLK_DEV   *Dev;
1073   EFI_STATUS Status;
1074
1075   Dev = (VBLK_DEV *) AllocateZeroPool (sizeof *Dev);
1076   if (Dev == NULL) {
1077     return EFI_OUT_OF_RESOURCES;
1078   }
1079
1080   Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
1081                   (VOID **)&Dev->VirtIo, This->DriverBindingHandle,
1082                   DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
1083   if (EFI_ERROR (Status)) {
1084     goto FreeVirtioBlk;
1085   }
1086
1087   //
1088   // VirtIo access granted, configure virtio-blk device.
1089   //
1090   Status = VirtioBlkInit (Dev);
1091   if (EFI_ERROR (Status)) {
1092     goto CloseVirtIo;
1093   }
1094
1095   Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK,
1096                   &VirtioBlkExitBoot, Dev, &Dev->ExitBoot);
1097   if (EFI_ERROR (Status)) {
1098     goto UninitDev;
1099   }
1100
1101   //
1102   // Setup complete, attempt to export the driver instance's BlockIo interface.
1103   //
1104   Dev->Signature = VBLK_SIG;
1105   Status = gBS->InstallProtocolInterface (&DeviceHandle,
1106                   &gEfiBlockIoProtocolGuid, EFI_NATIVE_INTERFACE,
1107                   &Dev->BlockIo);
1108   if (EFI_ERROR (Status)) {
1109     goto CloseExitBoot;
1110   }
1111
1112   return EFI_SUCCESS;
1113
1114 CloseExitBoot:
1115   gBS->CloseEvent (Dev->ExitBoot);
1116
1117 UninitDev:
1118   VirtioBlkUninit (Dev);
1119
1120 CloseVirtIo:
1121   gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
1122          This->DriverBindingHandle, DeviceHandle);
1123
1124 FreeVirtioBlk:
1125   FreePool (Dev);
1126
1127   return Status;
1128 }
1129
1130
1131 /**
1132
1133   Stop driving a virtio-blk device and remove its BlockIo interface.
1134
1135   This function replays the success path of DriverBindingStart() in reverse.
1136   The host side virtio-blk device is reset, so that the OS boot loader or the
1137   OS may reinitialize it.
1138
1139   @param[in] This               The EFI_DRIVER_BINDING_PROTOCOL object
1140                                 incorporating this driver (independently of any
1141                                 device).
1142
1143   @param[in] DeviceHandle       Stop driving this device.
1144
1145   @param[in] NumberOfChildren   Since this function belongs to a device driver
1146                                 only (as opposed to a bus driver), the caller
1147                                 environment sets NumberOfChildren to zero, and
1148                                 we ignore it.
1149
1150   @param[in] ChildHandleBuffer  Ignored (corresponding to NumberOfChildren).
1151
1152 **/
1153
1154 EFI_STATUS
1155 EFIAPI
1156 VirtioBlkDriverBindingStop (
1157   IN EFI_DRIVER_BINDING_PROTOCOL *This,
1158   IN EFI_HANDLE                  DeviceHandle,
1159   IN UINTN                       NumberOfChildren,
1160   IN EFI_HANDLE                  *ChildHandleBuffer
1161   )
1162 {
1163   EFI_STATUS            Status;
1164   EFI_BLOCK_IO_PROTOCOL *BlockIo;
1165   VBLK_DEV              *Dev;
1166
1167   Status = gBS->OpenProtocol (
1168                   DeviceHandle,                  // candidate device
1169                   &gEfiBlockIoProtocolGuid,      // retrieve the BlockIo iface
1170                   (VOID **)&BlockIo,             // target pointer
1171                   This->DriverBindingHandle,     // requestor driver identity
1172                   DeviceHandle,                  // requesting lookup for dev.
1173                   EFI_OPEN_PROTOCOL_GET_PROTOCOL // lookup only, no ref. added
1174                   );
1175   if (EFI_ERROR (Status)) {
1176     return Status;
1177   }
1178
1179   Dev = VIRTIO_BLK_FROM_BLOCK_IO (BlockIo);
1180
1181   //
1182   // Handle Stop() requests for in-use driver instances gracefully.
1183   //
1184   Status = gBS->UninstallProtocolInterface (DeviceHandle,
1185                   &gEfiBlockIoProtocolGuid, &Dev->BlockIo);
1186   if (EFI_ERROR (Status)) {
1187     return Status;
1188   }
1189
1190   gBS->CloseEvent (Dev->ExitBoot);
1191
1192   VirtioBlkUninit (Dev);
1193
1194   gBS->CloseProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
1195          This->DriverBindingHandle, DeviceHandle);
1196
1197   FreePool (Dev);
1198
1199   return EFI_SUCCESS;
1200 }
1201
1202
1203 //
1204 // The static object that groups the Supported() (ie. probe), Start() and
1205 // Stop() functions of the driver together. Refer to UEFI Spec 2.3.1 + Errata
1206 // C, 10.1 EFI Driver Binding Protocol.
1207 //
1208 STATIC EFI_DRIVER_BINDING_PROTOCOL gDriverBinding = {
1209   &VirtioBlkDriverBindingSupported,
1210   &VirtioBlkDriverBindingStart,
1211   &VirtioBlkDriverBindingStop,
1212   0x10, // Version, must be in [0x10 .. 0xFFFFFFEF] for IHV-developed drivers
1213   NULL, // ImageHandle, to be overwritten by
1214         // EfiLibInstallDriverBindingComponentName2() in VirtioBlkEntryPoint()
1215   NULL  // DriverBindingHandle, ditto
1216 };
1217
1218
1219 //
1220 // The purpose of the following scaffolding (EFI_COMPONENT_NAME_PROTOCOL and
1221 // EFI_COMPONENT_NAME2_PROTOCOL implementation) is to format the driver's name
1222 // in English, for display on standard console devices. This is recommended for
1223 // UEFI drivers that follow the UEFI Driver Model. Refer to the Driver Writer's
1224 // Guide for UEFI 2.3.1 v1.01, 11 UEFI Driver and Controller Names.
1225 //
1226 // Device type names ("Virtio Block Device") are not formatted because the
1227 // driver supports only that device type. Therefore the driver name suffices
1228 // for unambiguous identification.
1229 //
1230
1231 STATIC
1232 EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
1233   { "eng;en", L"Virtio Block Driver" },
1234   { NULL,     NULL                   }
1235 };
1236
1237 STATIC
1238 EFI_COMPONENT_NAME_PROTOCOL gComponentName;
1239
1240 EFI_STATUS
1241 EFIAPI
1242 VirtioBlkGetDriverName (
1243   IN  EFI_COMPONENT_NAME_PROTOCOL *This,
1244   IN  CHAR8                       *Language,
1245   OUT CHAR16                      **DriverName
1246   )
1247 {
1248   return LookupUnicodeString2 (
1249            Language,
1250            This->SupportedLanguages,
1251            mDriverNameTable,
1252            DriverName,
1253            (BOOLEAN)(This == &gComponentName) // Iso639Language
1254            );
1255 }
1256
1257 EFI_STATUS
1258 EFIAPI
1259 VirtioBlkGetDeviceName (
1260   IN  EFI_COMPONENT_NAME_PROTOCOL *This,
1261   IN  EFI_HANDLE                  DeviceHandle,
1262   IN  EFI_HANDLE                  ChildHandle,
1263   IN  CHAR8                       *Language,
1264   OUT CHAR16                      **ControllerName
1265   )
1266 {
1267   return EFI_UNSUPPORTED;
1268 }
1269
1270 STATIC
1271 EFI_COMPONENT_NAME_PROTOCOL gComponentName = {
1272   &VirtioBlkGetDriverName,
1273   &VirtioBlkGetDeviceName,
1274   "eng" // SupportedLanguages, ISO 639-2 language codes
1275 };
1276
1277 STATIC
1278 EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {
1279   (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)     &VirtioBlkGetDriverName,
1280   (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) &VirtioBlkGetDeviceName,
1281   "en" // SupportedLanguages, RFC 4646 language codes
1282 };
1283
1284
1285 //
1286 // Entry point of this driver.
1287 //
1288 EFI_STATUS
1289 EFIAPI
1290 VirtioBlkEntryPoint (
1291   IN EFI_HANDLE       ImageHandle,
1292   IN EFI_SYSTEM_TABLE *SystemTable
1293   )
1294 {
1295   return EfiLibInstallDriverBindingComponentName2 (
1296            ImageHandle,
1297            SystemTable,
1298            &gDriverBinding,
1299            ImageHandle,
1300            &gComponentName,
1301            &gComponentName2
1302            );
1303 }
1304