OvmfPkg/Virtio10Dxe/Virtio10.c

   1 /** @file
   2   A non-transitional driver for VirtIo 1.0 PCI devices.
   3
   4   Copyright (C) 2016, Red Hat, Inc.
   5   Copyright (C) 2017, AMD Inc, All rights reserved.<BR>
   6
   7   This program and the accompanying materials are licensed and made available
   8   under the terms and conditions of the BSD License which accompanies this
   9   distribution. The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
  13   WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14 **/
  15
  16 #include <IndustryStandard/Pci.h>
  17 #include <IndustryStandard/Virtio.h>
  18 #include <Protocol/PciIo.h>
  19 #include <Protocol/PciRootBridgeIo.h>
  20 #include <Protocol/VirtioDevice.h>
  21 #include <Library/BaseMemoryLib.h>
  22 #include <Library/DebugLib.h>
  23 #include <Library/MemoryAllocationLib.h>
  24 #include <Library/UefiBootServicesTableLib.h>
  25 #include <Library/UefiLib.h>
  26
  27 #include "Virtio10.h"
  28
  29
  30 //
  31 // Utility functions
  32 //
  33
  34 /**
  35   Transfer data between the caller and a register in a virtio-1.0 register
  36   block.
  37
  38   @param[in]     PciIo        The EFI_PCI_IO_PROTOCOL instance that represents
  39                               the device.
  40
  41   @param[in]     Config       The "fat pointer" structure that identifies the
  42                               register block to access.
  43
  44   @param[in]     Write        TRUE if the register should be written, FALSE if
  45                               the register should be read.
  46
  47   @param[in]     FieldOffset  The offset of the register within the register
  48                               block.
  49
  50   @param[in]     FieldSize    The size of the register within the register
  51                               block. Can be one of 1, 2, 4 and 8. Accesses to
  52                               8-byte registers are broken up into two 4-byte
  53                               accesses.
  54
  55   @param[in,out] Buffer       When Write is TRUE, the register is written with
  56                               data from Buffer. When Write is FALSE, the caller
  57                               receives the register value into Buffer.
  58
  59   @retval  EFI_SUCCESS            Register access successful.
  60
  61   @retval  EFI_INVALID_PARAMETER  The register block pointed-to by Config
  62                                   doesn't exist; or FieldOffset and FieldSize
  63                                   would overflow the register block; or
  64                                   FieldSize is invalid.
  65
  66   @return                         Error codes from
  67                                   EFI_PCI_IO_PROTOCOL.(Io|Mem).(Read|Write)
  68                                   member functions.
  69 **/
  70 STATIC
  71 EFI_STATUS
  72 Virtio10Transfer (
  73   IN     EFI_PCI_IO_PROTOCOL *PciIo,
  74   IN     VIRTIO_1_0_CONFIG   *Config,
  75   IN     BOOLEAN             Write,
  76   IN     UINTN               FieldOffset,
  77   IN     UINTN               FieldSize,
  78   IN OUT VOID                *Buffer
  79   )
  80 {
  81   UINTN                      Count;
  82   EFI_PCI_IO_PROTOCOL_WIDTH  Width;
  83   EFI_PCI_IO_PROTOCOL_ACCESS *BarType;
  84   EFI_PCI_IO_PROTOCOL_IO_MEM Access;
  85
  86   if (!Config->Exists ||
  87       FieldSize > Config->Length ||
  88       FieldOffset > Config->Length - FieldSize) {
  89     return EFI_INVALID_PARAMETER;
  90   }
  91
  92   Count = 1;
  93   switch (FieldSize) {
  94     case 1:
  95       Width = EfiPciIoWidthUint8;
  96       break;
  97
  98     case 2:
  99       Width = EfiPciIoWidthUint16;
 100       break;
 101
 102     case 8:
 103       Count = 2;
 104       //
 105       // fall through
 106       //
 107
 108     case 4:
 109       Width = EfiPciIoWidthUint32;
 110       break;
 111
 112     default:
 113       return EFI_INVALID_PARAMETER;
 114   }
 115
 116   BarType = (Config->BarType == Virtio10BarTypeMem) ? &PciIo->Mem : &PciIo->Io;
 117   Access = Write ? BarType->Write : BarType->Read;
 118
 119   return Access (PciIo, Width, Config->Bar, Config->Offset + FieldOffset,
 120            Count, Buffer);
 121 }
 122
 123
 124 /**
 125   Determine if a PCI BAR is IO or MMIO.
 126
 127   @param[in]  PciIo     The EFI_PCI_IO_PROTOCOL instance that represents the
 128                         device.
 129
 130   @param[in]  BarIndex  The number of the BAR whose type the caller is
 131                         interested in.
 132
 133   @param[out] BarType   On output, a VIRTIO_1_0_BAR_TYPE value that gives the
 134                         type of the BAR.
 135
 136   @retval EFI_SUCCESS      The BAR type has been recognized and stored in
 137                            BarType.
 138
 139   @retval EFI_UNSUPPORTED  The BAR type couldn't be identified.
 140
 141   @return                  Error codes from
 142                            EFI_PCI_IO_PROTOCOL.GetBarAttributes().
 143 **/
 144 STATIC
 145 EFI_STATUS
 146 GetBarType (
 147   IN  EFI_PCI_IO_PROTOCOL *PciIo,
 148   IN  UINT8               BarIndex,
 149   OUT VIRTIO_1_0_BAR_TYPE *BarType
 150   )
 151 {
 152   EFI_STATUS Status;
 153   VOID       *Resources;
 154
 155   Status = PciIo->GetBarAttributes (PciIo, BarIndex, NULL, &Resources);
 156   if (EFI_ERROR (Status)) {
 157     return Status;
 158   }
 159
 160   Status = EFI_UNSUPPORTED;
 161
 162   if (*(UINT8 *)Resources == ACPI_QWORD_ADDRESS_SPACE_DESCRIPTOR) {
 163     EFI_ACPI_QWORD_ADDRESS_SPACE_DESCRIPTOR *Descriptor;
 164
 165     Descriptor = Resources;
 166     switch (Descriptor->ResType) {
 167     case ACPI_ADDRESS_SPACE_TYPE_MEM:
 168       *BarType = Virtio10BarTypeMem;
 169       Status = EFI_SUCCESS;
 170       break;
 171
 172     case ACPI_ADDRESS_SPACE_TYPE_IO:
 173       *BarType = Virtio10BarTypeIo;
 174       Status = EFI_SUCCESS;
 175       break;
 176
 177     default:
 178       break;
 179     }
 180   }
 181
 182   FreePool (Resources);
 183   return Status;
 184 }
 185
 186
 187 /**
 188   Read a slice from PCI config space at the given offset, then advance the
 189   offset.
 190
 191   @param [in]     PciIo   The EFI_PCI_IO_PROTOCOL instance that represents the
 192                           device.
 193
 194   @param [in,out] Offset  On input, the offset in PCI config space to start
 195                           reading from. On output, the offset of the first byte
 196                           that was not read. On error, Offset is not modified.
 197
 198   @param [in]     Size    The number of bytes to read.
 199
 200   @param [out]    Buffer  On output, the bytes read from PCI config space are
 201                           stored in this object.
 202
 203   @retval EFI_SUCCESS  Size bytes have been transferred from PCI config space
 204                        (from Offset) to Buffer, and Offset has been incremented
 205                        by Size.
 206
 207   @return              Error codes from PciIo->Pci.Read().
 208 **/
 209 STATIC
 210 EFI_STATUS
 211 ReadConfigSpace (
 212   IN     EFI_PCI_IO_PROTOCOL *PciIo,
 213   IN OUT UINT32              *Offset,
 214   IN     UINTN               Size,
 215      OUT VOID                *Buffer
 216   )
 217 {
 218   EFI_STATUS Status;
 219
 220   Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, *Offset, Size, Buffer);
 221   if (EFI_ERROR (Status)) {
 222     return Status;
 223   }
 224   *Offset += (UINT32)Size;
 225   return EFI_SUCCESS;
 226 }
 227
 228
 229 /*
 230   Traverse the PCI capabilities list of a virtio-1.0 device, and capture the
 231   locations of the interesting virtio-1.0 register blocks.
 232
 233   @param[in,out] Device         The VIRTIO_1_0_DEV structure that identifies
 234                                 the device. On input, the caller is responsible
 235                                 that the Device->PciIo member be live, and that
 236                                 the CommonConfig, NotifyConfig,
 237                                 NotifyOffsetMultiplier and SpecificConfig
 238                                 members be zeroed. On output,  said members
 239                                 will have been updated from the PCI
 240                                 capabilities found.
 241
 242   @param[in]     CapabilityPtr  The offset of the first capability in PCI
 243                                 config space, taken from the standard PCI
 244                                 device header.
 245
 246   @retval EFI_SUCCESS  Traversal successful.
 247
 248   @return              Error codes from the ReadConfigSpace() and GetBarType()
 249                        helper functions.
 250 */
 251 STATIC
 252 EFI_STATUS
 253 ParseCapabilities (
 254   IN OUT VIRTIO_1_0_DEV *Device,
 255   IN     UINT8          CapabilityPtr
 256   )
 257 {
 258   UINT32              Offset;
 259   VIRTIO_PCI_CAP_LINK CapLink;
 260
 261   for (Offset = CapabilityPtr & 0xFC;
 262        Offset > 0;
 263        Offset = CapLink.CapNext & 0xFC
 264        ) {
 265     EFI_STATUS        Status;
 266     UINT8             CapLen;
 267     VIRTIO_PCI_CAP    VirtIoCap;
 268     VIRTIO_1_0_CONFIG *ParsedConfig;
 269
 270     //
 271     // Read capability identifier and link to next capability.
 272     //
 273     Status = ReadConfigSpace (Device->PciIo, &Offset, sizeof CapLink,
 274                &CapLink);
 275     if (EFI_ERROR (Status)) {
 276       return Status;
 277     }
 278     if (CapLink.CapId != 0x09) {
 279       //
 280       // Not a vendor-specific capability, move to the next one.
 281       //
 282       continue;
 283     }
 284
 285     //
 286     // Big enough to accommodate a VIRTIO_PCI_CAP structure?
 287     //
 288     Status = ReadConfigSpace (Device->PciIo, &Offset, sizeof CapLen, &CapLen);
 289     if (EFI_ERROR (Status)) {
 290       return Status;
 291     }
 292     if (CapLen < sizeof CapLink + sizeof CapLen + sizeof VirtIoCap) {
 293       //
 294       // Too small, move to next.
 295       //
 296       continue;
 297     }
 298
 299     //
 300     // Read interesting part of capability.
 301     //
 302     Status = ReadConfigSpace (Device->PciIo, &Offset, sizeof VirtIoCap,
 303                &VirtIoCap);
 304     if (EFI_ERROR (Status)) {
 305       return Status;
 306     }
 307     switch (VirtIoCap.ConfigType) {
 308     case VIRTIO_PCI_CAP_COMMON_CFG:
 309       ParsedConfig = &Device->CommonConfig;
 310       break;
 311     case VIRTIO_PCI_CAP_NOTIFY_CFG:
 312       ParsedConfig = &Device->NotifyConfig;
 313       break;
 314     case VIRTIO_PCI_CAP_DEVICE_CFG:
 315       ParsedConfig = &Device->SpecificConfig;
 316       break;
 317     default:
 318       //
 319       // Capability is not interesting.
 320       //
 321       continue;
 322     }
 323
 324     //
 325     // Save the location of the register block into ParsedConfig.
 326     //
 327     Status = GetBarType (Device->PciIo, VirtIoCap.Bar, &ParsedConfig->BarType);
 328     if (EFI_ERROR (Status)) {
 329       return Status;
 330     }
 331     ParsedConfig->Bar    = VirtIoCap.Bar;
 332     ParsedConfig->Offset = VirtIoCap.Offset;
 333     ParsedConfig->Length = VirtIoCap.Length;
 334
 335     if (VirtIoCap.ConfigType == VIRTIO_PCI_CAP_NOTIFY_CFG) {
 336       //
 337       // This capability has an additional field called NotifyOffsetMultiplier;
 338       // parse it too.
 339       //
 340       if (CapLen < sizeof CapLink + sizeof CapLen + sizeof VirtIoCap +
 341                    sizeof Device->NotifyOffsetMultiplier) {
 342         //
 343         // Too small, move to next.
 344         //
 345         continue;
 346       }
 347
 348       Status = ReadConfigSpace (Device->PciIo, &Offset,
 349                  sizeof Device->NotifyOffsetMultiplier,
 350                  &Device->NotifyOffsetMultiplier);
 351       if (EFI_ERROR (Status)) {
 352         return Status;
 353       }
 354     }
 355
 356     //
 357     // Capability parsed successfully.
 358     //
 359     ParsedConfig->Exists = TRUE;
 360   }
 361
 362   return EFI_SUCCESS;
 363 }
 364
 365
 366 /**
 367   Accumulate the BAR type of a virtio-1.0 register block into a UINT64
 368   attribute map, such that the latter is suitable for enabling IO / MMIO
 369   decoding with EFI_PCI_IO_PROTOCOL.Attributes().
 370
 371   @param[in]     Config      The "fat pointer" structure that identifies the
 372                              register block. It is allowed for the register
 373                              block not to exist.
 374
 375   @param[in,out] Attributes  On output, if the register block exists,
 376                              EFI_PCI_IO_ATTRIBUTE_MEMORY or
 377                              EFI_PCI_IO_ATTRIBUTE_IO is OR-ed into Attributes,
 378                              according to the register block's BAR type.
 379 **/
 380 STATIC
 381 VOID
 382 UpdateAttributes (
 383   IN     VIRTIO_1_0_CONFIG *Config,
 384   IN OUT UINT64            *Attributes
 385   )
 386 {
 387   if (Config->Exists) {
 388     *Attributes |= (Config->BarType == Virtio10BarTypeMem) ?
 389                      EFI_PCI_IO_ATTRIBUTE_MEMORY:
 390                      EFI_PCI_IO_ATTRIBUTE_IO;
 391   }
 392 }
 393
 394
 395 //
 396 // VIRTIO_DEVICE_PROTOCOL member functions
 397 //
 398
 399 STATIC
 400 EFI_STATUS
 401 EFIAPI
 402 Virtio10GetDeviceFeatures (
 403   IN VIRTIO_DEVICE_PROTOCOL *This,
 404   OUT UINT64                *DeviceFeatures
 405   )
 406 {
 407   VIRTIO_1_0_DEV *Dev;
 408   UINT32         Selector;
 409   UINT32         Features32[2];
 410
 411   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 412
 413   for (Selector = 0; Selector < 2; ++Selector) {
 414     EFI_STATUS Status;
 415
 416     //
 417     // Select the low or high half of the features.
 418     //
 419     Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 420                OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceFeatureSelect),
 421                sizeof Selector, &Selector);
 422     if (EFI_ERROR (Status)) {
 423       return Status;
 424     }
 425
 426     //
 427     // Fetch that half.
 428     //
 429     Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, FALSE,
 430                OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceFeature),
 431                sizeof Features32[Selector], &Features32[Selector]);
 432     if (EFI_ERROR (Status)) {
 433       return Status;
 434     }
 435   }
 436
 437   *DeviceFeatures = LShiftU64 (Features32[1], 32) | Features32[0];
 438   return EFI_SUCCESS;
 439 }
 440
 441
 442 STATIC
 443 EFI_STATUS
 444 EFIAPI
 445 Virtio10SetGuestFeatures (
 446   IN VIRTIO_DEVICE_PROTOCOL  *This,
 447   IN UINT64                   Features
 448   )
 449 {
 450   VIRTIO_1_0_DEV *Dev;
 451   UINT32         Selector;
 452   UINT32         Features32[2];
 453
 454   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 455
 456   Features32[0] = (UINT32)Features;
 457   Features32[1] = (UINT32)RShiftU64 (Features, 32);
 458
 459   for (Selector = 0; Selector < 2; ++Selector) {
 460     EFI_STATUS Status;
 461
 462     //
 463     // Select the low or high half of the features.
 464     //
 465     Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 466                OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DriverFeatureSelect),
 467                sizeof Selector, &Selector);
 468     if (EFI_ERROR (Status)) {
 469       return Status;
 470     }
 471
 472     //
 473     // Write that half.
 474     //
 475     Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 476                OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DriverFeature),
 477                sizeof Features32[Selector], &Features32[Selector]);
 478     if (EFI_ERROR (Status)) {
 479       return Status;
 480     }
 481   }
 482
 483   return EFI_SUCCESS;
 484 }
 485
 486
 487 STATIC
 488 EFI_STATUS
 489 EFIAPI
 490 Virtio10SetQueueAddress (
 491   IN VIRTIO_DEVICE_PROTOCOL  *This,
 492   IN VRING                   *Ring
 493   )
 494 {
 495   VIRTIO_1_0_DEV *Dev;
 496   EFI_STATUS     Status;
 497   UINT64         Address;
 498   UINT16         Enable;
 499
 500   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 501
 502   Address = (UINTN)Ring->Desc;
 503   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 504              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueDesc),
 505              sizeof Address, &Address);
 506   if (EFI_ERROR (Status)) {
 507     return Status;
 508   }
 509
 510   Address = (UINTN)Ring->Avail.Flags;
 511   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 512              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueAvail),
 513              sizeof Address, &Address);
 514   if (EFI_ERROR (Status)) {
 515     return Status;
 516   }
 517
 518   Address = (UINTN)Ring->Used.Flags;
 519   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 520              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueUsed),
 521              sizeof Address, &Address);
 522   if (EFI_ERROR (Status)) {
 523     return Status;
 524   }
 525
 526   Enable = 1;
 527   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 528              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueEnable),
 529              sizeof Enable, &Enable);
 530   return Status;
 531 }
 532
 533
 534 STATIC
 535 EFI_STATUS
 536 EFIAPI
 537 Virtio10SetQueueSel (
 538   IN VIRTIO_DEVICE_PROTOCOL  *This,
 539   IN UINT16                   Index
 540   )
 541 {
 542   VIRTIO_1_0_DEV *Dev;
 543   EFI_STATUS     Status;
 544
 545   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 546
 547   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 548              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),
 549              sizeof Index, &Index);
 550   return Status;
 551 }
 552
 553
 554 STATIC
 555 EFI_STATUS
 556 EFIAPI
 557 Virtio10SetQueueNotify (
 558   IN VIRTIO_DEVICE_PROTOCOL  *This,
 559   IN UINT16                   Index
 560   )
 561 {
 562   VIRTIO_1_0_DEV *Dev;
 563   EFI_STATUS     Status;
 564   UINT16         SavedQueueSelect;
 565   UINT16         NotifyOffset;
 566
 567   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 568
 569   //
 570   // Read NotifyOffset first. NotifyOffset is queue specific, so we have
 571   // to stash & restore the current queue selector around it.
 572   //
 573   // So, start with saving the current queue selector.
 574   //
 575   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, FALSE,
 576              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),
 577              sizeof SavedQueueSelect, &SavedQueueSelect);
 578   if (EFI_ERROR (Status)) {
 579     return Status;
 580   }
 581
 582   //
 583   // Select the requested queue.
 584   //
 585   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 586              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),
 587              sizeof Index, &Index);
 588   if (EFI_ERROR (Status)) {
 589     return Status;
 590   }
 591
 592   //
 593   // Read the QueueNotifyOff field.
 594   //
 595   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, FALSE,
 596              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueNotifyOff),
 597              sizeof NotifyOffset, &NotifyOffset);
 598   if (EFI_ERROR (Status)) {
 599     return Status;
 600   }
 601
 602   //
 603   // Re-select the original queue.
 604   //
 605   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 606              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),
 607              sizeof SavedQueueSelect, &SavedQueueSelect);
 608   if (EFI_ERROR (Status)) {
 609     return Status;
 610   }
 611
 612   //
 613   // We can now kick the queue.
 614   //
 615   Status = Virtio10Transfer (Dev->PciIo, &Dev->NotifyConfig, TRUE,
 616              NotifyOffset * Dev->NotifyOffsetMultiplier,
 617              sizeof Index, &Index);
 618   return Status;
 619 }
 620
 621
 622 STATIC
 623 EFI_STATUS
 624 EFIAPI
 625 Virtio10SetQueueAlign (
 626   IN VIRTIO_DEVICE_PROTOCOL  *This,
 627   IN UINT32                   Alignment
 628   )
 629 {
 630   return (Alignment == EFI_PAGE_SIZE) ? EFI_SUCCESS : EFI_UNSUPPORTED;
 631 }
 632
 633
 634 STATIC
 635 EFI_STATUS
 636 EFIAPI
 637 Virtio10SetPageSize (
 638   IN VIRTIO_DEVICE_PROTOCOL  *This,
 639   IN UINT32                   PageSize
 640   )
 641 {
 642   return (PageSize == EFI_PAGE_SIZE) ? EFI_SUCCESS : EFI_UNSUPPORTED;
 643 }
 644
 645
 646 STATIC
 647 EFI_STATUS
 648 EFIAPI
 649 Virtio10GetQueueNumMax (
 650   IN  VIRTIO_DEVICE_PROTOCOL  *This,
 651   OUT UINT16                  *QueueNumMax
 652   )
 653 {
 654   VIRTIO_1_0_DEV *Dev;
 655   EFI_STATUS     Status;
 656
 657   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 658
 659   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, FALSE,
 660              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSize),
 661              sizeof *QueueNumMax, QueueNumMax);
 662   return Status;
 663 }
 664
 665
 666 STATIC
 667 EFI_STATUS
 668 EFIAPI
 669 Virtio10SetQueueNum (
 670   IN VIRTIO_DEVICE_PROTOCOL  *This,
 671   IN UINT16                   QueueSize
 672   )
 673 {
 674   EFI_STATUS     Status;
 675   UINT16         CurrentSize;
 676
 677   //
 678   // This member function is required for VirtIo MMIO, and a no-op in
 679   // VirtIo PCI 0.9.5. In VirtIo 1.0, drivers can theoretically use this
 680   // member to reduce memory consumption, but none of our drivers do. So
 681   // just check that they set the size that is already in effect.
 682   //
 683   Status = Virtio10GetQueueNumMax (This, &CurrentSize);
 684   if (EFI_ERROR (Status)) {
 685     return Status;
 686   }
 687   return (CurrentSize == QueueSize) ? EFI_SUCCESS : EFI_UNSUPPORTED;
 688 }
 689
 690
 691 STATIC
 692 EFI_STATUS
 693 EFIAPI
 694 Virtio10GetDeviceStatus (
 695   IN  VIRTIO_DEVICE_PROTOCOL  *This,
 696   OUT UINT8                   *DeviceStatus
 697   )
 698 {
 699   VIRTIO_1_0_DEV *Dev;
 700   EFI_STATUS     Status;
 701
 702   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 703
 704   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, FALSE,
 705              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceStatus),
 706              sizeof *DeviceStatus, DeviceStatus);
 707   return Status;
 708 }
 709
 710
 711 STATIC
 712 EFI_STATUS
 713 EFIAPI
 714 Virtio10SetDeviceStatus (
 715   IN VIRTIO_DEVICE_PROTOCOL  *This,
 716   IN UINT8                   DeviceStatus
 717   )
 718 {
 719   VIRTIO_1_0_DEV *Dev;
 720   EFI_STATUS     Status;
 721
 722   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 723
 724   Status = Virtio10Transfer (Dev->PciIo, &Dev->CommonConfig, TRUE,
 725              OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceStatus),
 726              sizeof DeviceStatus, &DeviceStatus);
 727   return Status;
 728 }
 729
 730
 731 STATIC
 732 EFI_STATUS
 733 EFIAPI
 734 Virtio10WriteDevice (
 735   IN VIRTIO_DEVICE_PROTOCOL *This,
 736   IN UINTN                  FieldOffset,
 737   IN UINTN                  FieldSize,
 738   IN UINT64                 Value
 739   )
 740 {
 741   VIRTIO_1_0_DEV *Dev;
 742   EFI_STATUS     Status;
 743
 744   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 745
 746   Status = Virtio10Transfer (Dev->PciIo, &Dev->SpecificConfig, TRUE,
 747              FieldOffset, FieldSize, &Value);
 748   return Status;
 749 }
 750
 751
 752 STATIC
 753 EFI_STATUS
 754 EFIAPI
 755 Virtio10ReadDevice (
 756   IN  VIRTIO_DEVICE_PROTOCOL *This,
 757   IN  UINTN                  FieldOffset,
 758   IN  UINTN                  FieldSize,
 759   IN  UINTN                  BufferSize,
 760   OUT VOID                   *Buffer
 761   )
 762 {
 763   VIRTIO_1_0_DEV *Dev;
 764   EFI_STATUS     Status;
 765
 766   if (FieldSize != BufferSize) {
 767     return EFI_INVALID_PARAMETER;
 768   }
 769
 770   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 771
 772   Status = Virtio10Transfer (Dev->PciIo, &Dev->SpecificConfig, FALSE,
 773              FieldOffset, FieldSize, Buffer);
 774   return Status;
 775 }
 776
 777 STATIC
 778 EFI_STATUS
 779 EFIAPI
 780 Virtio10AllocateSharedPages (
 781   IN     VIRTIO_DEVICE_PROTOCOL  *This,
 782   IN     UINTN                   Pages,
 783   IN OUT VOID                    **HostAddress
 784   )
 785 {
 786   VIRTIO_1_0_DEV *Dev;
 787   EFI_STATUS     Status;
 788
 789   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 790
 791   Status = Dev->PciIo->AllocateBuffer (
 792                          Dev->PciIo,
 793                          AllocateAnyPages,
 794                          EfiBootServicesData,
 795                          Pages,
 796                          HostAddress,
 797                          EFI_PCI_ATTRIBUTE_MEMORY_CACHED
 798                          );
 799   return Status;
 800 }
 801
 802 STATIC
 803 VOID
 804 EFIAPI
 805 Virtio10FreeSharedPages (
 806   IN  VIRTIO_DEVICE_PROTOCOL  *This,
 807   IN  UINTN                   Pages,
 808   IN  VOID                    *HostAddress
 809   )
 810 {
 811   VIRTIO_1_0_DEV *Dev;
 812
 813   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 814
 815   Dev->PciIo->FreeBuffer (
 816                 Dev->PciIo,
 817                 Pages,
 818                 HostAddress
 819                 );
 820 }
 821
 822 STATIC
 823 EFI_STATUS
 824 EFIAPI
 825 Virtio10MapSharedBuffer (
 826   IN     VIRTIO_DEVICE_PROTOCOL  *This,
 827   IN     VIRTIO_MAP_OPERATION    Operation,
 828   IN     VOID                    *HostAddress,
 829   IN OUT UINTN                   *NumberOfBytes,
 830   OUT    EFI_PHYSICAL_ADDRESS    *DeviceAddress,
 831   OUT    VOID                    **Mapping
 832   )
 833 {
 834   EFI_STATUS                    Status;
 835   VIRTIO_1_0_DEV                *Dev;
 836   EFI_PCI_IO_PROTOCOL_OPERATION PciIoOperation;
 837
 838   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 839
 840   //
 841   // Map VIRTIO_MAP_OPERATION to EFI_PCI_IO_PROTOCOL_OPERATION
 842   //
 843   switch (Operation) {
 844   case VirtioOperationBusMasterRead:
 845     PciIoOperation = EfiPciIoOperationBusMasterRead;
 846     break;
 847   case VirtioOperationBusMasterWrite:
 848     PciIoOperation = EfiPciIoOperationBusMasterWrite;
 849     break;
 850   case VirtioOperationBusMasterCommonBuffer:
 851     PciIoOperation = EfiPciIoOperationBusMasterCommonBuffer;
 852     break;
 853   default:
 854     return EFI_INVALID_PARAMETER;
 855   }
 856
 857   Status = Dev->PciIo->Map (
 858                          Dev->PciIo,
 859                          PciIoOperation,
 860                          HostAddress,
 861                          NumberOfBytes,
 862                          DeviceAddress,
 863                          Mapping
 864                          );
 865   return Status;
 866 }
 867
 868 STATIC
 869 EFI_STATUS
 870 EFIAPI
 871 Virtio10UnmapSharedBuffer (
 872   IN  VIRTIO_DEVICE_PROTOCOL  *This,
 873   IN  VOID                    *Mapping
 874   )
 875 {
 876   EFI_STATUS      Status;
 877   VIRTIO_1_0_DEV  *Dev;
 878
 879   Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);
 880
 881   Status = Dev->PciIo->Unmap (
 882                          Dev->PciIo,
 883                          Mapping
 884                          );
 885
 886   return Status;
 887 }
 888
 889 STATIC CONST VIRTIO_DEVICE_PROTOCOL mVirtIoTemplate = {
 890   VIRTIO_SPEC_REVISION (1, 0, 0),
 891   0,                              // SubSystemDeviceId, filled in dynamically
 892   Virtio10GetDeviceFeatures,
 893   Virtio10SetGuestFeatures,
 894   Virtio10SetQueueAddress,
 895   Virtio10SetQueueSel,
 896   Virtio10SetQueueNotify,
 897   Virtio10SetQueueAlign,
 898   Virtio10SetPageSize,
 899   Virtio10GetQueueNumMax,
 900   Virtio10SetQueueNum,
 901   Virtio10GetDeviceStatus,
 902   Virtio10SetDeviceStatus,
 903   Virtio10WriteDevice,
 904   Virtio10ReadDevice,
 905   Virtio10AllocateSharedPages,
 906   Virtio10FreeSharedPages,
 907   Virtio10MapSharedBuffer,
 908   Virtio10UnmapSharedBuffer
 909 };
 910
 911
 912 //
 913 // EFI_DRIVER_BINDING_PROTOCOL member functions
 914 //
 915
 916 STATIC
 917 EFI_STATUS
 918 EFIAPI
 919 Virtio10BindingSupported (
 920   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 921   IN EFI_HANDLE                  DeviceHandle,
 922   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath
 923   )
 924 {
 925   EFI_STATUS          Status;
 926   EFI_PCI_IO_PROTOCOL *PciIo;
 927   PCI_TYPE00          Pci;
 928
 929   Status = gBS->OpenProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
 930                   (VOID **)&PciIo, This->DriverBindingHandle,
 931                   DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
 932   if (EFI_ERROR (Status)) {
 933     return Status;
 934   }
 935
 936   Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint32, 0,
 937                         sizeof Pci / sizeof (UINT32), &Pci);
 938   if (EFI_ERROR (Status)) {
 939     goto CloseProtocol;
 940   }
 941
 942   Status = EFI_UNSUPPORTED;
 943   //
 944   // Recognize non-transitional modern devices. Also, we'll have to parse the
 945   // PCI capability list, so make sure the CapabilityPtr field will be valid.
 946   //
 947   if (Pci.Hdr.VendorId == VIRTIO_VENDOR_ID &&
 948       Pci.Hdr.DeviceId >= 0x1040 &&
 949       Pci.Hdr.DeviceId <= 0x107F &&
 950       Pci.Hdr.RevisionID >= 0x01 &&
 951       Pci.Device.SubsystemID >= 0x40 &&
 952       (Pci.Hdr.Status & EFI_PCI_STATUS_CAPABILITY) != 0) {
 953     //
 954     // The virtio-vga device is special. It can be driven both as a VGA device
 955     // with a linear framebuffer, and through its underlying, modern,
 956     // virtio-gpu-pci device, which has no linear framebuffer itself. For
 957     // compatibility with guest OSes that insist on inheriting a linear
 958     // framebuffer from the firmware, we should leave virtio-vga to
 959     // QemuVideoDxe, and support only virtio-gpu-pci here.
 960     //
 961     // Both virtio-vga and virtio-gpu-pci have DeviceId 0x1050, but only the
 962     // former has device class PCI_CLASS_DISPLAY_VGA.
 963     //
 964     if (Pci.Hdr.DeviceId != 0x1050 || !IS_PCI_VGA (&Pci)) {
 965       Status = EFI_SUCCESS;
 966     }
 967   }
 968
 969 CloseProtocol:
 970   gBS->CloseProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
 971          This->DriverBindingHandle, DeviceHandle);
 972
 973   return Status;
 974 }
 975
 976
 977 STATIC
 978 EFI_STATUS
 979 EFIAPI
 980 Virtio10BindingStart (
 981   IN EFI_DRIVER_BINDING_PROTOCOL *This,
 982   IN EFI_HANDLE                  DeviceHandle,
 983   IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath
 984   )
 985 {
 986   VIRTIO_1_0_DEV *Device;
 987   EFI_STATUS     Status;
 988   PCI_TYPE00     Pci;
 989   UINT64         SetAttributes;
 990
 991   Device = AllocateZeroPool (sizeof *Device);
 992   if (Device == NULL) {
 993     return EFI_OUT_OF_RESOURCES;
 994   }
 995
 996   Device->Signature = VIRTIO_1_0_SIGNATURE;
 997   CopyMem (&Device->VirtIo, &mVirtIoTemplate, sizeof mVirtIoTemplate);
 998
 999   Status = gBS->OpenProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
1000                   (VOID **)&Device->PciIo, This->DriverBindingHandle,
1001                   DeviceHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
1002   if (EFI_ERROR (Status)) {
1003     goto FreeDevice;
1004   }
1005
1006   Status = Device->PciIo->Pci.Read (Device->PciIo, EfiPciIoWidthUint32, 0,
1007                                 sizeof Pci / sizeof (UINT32), &Pci);
1008   if (EFI_ERROR (Status)) {
1009     goto ClosePciIo;
1010   }
1011
1012   Device->VirtIo.SubSystemDeviceId = Pci.Hdr.DeviceId - 0x1040;
1013
1014   Status = ParseCapabilities (Device, Pci.Device.CapabilityPtr);
1015   if (EFI_ERROR (Status)) {
1016     goto ClosePciIo;
1017   }
1018
1019   Status = Device->PciIo->Attributes (Device->PciIo,
1020                             EfiPciIoAttributeOperationGet, 0,
1021                             &Device->OriginalPciAttributes);
1022   if (EFI_ERROR (Status)) {
1023     goto ClosePciIo;
1024   }
1025
1026   SetAttributes = (EFI_PCI_IO_ATTRIBUTE_BUS_MASTER |
1027                    EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE);
1028   UpdateAttributes (&Device->CommonConfig, &SetAttributes);
1029   UpdateAttributes (&Device->NotifyConfig, &SetAttributes);
1030   UpdateAttributes (&Device->SpecificConfig, &SetAttributes);
1031   Status = Device->PciIo->Attributes (Device->PciIo,
1032                             EfiPciIoAttributeOperationEnable, SetAttributes,
1033                             NULL);
1034   if (EFI_ERROR (Status)) {
1035     goto ClosePciIo;
1036   }
1037
1038   Status = gBS->InstallProtocolInterface (&DeviceHandle,
1039                   &gVirtioDeviceProtocolGuid, EFI_NATIVE_INTERFACE,
1040                   &Device->VirtIo);
1041   if (EFI_ERROR (Status)) {
1042     goto RestorePciAttributes;
1043   }
1044
1045   return EFI_SUCCESS;
1046
1047 RestorePciAttributes:
1048   Device->PciIo->Attributes (Device->PciIo, EfiPciIoAttributeOperationSet,
1049                    Device->OriginalPciAttributes, NULL);
1050
1051 ClosePciIo:
1052   gBS->CloseProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
1053          This->DriverBindingHandle, DeviceHandle);
1054
1055 FreeDevice:
1056   FreePool (Device);
1057
1058   return Status;
1059 }
1060
1061
1062 STATIC
1063 EFI_STATUS
1064 EFIAPI
1065 Virtio10BindingStop (
1066   IN EFI_DRIVER_BINDING_PROTOCOL *This,
1067   IN EFI_HANDLE                  DeviceHandle,
1068   IN UINTN                       NumberOfChildren,
1069   IN EFI_HANDLE                  *ChildHandleBuffer
1070   )
1071 {
1072   EFI_STATUS             Status;
1073   VIRTIO_DEVICE_PROTOCOL *VirtIo;
1074   VIRTIO_1_0_DEV         *Device;
1075
1076   Status = gBS->OpenProtocol (DeviceHandle, &gVirtioDeviceProtocolGuid,
1077                   (VOID **)&VirtIo, This->DriverBindingHandle,
1078                   DeviceHandle, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
1079   if (EFI_ERROR (Status)) {
1080     return Status;
1081   }
1082
1083   Device = VIRTIO_1_0_FROM_VIRTIO_DEVICE (VirtIo);
1084
1085   Status = gBS->UninstallProtocolInterface (DeviceHandle,
1086                   &gVirtioDeviceProtocolGuid, &Device->VirtIo);
1087   if (EFI_ERROR (Status)) {
1088     return Status;
1089   }
1090
1091   Device->PciIo->Attributes (Device->PciIo, EfiPciIoAttributeOperationSet,
1092                    Device->OriginalPciAttributes, NULL);
1093   gBS->CloseProtocol (DeviceHandle, &gEfiPciIoProtocolGuid,
1094          This->DriverBindingHandle, DeviceHandle);
1095   FreePool (Device);
1096
1097   return EFI_SUCCESS;
1098 }
1099
1100
1101 STATIC EFI_DRIVER_BINDING_PROTOCOL mDriverBinding = {
1102   &Virtio10BindingSupported,
1103   &Virtio10BindingStart,
1104   &Virtio10BindingStop,
1105   0x10, // Version
1106   NULL, // ImageHandle, to be overwritten
1107   NULL  // DriverBindingHandle, to be overwritten
1108 };
1109
1110
1111 //
1112 // EFI_COMPONENT_NAME_PROTOCOL and EFI_COMPONENT_NAME2_PROTOCOL
1113 // implementations
1114 //
1115
1116 STATIC
1117 EFI_UNICODE_STRING_TABLE mDriverNameTable[] = {
1118   { "eng;en", L"Virtio 1.0 PCI Driver" },
1119   { NULL,     NULL                     }
1120 };
1121
1122 STATIC
1123 EFI_COMPONENT_NAME_PROTOCOL mComponentName;
1124
1125 STATIC
1126 EFI_STATUS
1127 EFIAPI
1128 Virtio10GetDriverName (
1129   IN  EFI_COMPONENT_NAME_PROTOCOL *This,
1130   IN  CHAR8                       *Language,
1131   OUT CHAR16                      **DriverName
1132   )
1133 {
1134   return LookupUnicodeString2 (
1135            Language,
1136            This->SupportedLanguages,
1137            mDriverNameTable,
1138            DriverName,
1139            (BOOLEAN)(This == &mComponentName) // Iso639Language
1140            );
1141 }
1142
1143 STATIC
1144 EFI_STATUS
1145 EFIAPI
1146 Virtio10GetDeviceName (
1147   IN  EFI_COMPONENT_NAME_PROTOCOL *This,
1148   IN  EFI_HANDLE                  DeviceHandle,
1149   IN  EFI_HANDLE                  ChildHandle,
1150   IN  CHAR8                       *Language,
1151   OUT CHAR16                      **ControllerName
1152   )
1153 {
1154   return EFI_UNSUPPORTED;
1155 }
1156
1157 STATIC
1158 EFI_COMPONENT_NAME_PROTOCOL mComponentName = {
1159   &Virtio10GetDriverName,
1160   &Virtio10GetDeviceName,
1161   "eng"
1162 };
1163
1164 STATIC
1165 EFI_COMPONENT_NAME2_PROTOCOL mComponentName2 = {
1166   (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)     &Virtio10GetDriverName,
1167   (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) &Virtio10GetDeviceName,
1168   "en"
1169 };
1170
1171
1172 //
1173 // Entry point of this driver
1174 //
1175
1176 EFI_STATUS
1177 EFIAPI
1178 Virtio10EntryPoint (
1179   IN EFI_HANDLE       ImageHandle,
1180   IN EFI_SYSTEM_TABLE *SystemTable
1181   )
1182 {
1183   return EfiLibInstallDriverBindingComponentName2 (
1184            ImageHandle,
1185            SystemTable,
1186            &mDriverBinding,
1187            ImageHandle,
1188            &mComponentName,
1189            &mComponentName2
1190            );
1191 }