[轉] UEFI实战

  ///
  /// The version number of the UEFI driver that produced the
  /// EFI_DRIVER_BINDING_PROTOCOL. This field is used by
  /// the EFI boot service ConnectController() to determine
  /// the order that driver’s Supported() service will be used when
  /// a controller needs to be started. EFI Driver Binding Protocol
  /// instances with higher Version values will be used before ones
  /// with lower Version values. The Version values of 0x0-
  /// 0x0f and 0xfffffff0-0xffffffff are reserved for
  /// platform/OEM specific drivers. The Version values of 0x10-
  /// 0xffffffef are reserved for IHV-developed drivers.
  ///  UINT32                        Version;

  ///
  /// The image handle of the UEFI driver that produced this instance
  /// of the EFI_DRIVER_BINDING_PROTOCOL.
  ///  EFI_HANDLE                    ImageHandle;

  ///
  /// The handle on which this instance of the
  /// EFI_DRIVER_BINDING_PROTOCOL is installed. In most
  /// cases, this is the same handle as ImageHandle. However, for
  /// UEFI drivers that produce more than one instance of the
  /// EFI_DRIVER_BINDING_PROTOCOL, this value may not be
  /// the same as ImageHandle.
  ///  EFI_HANDLE                    DriverBindingHandle;
};

    //
    // Loop through the sorted Driver Binding Protocol Instances in order, and see if
    // any of the Driver Binding Protocols support the controller specified by
    // ControllerHandle.
    //    DriverBinding = NULL;
    DriverFound = FALSE;
    for (Index = 0; (Index < NumberOfSortedDriverBindingProtocols) && !DriverFound; Index++) {
      if (SortedDriverBindingProtocols[Index] != NULL) {
        DriverBinding = SortedDriverBindingProtocols[Index];
        PERF_START (DriverBinding->DriverBindingHandle, “DB:Support:”, NULL, 0);
        Status = DriverBinding->Supported(
                                  DriverBinding,
                                  ControllerHandle,
                                  RemainingDevicePath
                                  );
        PERF_END (DriverBinding->DriverBindingHandle, “DB:Support:”, NULL, 0);
        if (!EFI_ERROR (Status)) {
          SortedDriverBindingProtocols[Index] = NULL;
          DriverFound = TRUE;

          //
          // A driver was found that supports ControllerHandle, so attempt to start the driver
          // on ControllerHandle.
          //          PERF_START (DriverBinding->DriverBindingHandle, “DB:Start:”, NULL, 0);
          Status = DriverBinding->Start (
                                    DriverBinding,
                                    ControllerHandle,
                                    RemainingDevicePath
                                    );
          PERF_END (DriverBinding->DriverBindingHandle, “DB:Start:”, NULL, 0);

          if (!EFI_ERROR (Status)) {
            //
            // The driver was successfully started on ControllerHandle, so set a flag
            //            OneStarted = TRUE;
          }
        }
      }
    }
  } while (DriverFound);

  ///
  /// The size, in bytes, of the ROM image.
  ///  UINT64                                  RomSize;

  ///
  /// A pointer to the in memory copy of the ROM image. The PCI Bus Driver is responsible
  /// for allocating memory for the ROM image, and copying the contents of the ROM to memory.
  /// The contents of this buffer are either from the PCI option ROM that can be accessed
  /// through the ROM BAR of the PCI controller, or it is from a platform-specific location.
  /// The Attributes() function can be used to determine from which of these two sources
  /// the RomImage buffer was initialized.
  ///  VOID                                    *RomImage;
};

  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
  @param  Width                 Signifies the width of the memory operations.
  @param  Offset                The offset within the PCI configuration space for the PCI controller.
  @param  Count                 The number of PCI configuration operations to perform.
  @param  Buffer                For read operations, the destination buffer to store the results. For write
                                operations, the source buffer to write data from.

  @retval EFI_SUCCESS           The data was read from or written to the PCI controller.
  @retval EFI_UNSUPPORTED       The address range specified by Offset, Width, and Count is not
                                valid for the PCI configuration header of the PCI controller.
  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  @retval EFI_INVALID_PARAMETER Buffer is NULL or Width is invalid.

**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_IO_PROTOCOL_CONFIG)(
  IN EFI_PCI_IO_PROTOCOL              *This,
  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
  IN     UINT32                       Offset,
  IN     UINTN                        Count,
  IN OUT VOID                         *Buffer
  );

typedef struct {
  ///
  /// Read PCI controller registers in PCI configuration space.
  ///  EFI_PCI_IO_PROTOCOL_CONFIG  Read;
  ///
  /// Write PCI controller registers in PCI configuration space.
  ///  EFI_PCI_IO_PROTOCOL_CONFIG  Write;
} EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS;

/**
  Enable a PCI driver to access PCI controller registers in the PCI memory or I/O space.

  @param  This                  A pointer to the EFI_PCI_IO_PROTOCOL instance.
  @param  Width                 Signifies the width of the memory or I/O operations.
  @param  BarIndex              The BAR index of the standard PCI Configuration header to use as the
                                base address for the memory or I/O operation to perform.
  @param  Offset                The offset within the selected BAR to start the memory or I/O operation.
  @param  Count                 The number of memory or I/O operations to perform.
  @param  Buffer                For read operations, the destination buffer to store the results. For write
                                operations, the source buffer to write data from.

  @retval EFI_SUCCESS           The data was read from or written to the PCI controller.
  @retval EFI_UNSUPPORTED       BarIndex not valid for this PCI controller.
  @retval EFI_UNSUPPORTED       The address range specified by Offset, Width, and Count is not
                                valid for the PCI BAR specified by BarIndex.
  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.

**/
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_IO_PROTOCOL_IO_MEM)(
  IN EFI_PCI_IO_PROTOCOL              *This,
  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,     // 每个元素的大小
  IN     UINT8                                      BarIndex,       // 0～5中的一个
  IN     UINT64                                   Offset,            // 偏移
  IN     UINTN                                     Count,           //  元素个数
  IN OUT VOID                                   *Buffer
  );

typedef struct {
  ///
  /// Read PCI controller registers in the PCI memory or I/O space.
  ///  EFI_PCI_IO_PROTOCOL_IO_MEM  Read;
  ///
  /// Write PCI controller registers in the PCI memory or I/O space.
  ///  EFI_PCI_IO_PROTOCOL_IO_MEM  Write;
} EFI_PCI_IO_PROTOCOL_ACCESS;

  @retval EFI_SUCCESS          .
  @retval EFI_DEVICE_ERROR         .

**/
EFI_STATUS
EFIAPI AC97Reset(
        IN  EFI_AUDIO_PROTOCOL  *This
        )
{
    NTSTATUS InitAC97 (void);
    EFI_STATUS            Status;
    AUDIO_PRIVATE_DATA* Private = AUDIO_PRIVATE_DATA_FROM_THIS(This);
    gAudioPciIo = Private->PciIo;

    Status = InitAC97 ();
    return Status;
}

  @retval EFI_SUCCESS          .
  @retval EFI_DEVICE_ERROR         .

**/
EFI_STATUS
EFIAPI AC97Play(
        IN  EFI_AUDIO_PROTOCOL  *This,
    IN  UINT8* PcmData,
    IN  UINT32 Format,
    IN  UINTN Size
        )
{
    EFI_STATUS            Status;
    UINTN i=0, LenLeft = Size;
    AUDIO_PRIVATE_DATA* Private = AUDIO_PRIVATE_DATA_FROM_THIS(This);
    gAudioPciIo = Private->PciIo;

    for( i=0; i< 32 && LenLeft > 0; i++, LenLeft-=65536){
        Private->Bdes[0].addr = (u32)(PcmData + 65536 * 4 * i);
        Private->Bdes[0].len = (u16)(LenLeft <= 65536 ? LenLeft:LenLeft-65536);
    }
    Private->Bdes[i-1].BUP = 1;
    Private->Bdes[i-1].IOC = 0;

    WriteBMControlRegister32(PO_BDBAR       ,  (u32)Private->Bdes);
    WriteBMControlRegister(PO_LVI         ,  0);

    (void) Status;
    return EFI_SUCCESS;
}

  @retval EFI_SUCCESS          .
  @retval EFI_DEVICE_ERROR         .

**/
EFI_STATUS
EFIAPI AC97Volume(
        IN  EFI_AUDIO_PROTOCOL  *This,
    IN  INT32 Increase,
    IN OUT INT32 * NewVolume
    )
{
    AUDIO_PRIVATE_DATA* Private = AUDIO_PRIVATE_DATA_FROM_THIS(This);
    gAudioPciIo = Private->PciIo;

    if(*NewVolume < 0){
        WORD data= (WORD) (long ) NewVolume;
        WriteCodecRegister (AC97REG_PCM_OUT_VOLUME, data, 0xFFFF);
    }else{
        WORD data= 0;
        ReadCodecRegister(AC97REG_PCM_OUT_VOLUME, &data);
        data += (INT16) Increase;
        WriteCodecRegister (AC97REG_PCM_OUT_VOLUME, data, 0xFFFF);
        *NewVolume = (INT32)data;
    }
    return EFI_SUCCESS;
}

  @param  This                Protocol instance pointer.
  @param  ControllerHandle    Handle of device to test
  @param  RemainingDevicePath Optional parameter use to pick a specific child
                              device to start.

  @retval EFI_SUCCESS         This driver supports this device
  @retval EFI_ALREADY_STARTED This driver is already running on this device
  @retval other               This driver does not support this device

**/
EFI_STATUS
EFIAPI
AC97DriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS            Status;
  PCI_TYPE00                        PciData;
  EFI_PCI_IO_PROTOCOL       *PciIo;
  Status = gBS->OpenProtocol(
          ControllerHandle,
          &gEfiPciIoProtocolGuid,
          (VOID**)&PciIo,
          This->DriverBindingHandle,
          ControllerHandle,
          EFI_OPEN_PROTOCOL_BY_DRIVER
            );
   if (EFI_ERROR (Status)) {
       return Status;
   }

   Status = PciIo->Pci.Read (
           PciIo,
           EfiPciIoWidthUint32,
           0,
           sizeof (PciData) / sizeof (UINT32),
           &PciData
           );

   gBS->CloseProtocol (
        ControllerHandle,
        &gEfiPciIoProtocolGuid,
        This->DriverBindingHandle,
        ControllerHandle
        );

   if (EFI_ERROR (Status)) {
       return Status;
   }
   if (!(PciData.Hdr.ClassCode[2] == PCI_CLASS_MEDIA && PciData.Hdr.ClassCode[1] == PCI_CLASS_MEDIA_AUDIO && PciData.Hdr.ClassCode[0] == 0x00) ) {
       return EFI_UNSUPPORTED;
   }
  return EFI_SUCCESS;
}

  @param  This                 Protocol instance pointer.
  @param  ControllerHandle     Handle of device to bind driver to
  @param  RemainingDevicePath  Optional parameter use to pick a specific child
                               device to start.

  @retval EFI_SUCCESS          This driver is added to ControllerHandle
  @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
  @retval other                This driver does not support this device

**/
EFI_STATUS
EFIAPI
AC97DriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS            Status;
  EFI_PCI_IO_PROTOCOL   *PciIo;
  AUDIO_PRIVATE_DATA    *Private;

  Status = gBS->OpenProtocol(
          ControllerHandle,
          &gEfiPciIoProtocolGuid,
          (VOID**)&PciIo,
          This->DriverBindingHandle,
          ControllerHandle,
          EFI_OPEN_PROTOCOL_BY_DRIVER
            );
   if (EFI_ERROR (Status)) {
       return Status;
   }
   //
   // Allocate a buffer to store the ATA_ATAPI_PASS_THRU_INSTANCE data structure
   //   Private = AllocateCopyPool (sizeof (AUDIO_PRIVATE_DATA),        &gDiskIoPrivateDataTemplate );
   if (Private == NULL) {
       goto ErrorExit;
   }

   Private->PciIo = PciIo;
   Status = gBS->CreateEvent(EVT_NOTIFY_WAIT, TPL_NOTIFY, (EFI_EVENT_NOTIFY)PlayEndEventNoify, (VOID*)Private, &Private->Audio.WaitForEndEvent);

   Status = gBS->InstallProtocolInterface (
                  &ControllerHandle,
                  &gEfiAudioProtocolGUID,
                  EFI_NATIVE_INTERFACE,
                  &Private->Audio
                  );

ErrorExit:
   if (EFI_ERROR (Status)) {

    if (Private != NULL) {
      FreePool (Private);
    }

    gBS->CloseProtocol (
          ControllerHandle,
          &gEfiPciIoProtocolGuid,
          This->DriverBindingHandle,
          ControllerHandle
          );
  }else{
   // Init Ac97
   AC97Reset(&Private->Audio);
  }
   return Status;
}

  @param  This              Protocol instance pointer.
  @param  ControllerHandle  Handle of device to stop driver on
  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
                            children is zero stop the entire bus driver.
  @param  ChildHandleBuffer List of Child Handles to Stop.

  @retval EFI_SUCCESS       This driver is removed ControllerHandle
  @retval other             This driver was not removed from this device

**/
EFI_STATUS
EFIAPI
AC97DriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN  EFI_HANDLE                     ControllerHandle,
  IN  UINTN                          NumberOfChildren,
  IN  EFI_HANDLE                     *ChildHandleBuffer
  )
{
  EFI_STATUS            Status;
  AUDIO_PRIVATE_DATA    *Private;
  EFI_AUDIO_PROTOCOL    *Audio;

  //
  // Get our context back.
  //  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiAudioProtocolGUID,
                  (VOID **) &Audio,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }

  Private = AUDIO_PRIVATE_DATA_FROM_THIS(This);

  Status = gBS->UninstallProtocolInterface (
                  ControllerHandle,
                  &gEfiAudioProtocolGUID,
                  &Private->Audio
                  );
  if (!EFI_ERROR (Status)) {
    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEfiPciIoProtocolGuid,
                    This->DriverBindingHandle,
                    ControllerHandle
                    );
  }

  if (!EFI_ERROR (Status)) {
    FreePool (Private);
  }

  return Status;
}

首先找出FAT分区的controller,然后打开EFI_SIMPLE_FILE_SYSTEM_PROTOCOL， 如果系统中只有一个FAT分区，用gBS->LocateProtocol(…)就可以了。EFI_SIMPLE_FILE_SYSTEM_PROTOCOL 只提供了一个方法OpenVolume，用来打开设备，获得 EFI_FILE_PROTOCOL实例。

得到该分区上EFI_FILE_PROTOCOL实例的指针后，就可以操作该分区上的文件了。

读写文件与我们常用的标准C读写文件大同小异。例如写文件

下面是Open/Read/Write/Close的函数原型，以供参考

值得注意的是：
1. Open函数的第一个参数是EFI_FILE_PROTOCOL实例的指针。其它函数的第一个参数是通过Open得到的文件Handle，其类型被强制转换成了EFI_FILE_PROTOCOL*.
2. Open函数的第三个参数是绝对路径，例如本例中的testfileprotocol.txt会产生在该分区的根目录。