[mirror_edk2.git] / EdkModulePkg / Universal / Disk / DiskIo / Dxe / diskio.c

/*++

Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution.  The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php

THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

Module Name:

  DiskIo.c

Abstract:

  DiskIo driver that layers it's self on every Block IO protocol in the system.
  DiskIo converts a block oriented device to a byte oriented device.

  ReadDisk may have to do reads that are not aligned on sector boundaries.
  There are three cases:

    UnderRun - The first byte is not on a sector boundary or the read request is
               less than a sector in length.

    Aligned  - A read of N contiguous sectors.

    OverRun  - The last byte is not on a sector boundary.

--*/

#include "DiskIo.h"

//
// Prototypes
// Driver model protocol interface
//
EFI_STATUS
EFIAPI
DiskIoDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  );

EFI_STATUS
EFIAPI
DiskIoDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN EFI_HANDLE                     ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  );

EFI_STATUS
EFIAPI
DiskIoDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN  EFI_HANDLE                     ControllerHandle,
  IN  UINTN                          NumberOfChildren,
  IN  EFI_HANDLE                     *ChildHandleBuffer
  );

//
// Disk I/O Protocol Interface
//
EFI_STATUS
EFIAPI
DiskIoReadDisk (
  IN EFI_DISK_IO_PROTOCOL  *This,
  IN UINT32                MediaId,
  IN UINT64                Offset,
  IN UINTN                 BufferSize,
  OUT VOID                 *Buffer
  );

EFI_STATUS
EFIAPI
DiskIoWriteDisk (
  IN EFI_DISK_IO_PROTOCOL  *This,
  IN UINT32                MediaId,
  IN UINT64                Offset,
  IN UINTN                 BufferSize,
  IN VOID                  *Buffer
  );

EFI_DRIVER_BINDING_PROTOCOL gDiskIoDriverBinding = {
  DiskIoDriverBindingSupported,
  DiskIoDriverBindingStart,
  DiskIoDriverBindingStop,
  0x10,
  NULL,
  NULL
};

DISK_IO_PRIVATE_DATA        gDiskIoPrivateDataTemplate = {
  DISK_IO_PRIVATE_DATA_SIGNATURE,
  {
    EFI_DISK_IO_PROTOCOL_REVISION,
    DiskIoReadDisk,
    DiskIoWriteDisk
  },
  NULL
};

EFI_STATUS
EFIAPI
DiskIoDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
/*++

  Routine Description:
    Test to see if this driver supports ControllerHandle. Any ControllerHandle
    than contains a BlockIo protocol can be supported.

  Arguments:
    This                - Protocol instance pointer.
    ControllerHandle    - Handle of device to test.
    RemainingDevicePath - Not used.

  Returns:
    EFI_SUCCESS         - This driver supports this device.
    EFI_ALREADY_STARTED - This driver is already running on this device.
    other               - This driver does not support this device.

--*/
{
  EFI_STATUS            Status;
  EFI_BLOCK_IO_PROTOCOL *BlockIo;

  //
  // Open the IO Abstraction(s) needed to perform the supported test.
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiBlockIoProtocolGuid,
                  (VOID **) &BlockIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
  //
  // Close the I/O Abstraction(s) used to perform the supported test.
  //
  gBS->CloseProtocol (
        ControllerHandle,
        &gEfiBlockIoProtocolGuid,
        This->DriverBindingHandle,
        ControllerHandle
        );
  return EFI_SUCCESS;
}

EFI_STATUS
EFIAPI
DiskIoDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
/*++

  Routine Description:
    Start this driver on ControllerHandle by opening a Block IO protocol and
    installing a Disk IO protocol on ControllerHandle.

  Arguments:
    This                - Protocol instance pointer.
    ControllerHandle    - Handle of device to bind driver to.
    RemainingDevicePath - Not used, always produce all possible children.

  Returns:
    EFI_SUCCESS         - This driver is added to ControllerHandle.
    EFI_ALREADY_STARTED - This driver is already running on ControllerHandle.
    other               - This driver does not support this device.

--*/
{
  EFI_STATUS            Status;
  DISK_IO_PRIVATE_DATA  *Private;

  Private = NULL;

  //
  // Connect to the Block IO interface on ControllerHandle.
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiBlockIoProtocolGuid,
                  (VOID **) &gDiskIoPrivateDataTemplate.BlockIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
  //
  // Initialize the Disk IO device instance.
  //
  Private = AllocateCopyPool (sizeof (DISK_IO_PRIVATE_DATA), &gDiskIoPrivateDataTemplate);
  if (Private == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ErrorExit;
  }
  //
  // Install protocol interfaces for the Disk IO device.
  //
  Status = gBS->InstallProtocolInterface (
                  &ControllerHandle,
                  &gEfiDiskIoProtocolGuid,
                  EFI_NATIVE_INTERFACE,
                  &Private->DiskIo
                  );

ErrorExit:
  if (EFI_ERROR (Status)) {

    if (Private != NULL) {
      gBS->FreePool (Private);
    }

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

  return Status;
}

EFI_STATUS
EFIAPI
DiskIoDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
  IN  EFI_HANDLE                     ControllerHandle,
  IN  UINTN                          NumberOfChildren,
  IN  EFI_HANDLE                     *ChildHandleBuffer
  )
/*++

  Routine Description:
    Stop this driver on ControllerHandle by removing Disk IO protocol and closing
    the Block IO protocol on ControllerHandle.

  Arguments:
    This              - Protocol instance pointer.
    ControllerHandle  - Handle of device to stop driver on.
    NumberOfChildren  - Not used.
    ChildHandleBuffer - Not used.

  Returns:
    EFI_SUCCESS         - This driver is removed ControllerHandle.
    other               - This driver was not removed from this device.
    EFI_UNSUPPORTED

--*/
{
  EFI_STATUS            Status;
  EFI_DISK_IO_PROTOCOL  *DiskIo;
  DISK_IO_PRIVATE_DATA  *Private;

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

  Private = DISK_IO_PRIVATE_DATA_FROM_THIS (DiskIo);

  Status = gBS->UninstallProtocolInterface (
                  ControllerHandle,
                  &gEfiDiskIoProtocolGuid,
                  &Private->DiskIo
                  );
  if (!EFI_ERROR (Status)) {

    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEfiBlockIoProtocolGuid,
                    This->DriverBindingHandle,
                    ControllerHandle
                    );
  }

  if (!EFI_ERROR (Status)) {
    gBS->FreePool (Private);
  }

  return Status;
}

EFI_STATUS
EFIAPI
DiskIoReadDisk (
  IN EFI_DISK_IO_PROTOCOL  *This,
  IN UINT32                MediaId,
  IN UINT64                Offset,
  IN UINTN                 BufferSize,
  OUT VOID                 *Buffer
  )
/*++

  Routine Description:
    Read BufferSize bytes from Offset into Buffer.

    Reads may support reads that are not aligned on
    sector boundaries. There are three cases:

      UnderRun - The first byte is not on a sector boundary or the read request is
                 less than a sector in length.

      Aligned  - A read of N contiguous sectors.

      OverRun  - The last byte is not on a sector boundary.


  Arguments:
    This       - Protocol instance pointer.
    MediaId    - Id of the media, changes every time the media is replaced.
    Offset     - The starting byte offset to read from.
    BufferSize - Size of Buffer.
    Buffer     - Buffer containing read data.

  Returns:
    EFI_SUCCESS           - The data was read correctly from the device.
    EFI_DEVICE_ERROR      - The device reported an error while performing the read.
    EFI_NO_MEDIA          - There is no media in the device.
    EFI_MEDIA_CHNAGED     - The MediaId does not matched the current device.
    EFI_INVALID_PARAMETER - The read request contains device addresses that are not
                            valid for the device.
    EFI_OUT_OF_RESOURCES

--*/
{
  EFI_STATUS            Status;
  DISK_IO_PRIVATE_DATA  *Private;
  EFI_BLOCK_IO_PROTOCOL *BlockIo;
  EFI_BLOCK_IO_MEDIA    *Media;
  UINT32                BlockSize;
  UINT64                Lba;
  UINT64                OverRunLba;
  UINT32                UnderRun;
  UINT32                OverRun;
  BOOLEAN               TransactionComplete;
  UINTN                 WorkingBufferSize;
  UINT8                 *WorkingBuffer;
  UINTN                 Length;
  UINT8                 *Data;
  UINT8                 *PreData;
  UINTN                 IsBufferAligned;
  UINTN                 DataBufferSize;
  BOOLEAN               LastRead;

  Private   = DISK_IO_PRIVATE_DATA_FROM_THIS (This);

  BlockIo   = Private->BlockIo;
  Media     = BlockIo->Media;
  BlockSize = Media->BlockSize;

  if (Media->MediaId != MediaId) {
    return EFI_MEDIA_CHANGED;
  }

  WorkingBuffer     = Buffer;
  WorkingBufferSize = BufferSize;

  //
  // Allocate a temporary buffer for operation
  //
  DataBufferSize = BlockSize * DATA_BUFFER_BLOCK_NUM;

  if (Media->IoAlign > 1) {
    PreData = AllocatePool (DataBufferSize + Media->IoAlign);
    Data    = PreData - ((UINTN) PreData & (Media->IoAlign - 1)) + Media->IoAlign;
  } else {
    PreData = AllocatePool (DataBufferSize);
    Data    = PreData;
  }

  if (PreData == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  Lba                 = DivU64x32Remainder (Offset, BlockSize, &UnderRun);

  Length              = BlockSize - UnderRun;
  TransactionComplete = FALSE;

  Status              = EFI_SUCCESS;
  if (UnderRun != 0) {
    //
    // Offset starts in the middle of an Lba, so read the entire block.
    //
    Status = BlockIo->ReadBlocks (
                        BlockIo,
                        MediaId,
                        Lba,
                        BlockSize,
                        Data
                        );

    if (EFI_ERROR (Status)) {
      goto Done;
    }

    if (Length > BufferSize) {
      Length              = BufferSize;
      TransactionComplete = TRUE;
    }

    CopyMem (WorkingBuffer, Data + UnderRun, Length);

    WorkingBuffer += Length;

    WorkingBufferSize -= Length;
    if (WorkingBufferSize == 0) {
      goto Done;
    }

    Lba += 1;
  }

  OverRunLba = Lba + DivU64x32Remainder (WorkingBufferSize, BlockSize, &OverRun);

  if (!TransactionComplete && WorkingBufferSize >= BlockSize) {
    //
    // If the DiskIo maps directly to a BlockIo device do the read.
    //
    if (OverRun != 0) {
      WorkingBufferSize -= OverRun;
    }
    //
    // Check buffer alignment
    //
    IsBufferAligned = (UINTN) WorkingBuffer & (UINTN) (Media->IoAlign - 1);

    if (Media->IoAlign <= 1 || IsBufferAligned == 0) {
      //
      // Alignment is satisfied, so read them together
      //
      Status = BlockIo->ReadBlocks (
                          BlockIo,
                          MediaId,
                          Lba,
                          WorkingBufferSize,
                          WorkingBuffer
                          );

      if (EFI_ERROR (Status)) {
        goto Done;
      }

      WorkingBuffer += WorkingBufferSize;

    } else {
      //
      // Use the allocated buffer instead of the original buffer
      // to avoid alignment issue.
      // Here, the allocated buffer (8-byte align) can satisfy the alignment
      //
      LastRead = FALSE;
      do {
        if (WorkingBufferSize <= DataBufferSize) {
          //
          // It is the last calling to readblocks in this loop
          //
          DataBufferSize  = WorkingBufferSize;
          LastRead        = TRUE;
        }

        Status = BlockIo->ReadBlocks (
                            BlockIo,
                            MediaId,
                            Lba,
                            DataBufferSize,
                            Data
                            );
        if (EFI_ERROR (Status)) {
          goto Done;
        }

        CopyMem (WorkingBuffer, Data, DataBufferSize);
        WorkingBufferSize -= DataBufferSize;
        WorkingBuffer += DataBufferSize;
        Lba += DATA_BUFFER_BLOCK_NUM;
      } while (!LastRead);
    }
  }

  if (!TransactionComplete && OverRun != 0) {
    //
    // Last read is not a complete block.
    //
    Status = BlockIo->ReadBlocks (
                        BlockIo,
                        MediaId,
                        OverRunLba,
                        BlockSize,
                        Data
                        );

    if (EFI_ERROR (Status)) {
      goto Done;
    }

    CopyMem (WorkingBuffer, Data, OverRun);
  }

Done:
  if (PreData != NULL) {
    gBS->FreePool (PreData);
  }

  return Status;
}

EFI_STATUS
EFIAPI
DiskIoWriteDisk (
  IN EFI_DISK_IO_PROTOCOL  *This,
  IN UINT32                MediaId,
  IN UINT64                Offset,
  IN UINTN                 BufferSize,
  IN VOID                  *Buffer
  )
/*++

  Routine Description:
    Read BufferSize bytes from Offset into Buffer.

    Writes may require a read modify write to support writes that are not
    aligned on sector boundaries. There are three cases:

      UnderRun - The first byte is not on a sector boundary or the write request
                 is less than a sector in length. Read modify write is required.

      Aligned  - A write of N contiguous sectors.

      OverRun  - The last byte is not on a sector boundary. Read modified write
                 required.

  Arguments:
    This       - Protocol instance pointer.
    MediaId    - Id of the media, changes every time the media is replaced.
    Offset     - The starting byte offset to read from.
    BufferSize - Size of Buffer.
    Buffer     - Buffer containing read data.

  Returns:
    EFI_SUCCESS           - The data was written correctly to the device.
    EFI_WRITE_PROTECTED   - The device can not be written to.
    EFI_DEVICE_ERROR      - The device reported an error while performing the write.
    EFI_NO_MEDIA          - There is no media in the device.
    EFI_MEDIA_CHNAGED     - The MediaId does not matched the current device.
    EFI_INVALID_PARAMETER - The write request contains device addresses that are not
                            valid for the device.
    EFI_OUT_OF_RESOURCES

--*/
{
  EFI_STATUS            Status;
  DISK_IO_PRIVATE_DATA  *Private;
  EFI_BLOCK_IO_PROTOCOL *BlockIo;
  EFI_BLOCK_IO_MEDIA    *Media;
  UINT32                BlockSize;
  UINT64                Lba;
  UINT64                OverRunLba;
  UINT32                UnderRun;
  UINT32                OverRun;
  BOOLEAN               TransactionComplete;
  UINTN                 WorkingBufferSize;
  UINT8                 *WorkingBuffer;
  UINTN                 Length;
  UINT8                 *Data;
  UINT8                 *PreData;
  UINTN                 IsBufferAligned;
  UINTN                 DataBufferSize;
  BOOLEAN               LastWrite;

  Private   = DISK_IO_PRIVATE_DATA_FROM_THIS (This);

  BlockIo   = Private->BlockIo;
  Media     = BlockIo->Media;
  BlockSize = Media->BlockSize;

  if (Media->ReadOnly) {
    return EFI_WRITE_PROTECTED;
  }

  if (Media->MediaId != MediaId) {
    return EFI_MEDIA_CHANGED;
  }

  DataBufferSize = BlockSize * DATA_BUFFER_BLOCK_NUM;

  if (Media->IoAlign > 1) {
    PreData = AllocatePool (DataBufferSize + Media->IoAlign);
    Data    = PreData - ((UINTN) PreData & (Media->IoAlign - 1)) + Media->IoAlign;
  } else {
    PreData = AllocatePool (DataBufferSize);
    Data    = PreData;
  }

  if (PreData == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  WorkingBuffer       = Buffer;
  WorkingBufferSize   = BufferSize;

  Lba                 = DivU64x32Remainder (Offset, BlockSize, &UnderRun);

  Length              = BlockSize - UnderRun;
  TransactionComplete = FALSE;

  Status              = EFI_SUCCESS;
  if (UnderRun != 0) {
    //
    // Offset starts in the middle of an Lba, so do read modify write.
    //
    Status = BlockIo->ReadBlocks (
                        BlockIo,
                        MediaId,
                        Lba,
                        BlockSize,
                        Data
                        );

    if (EFI_ERROR (Status)) {
      goto Done;
    }

    if (Length > BufferSize) {
      Length              = BufferSize;
      TransactionComplete = TRUE;
    }

    CopyMem (Data + UnderRun, WorkingBuffer, Length);

    Status = BlockIo->WriteBlocks (
                        BlockIo,
                        MediaId,
                        Lba,
                        BlockSize,
                        Data
                        );
    if (EFI_ERROR (Status)) {
      goto Done;
    }

    WorkingBuffer += Length;
    WorkingBufferSize -= Length;
    if (WorkingBufferSize == 0) {
      goto Done;
    }

    Lba += 1;
  }

  OverRunLba = Lba + DivU64x32Remainder (WorkingBufferSize, BlockSize, &OverRun);

  if (!TransactionComplete && WorkingBufferSize >= BlockSize) {
    //
    // If the DiskIo maps directly to a BlockIo device do the write.
    //
    if (OverRun != 0) {
      WorkingBufferSize -= OverRun;
    }
    //
    // Check buffer alignment
    //
    IsBufferAligned = (UINTN) WorkingBuffer & (UINTN) (Media->IoAlign - 1);

    if (Media->IoAlign <= 1 || IsBufferAligned == 0) {
      //
      // Alignment is satisfied, so write them together
      //
      Status = BlockIo->WriteBlocks (
                          BlockIo,
                          MediaId,
                          Lba,
                          WorkingBufferSize,
                          WorkingBuffer
                          );

      if (EFI_ERROR (Status)) {
        goto Done;
      }

      WorkingBuffer += WorkingBufferSize;

    } else {
      //
      // The buffer parameter is not aligned with the request
      // So use the allocated instead.
      // It can fit almost all the cases.
      //
      LastWrite = FALSE;
      do {
        if (WorkingBufferSize <= DataBufferSize) {
          //
          // It is the last calling to writeblocks in this loop
          //
          DataBufferSize  = WorkingBufferSize;
          LastWrite       = TRUE;
        }

        CopyMem (Data, WorkingBuffer, DataBufferSize);
        Status = BlockIo->WriteBlocks (
                            BlockIo,
                            MediaId,
                            Lba,
                            DataBufferSize,
                            Data
                            );
        if (EFI_ERROR (Status)) {
          goto Done;
        }

        WorkingBufferSize -= DataBufferSize;
        WorkingBuffer += DataBufferSize;
        Lba += DATA_BUFFER_BLOCK_NUM;
      } while (!LastWrite);
    }
  }

  if (!TransactionComplete && OverRun != 0) {
    //
    // Last bit is not a complete block, so do a read modify write.
    //
    Status = BlockIo->ReadBlocks (
                        BlockIo,
                        MediaId,
                        OverRunLba,
                        BlockSize,
                        Data
                        );

    if (EFI_ERROR (Status)) {
      goto Done;
    }

    CopyMem (Data, WorkingBuffer, OverRun);

    Status = BlockIo->WriteBlocks (
                        BlockIo,
                        MediaId,
                        OverRunLba,
                        BlockSize,
                        Data
                        );
    if (EFI_ERROR (Status)) {
      goto Done;
    }
  }

Done:
  if (PreData != NULL) {
    gBS->FreePool (PreData);
  }

  return Status;
}
Commit	Line	Data
b83a1237 LG	1	/*++
	2
	3	Copyright (c) 2006, Intel Corporation
	4	All rights reserved. This program and the accompanying materials
	5	are licensed and made available under the terms and conditions of the BSD License
	6	which accompanies this distribution. The full text of the license may be found at
	7	http://opensource.org/licenses/bsd-license.php
	8
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	11
	12	Module Name:
	13
	14	DiskIo.c
	15
	16	Abstract:
	17
	18	DiskIo driver that layers it's self on every Block IO protocol in the system.
	19	DiskIo converts a block oriented device to a byte oriented device.
	20
	21	ReadDisk may have to do reads that are not aligned on sector boundaries.
	22	There are three cases:
	23
	24	UnderRun - The first byte is not on a sector boundary or the read request is
	25	less than a sector in length.
	26
	27	Aligned - A read of N contiguous sectors.
	28
	29	OverRun - The last byte is not on a sector boundary.
	30
	31	--*/
	32
	33	#include "DiskIo.h"
	34
	35	//
	36	// Prototypes
	37	// Driver model protocol interface
	38	//
	39	EFI_STATUS
	40	EFIAPI
	41	DiskIoDriverBindingSupported (
	42	IN EFI_DRIVER_BINDING_PROTOCOL *This,
	43	IN EFI_HANDLE ControllerHandle,
	44	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
	45	);
	46
	47	EFI_STATUS
	48	EFIAPI
	49	DiskIoDriverBindingStart (
	50	IN EFI_DRIVER_BINDING_PROTOCOL *This,
	51	IN EFI_HANDLE ControllerHandle,
	52	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
	53	);
	54
	55	EFI_STATUS
	56	EFIAPI
	57	DiskIoDriverBindingStop (
	58	IN EFI_DRIVER_BINDING_PROTOCOL *This,
	59	IN EFI_HANDLE ControllerHandle,
	60	IN UINTN NumberOfChildren,
	61	IN EFI_HANDLE *ChildHandleBuffer
	62	);
	63
	64	//
65	// Disk I/O Protocol Interface
66	//
67	EFI_STATUS
68	EFIAPI
69	DiskIoReadDisk (
70	IN EFI_DISK_IO_PROTOCOL *This,
71	IN UINT32 MediaId,
72	IN UINT64 Offset,
73	IN UINTN BufferSize,
74	OUT VOID *Buffer
75	);
76
77	EFI_STATUS
78	EFIAPI
79	DiskIoWriteDisk (
80	IN EFI_DISK_IO_PROTOCOL *This,
81	IN UINT32 MediaId,
82	IN UINT64 Offset,
83	IN UINTN BufferSize,
84	IN VOID *Buffer
85	);
86
87	EFI_DRIVER_BINDING_PROTOCOL gDiskIoDriverBinding = {
88	DiskIoDriverBindingSupported,
89	DiskIoDriverBindingStart,
90	DiskIoDriverBindingStop,
91	0x10,
92	NULL,
93	NULL
94	};
95
96	DISK_IO_PRIVATE_DATA gDiskIoPrivateDataTemplate = {
97	DISK_IO_PRIVATE_DATA_SIGNATURE,
98	{
99	EFI_DISK_IO_PROTOCOL_REVISION,
100	DiskIoReadDisk,
101	DiskIoWriteDisk
102	},
103	NULL
104	};
105
106	EFI_STATUS
107	EFIAPI
108	DiskIoDriverBindingSupported (
109	IN EFI_DRIVER_BINDING_PROTOCOL *This,
110	IN EFI_HANDLE ControllerHandle,
111	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
112	)
113	/*++
114
115	Routine Description:
116	Test to see if this driver supports ControllerHandle. Any ControllerHandle
117	than contains a BlockIo protocol can be supported.
118
119	Arguments:
120	This - Protocol instance pointer.
121	ControllerHandle - Handle of device to test.
122	RemainingDevicePath - Not used.
123
124	Returns:
125	EFI_SUCCESS - This driver supports this device.
126	EFI_ALREADY_STARTED - This driver is already running on this device.
127	other - This driver does not support this device.
128
129	--*/
130	{
131	EFI_STATUS Status;
132	EFI_BLOCK_IO_PROTOCOL *BlockIo;
133
134	//
135	// Open the IO Abstraction(s) needed to perform the supported test.
136	//
137	Status = gBS->OpenProtocol (
138	ControllerHandle,
139	&gEfiBlockIoProtocolGuid,
140	(VOID **) &BlockIo,
141	This->DriverBindingHandle,
142	ControllerHandle,
143	EFI_OPEN_PROTOCOL_BY_DRIVER
144	);
145	if (EFI_ERROR (Status)) {
146	return Status;
147	}
148	//
149	// Close the I/O Abstraction(s) used to perform the supported test.
150	//
151	gBS->CloseProtocol (
152	ControllerHandle,
153	&gEfiBlockIoProtocolGuid,
154	This->DriverBindingHandle,
155	ControllerHandle
156	);
157	return EFI_SUCCESS;
158	}
159
160	EFI_STATUS
161	EFIAPI
162	DiskIoDriverBindingStart (
163	IN EFI_DRIVER_BINDING_PROTOCOL *This,
164	IN EFI_HANDLE ControllerHandle,
165	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
166	)
167	/*++
168
169	Routine Description:
170	Start this driver on ControllerHandle by opening a Block IO protocol and
171	installing a Disk IO protocol on ControllerHandle.
172
173	Arguments:
174	This - Protocol instance pointer.
175	ControllerHandle - Handle of device to bind driver to.
176	RemainingDevicePath - Not used, always produce all possible children.
177
178	Returns:
179	EFI_SUCCESS - This driver is added to ControllerHandle.
180	EFI_ALREADY_STARTED - This driver is already running on ControllerHandle.
181	other - This driver does not support this device.
182
183	--*/
184	{
185	EFI_STATUS Status;
186	DISK_IO_PRIVATE_DATA *Private;
187
188	Private = NULL;
189
190	//
191	// Connect to the Block IO interface on ControllerHandle.
192	//
193	Status = gBS->OpenProtocol (
194	ControllerHandle,
195	&gEfiBlockIoProtocolGuid,
196	(VOID **) &gDiskIoPrivateDataTemplate.BlockIo,
197	This->DriverBindingHandle,
198	ControllerHandle,
199	EFI_OPEN_PROTOCOL_BY_DRIVER
200	);
201	if (EFI_ERROR (Status)) {
202	return Status;
203	}
204	//
205	// Initialize the Disk IO device instance.
206	//
207	Private = AllocateCopyPool (sizeof (DISK_IO_PRIVATE_DATA), &gDiskIoPrivateDataTemplate);
208	if (Private == NULL) {
209	Status = EFI_OUT_OF_RESOURCES;
210	goto ErrorExit;
211	}
212	//
213	// Install protocol interfaces for the Disk IO device.
214	//
215	Status = gBS->InstallProtocolInterface (
216	&ControllerHandle,
217	&gEfiDiskIoProtocolGuid,
218	EFI_NATIVE_INTERFACE,
219	&Private->DiskIo
220	);
221
222	ErrorExit:
223	if (EFI_ERROR (Status)) {
224
225	if (Private != NULL) {
226	gBS->FreePool (Private);
227	}
228
229	gBS->CloseProtocol (
230	ControllerHandle,
231	&gEfiBlockIoProtocolGuid,
232	This->DriverBindingHandle,
233	ControllerHandle
234	);
235	}
236
237	return Status;
238	}
239
240	EFI_STATUS
241	EFIAPI
242	DiskIoDriverBindingStop (
243	IN EFI_DRIVER_BINDING_PROTOCOL *This,
244	IN EFI_HANDLE ControllerHandle,
245	IN UINTN NumberOfChildren,
246	IN EFI_HANDLE *ChildHandleBuffer
247	)
248	/*++
249
250	Routine Description:
251	Stop this driver on ControllerHandle by removing Disk IO protocol and closing
252	the Block IO protocol on ControllerHandle.
253
254	Arguments:
255	This - Protocol instance pointer.
256	ControllerHandle - Handle of device to stop driver on.
257	NumberOfChildren - Not used.
258	ChildHandleBuffer - Not used.
259
260	Returns:
261	EFI_SUCCESS - This driver is removed ControllerHandle.
262	other - This driver was not removed from this device.
263	EFI_UNSUPPORTED
264
265	--*/
266	{
267	EFI_STATUS Status;
268	EFI_DISK_IO_PROTOCOL *DiskIo;
269	DISK_IO_PRIVATE_DATA *Private;
270
271	//
272	// Get our context back.
273	//
274	Status = gBS->OpenProtocol (
275	ControllerHandle,
276	&gEfiDiskIoProtocolGuid,
277	(VOID **) &DiskIo,
278	This->DriverBindingHandle,
279	ControllerHandle,
280	EFI_OPEN_PROTOCOL_GET_PROTOCOL
281	);
282	if (EFI_ERROR (Status)) {
283	return EFI_UNSUPPORTED;
284	}
285
286	Private = DISK_IO_PRIVATE_DATA_FROM_THIS (DiskIo);
287
288	Status = gBS->UninstallProtocolInterface (
289	ControllerHandle,
290	&gEfiDiskIoProtocolGuid,
291	&Private->DiskIo
292	);
293	if (!EFI_ERROR (Status)) {
294
295	Status = gBS->CloseProtocol (
296	ControllerHandle,
297	&gEfiBlockIoProtocolGuid,
298	This->DriverBindingHandle,
299	ControllerHandle
300	);
301	}
302
303	if (!EFI_ERROR (Status)) {
304	gBS->FreePool (Private);
305	}
306
307	return Status;
308	}
309
310	EFI_STATUS
311	EFIAPI
312	DiskIoReadDisk (
313	IN EFI_DISK_IO_PROTOCOL *This,
314	IN UINT32 MediaId,
315	IN UINT64 Offset,
316	IN UINTN BufferSize,
317	OUT VOID *Buffer
318	)
319	/*++
320
321	Routine Description:
322	Read BufferSize bytes from Offset into Buffer.
323
324	Reads may support reads that are not aligned on
325	sector boundaries. There are three cases:
326
327	UnderRun - The first byte is not on a sector boundary or the read request is
328	less than a sector in length.
329
330	Aligned - A read of N contiguous sectors.
331
332	OverRun - The last byte is not on a sector boundary.
333
334
335	Arguments:
336	This - Protocol instance pointer.
337	MediaId - Id of the media, changes every time the media is replaced.
338	Offset - The starting byte offset to read from.
339	BufferSize - Size of Buffer.
340	Buffer - Buffer containing read data.
341
342	Returns:
343	EFI_SUCCESS - The data was read correctly from the device.
344	EFI_DEVICE_ERROR - The device reported an error while performing the read.
345	EFI_NO_MEDIA - There is no media in the device.
346	EFI_MEDIA_CHNAGED - The MediaId does not matched the current device.
347	EFI_INVALID_PARAMETER - The read request contains device addresses that are not
348	valid for the device.
349	EFI_OUT_OF_RESOURCES
350
351	--*/
352	{
353	EFI_STATUS Status;
354	DISK_IO_PRIVATE_DATA *Private;
355	EFI_BLOCK_IO_PROTOCOL *BlockIo;
356	EFI_BLOCK_IO_MEDIA *Media;
357	UINT32 BlockSize;
358	UINT64 Lba;
359	UINT64 OverRunLba;
360	UINT32 UnderRun;
361	UINT32 OverRun;
362	BOOLEAN TransactionComplete;
363	UINTN WorkingBufferSize;
364	UINT8 *WorkingBuffer;
365	UINTN Length;
366	UINT8 *Data;
367	UINT8 *PreData;
368	UINTN IsBufferAligned;
369	UINTN DataBufferSize;
370	BOOLEAN LastRead;
371
372	Private = DISK_IO_PRIVATE_DATA_FROM_THIS (This);
373
374	BlockIo = Private->BlockIo;
375	Media = BlockIo->Media;
376	BlockSize = Media->BlockSize;
377
378	if (Media->MediaId != MediaId) {
379	return EFI_MEDIA_CHANGED;
380	}
381
382	WorkingBuffer = Buffer;
383	WorkingBufferSize = BufferSize;
384
385	//
386	// Allocate a temporary buffer for operation
387	//
388	DataBufferSize = BlockSize * DATA_BUFFER_BLOCK_NUM;
389
390	if (Media->IoAlign > 1) {
391	PreData = AllocatePool (DataBufferSize + Media->IoAlign);
392	Data = PreData - ((UINTN) PreData & (Media->IoAlign - 1)) + Media->IoAlign;
393	} else {
394	PreData = AllocatePool (DataBufferSize);
395	Data = PreData;
396	}
397
398	if (PreData == NULL) {
399	return EFI_OUT_OF_RESOURCES;
400	}
401
402	Lba = DivU64x32Remainder (Offset, BlockSize, &UnderRun);
403
404	Length = BlockSize - UnderRun;
405	TransactionComplete = FALSE;
406
407	Status = EFI_SUCCESS;
408	if (UnderRun != 0) {
409	//
410	// Offset starts in the middle of an Lba, so read the entire block.
411	//
412	Status = BlockIo->ReadBlocks (
413	BlockIo,
414	MediaId,
415	Lba,
416	BlockSize,
417	Data
418	);
419
420	if (EFI_ERROR (Status)) {
421	goto Done;
422	}
423
424	if (Length > BufferSize) {
425	Length = BufferSize;
426	TransactionComplete = TRUE;
427	}
428
429	CopyMem (WorkingBuffer, Data + UnderRun, Length);
430
431	WorkingBuffer += Length;
432
433	WorkingBufferSize -= Length;
434	if (WorkingBufferSize == 0) {
435	goto Done;
436	}
437
438	Lba += 1;
439	}
440
441	OverRunLba = Lba + DivU64x32Remainder (WorkingBufferSize, BlockSize, &OverRun);
442
443	if (!TransactionComplete && WorkingBufferSize >= BlockSize) {
444	//
445	// If the DiskIo maps directly to a BlockIo device do the read.
446	//
447	if (OverRun != 0) {
448	WorkingBufferSize -= OverRun;
449	}
450	//
451	// Check buffer alignment
452	//
453	IsBufferAligned = (UINTN) WorkingBuffer & (UINTN) (Media->IoAlign - 1);
454
455	if (Media->IoAlign <= 1 \|\| IsBufferAligned == 0) {
456	//
457	// Alignment is satisfied, so read them together
458	//
459	Status = BlockIo->ReadBlocks (
460	BlockIo,
461	MediaId,
462	Lba,
463	WorkingBufferSize,
464	WorkingBuffer
465	);
466
467	if (EFI_ERROR (Status)) {
468	goto Done;
469	}
470
471	WorkingBuffer += WorkingBufferSize;
472
473	} else {
474	//
475	// Use the allocated buffer instead of the original buffer
476	// to avoid alignment issue.
477	// Here, the allocated buffer (8-byte align) can satisfy the alignment
478	//
479	LastRead = FALSE;
480	do {
481	if (WorkingBufferSize <= DataBufferSize) {
482	//
483	// It is the last calling to readblocks in this loop
484	//
485	DataBufferSize = WorkingBufferSize;
486	LastRead = TRUE;
487	}
488
489	Status = BlockIo->ReadBlocks (
490	BlockIo,
491	MediaId,
492	Lba,
493	DataBufferSize,
494	Data
495	);
496	if (EFI_ERROR (Status)) {
497	goto Done;
498	}
499
500	CopyMem (WorkingBuffer, Data, DataBufferSize);
501	WorkingBufferSize -= DataBufferSize;
502	WorkingBuffer += DataBufferSize;
503	Lba += DATA_BUFFER_BLOCK_NUM;
504	} while (!LastRead);
505	}
506	}
507
508	if (!TransactionComplete && OverRun != 0) {
509	//
510	// Last read is not a complete block.
511	//
512	Status = BlockIo->ReadBlocks (
513	BlockIo,
514	MediaId,
515	OverRunLba,
516	BlockSize,
517	Data
518	);
519
520	if (EFI_ERROR (Status)) {
521	goto Done;
522	}
523
524	CopyMem (WorkingBuffer, Data, OverRun);
525	}
526
527	Done:
528	if (PreData != NULL) {
529	gBS->FreePool (PreData);
530	}
531
532	return Status;
533	}
534
535	EFI_STATUS
536	EFIAPI
537	DiskIoWriteDisk (
538	IN EFI_DISK_IO_PROTOCOL *This,
539	IN UINT32 MediaId,
540	IN UINT64 Offset,
541	IN UINTN BufferSize,
542	IN VOID *Buffer
543	)
544	/*++
545
546	Routine Description:
547	Read BufferSize bytes from Offset into Buffer.
548
549	Writes may require a read modify write to support writes that are not
550	aligned on sector boundaries. There are three cases:
551
552	UnderRun - The first byte is not on a sector boundary or the write request
553	is less than a sector in length. Read modify write is required.
554
555	Aligned - A write of N contiguous sectors.
556
557	OverRun - The last byte is not on a sector boundary. Read modified write
558	required.
559
560	Arguments:
561	This - Protocol instance pointer.
562	MediaId - Id of the media, changes every time the media is replaced.
563	Offset - The starting byte offset to read from.
564	BufferSize - Size of Buffer.
565	Buffer - Buffer containing read data.
566
567	Returns:
568	EFI_SUCCESS - The data was written correctly to the device.
569	EFI_WRITE_PROTECTED - The device can not be written to.
570	EFI_DEVICE_ERROR - The device reported an error while performing the write.
571	EFI_NO_MEDIA - There is no media in the device.
572	EFI_MEDIA_CHNAGED - The MediaId does not matched the current device.
573	EFI_INVALID_PARAMETER - The write request contains device addresses that are not
574	valid for the device.
575	EFI_OUT_OF_RESOURCES
576
577	--*/
578	{
579	EFI_STATUS Status;
580	DISK_IO_PRIVATE_DATA *Private;
581	EFI_BLOCK_IO_PROTOCOL *BlockIo;
582	EFI_BLOCK_IO_MEDIA *Media;
583	UINT32 BlockSize;
584	UINT64 Lba;
585	UINT64 OverRunLba;
586	UINT32 UnderRun;
587	UINT32 OverRun;
588	BOOLEAN TransactionComplete;
589	UINTN WorkingBufferSize;
590	UINT8 *WorkingBuffer;
591	UINTN Length;
592	UINT8 *Data;
593	UINT8 *PreData;
594	UINTN IsBufferAligned;
595	UINTN DataBufferSize;
596	BOOLEAN LastWrite;
597
598	Private = DISK_IO_PRIVATE_DATA_FROM_THIS (This);
599
600	BlockIo = Private->BlockIo;
601	Media = BlockIo->Media;
602	BlockSize = Media->BlockSize;
603
604	if (Media->ReadOnly) {
605	return EFI_WRITE_PROTECTED;
606	}
607
608	if (Media->MediaId != MediaId) {
609	return EFI_MEDIA_CHANGED;
610	}
611
612	DataBufferSize = BlockSize * DATA_BUFFER_BLOCK_NUM;
613
614	if (Media->IoAlign > 1) {
615	PreData = AllocatePool (DataBufferSize + Media->IoAlign);
616	Data = PreData - ((UINTN) PreData & (Media->IoAlign - 1)) + Media->IoAlign;
617	} else {
618	PreData = AllocatePool (DataBufferSize);
619	Data = PreData;
620	}
621
622	if (PreData == NULL) {
623	return EFI_OUT_OF_RESOURCES;
624	}
625
626	WorkingBuffer = Buffer;
627	WorkingBufferSize = BufferSize;
628
629	Lba = DivU64x32Remainder (Offset, BlockSize, &UnderRun);
630
631	Length = BlockSize - UnderRun;
632	TransactionComplete = FALSE;
633
634	Status = EFI_SUCCESS;
635	if (UnderRun != 0) {
636	//
637	// Offset starts in the middle of an Lba, so do read modify write.
638	//
639	Status = BlockIo->ReadBlocks (
640	BlockIo,
641	MediaId,
642	Lba,
643	BlockSize,
644	Data
645	);
646
647	if (EFI_ERROR (Status)) {
648	goto Done;
649	}
650
651	if (Length > BufferSize) {
652	Length = BufferSize;
653	TransactionComplete = TRUE;
654	}
655
656	CopyMem (Data + UnderRun, WorkingBuffer, Length);
657
658	Status = BlockIo->WriteBlocks (
659	BlockIo,
660	MediaId,
661	Lba,
662	BlockSize,
663	Data
664	);
665	if (EFI_ERROR (Status)) {
666	goto Done;
667	}
668
669	WorkingBuffer += Length;
670	WorkingBufferSize -= Length;
671	if (WorkingBufferSize == 0) {
672	goto Done;
673	}
674
675	Lba += 1;
676	}
677
678	OverRunLba = Lba + DivU64x32Remainder (WorkingBufferSize, BlockSize, &OverRun);
679
680	if (!TransactionComplete && WorkingBufferSize >= BlockSize) {
681	//
682	// If the DiskIo maps directly to a BlockIo device do the write.
683	//
684	if (OverRun != 0) {
685	WorkingBufferSize -= OverRun;
686	}
687	//
688	// Check buffer alignment
689	//
690	IsBufferAligned = (UINTN) WorkingBuffer & (UINTN) (Media->IoAlign - 1);
691
692	if (Media->IoAlign <= 1 \|\| IsBufferAligned == 0) {
693	//
694	// Alignment is satisfied, so write them together
695	//
696	Status = BlockIo->WriteBlocks (
697	BlockIo,
698	MediaId,
699	Lba,
700	WorkingBufferSize,
701	WorkingBuffer
702	);
703
704	if (EFI_ERROR (Status)) {
705	goto Done;
706	}
707
708	WorkingBuffer += WorkingBufferSize;
709
710	} else {
711	//
712	// The buffer parameter is not aligned with the request
713	// So use the allocated instead.
714	// It can fit almost all the cases.
715	//
716	LastWrite = FALSE;
717	do {
718	if (WorkingBufferSize <= DataBufferSize) {
719	//
720	// It is the last calling to writeblocks in this loop
721	//
722	DataBufferSize = WorkingBufferSize;
723	LastWrite = TRUE;
724	}
725
726	CopyMem (Data, WorkingBuffer, DataBufferSize);
727	Status = BlockIo->WriteBlocks (
728	BlockIo,
729	MediaId,
730	Lba,
731	DataBufferSize,
732	Data
733	);
734	if (EFI_ERROR (Status)) {
735	goto Done;
736	}
737
738	WorkingBufferSize -= DataBufferSize;
739	WorkingBuffer += DataBufferSize;
740	Lba += DATA_BUFFER_BLOCK_NUM;
741	} while (!LastWrite);
742	}
743	}
744
745	if (!TransactionComplete && OverRun != 0) {
746	//
747	// Last bit is not a complete block, so do a read modify write.
748	//
749	Status = BlockIo->ReadBlocks (
750	BlockIo,
751	MediaId,
752	OverRunLba,
753	BlockSize,
754	Data
755	);
756
757	if (EFI_ERROR (Status)) {
758	goto Done;
759	}
760
761	CopyMem (Data, WorkingBuffer, OverRun);
762
763	Status = BlockIo->WriteBlocks (
764	BlockIo,
765	MediaId,
766	OverRunLba,
767	BlockSize,
768	Data
769	);
770	if (EFI_ERROR (Status)) {
771	goto Done;
772	}
773	}
774
775	Done:
776	if (PreData != NULL) {
777	gBS->FreePool (PreData);
778	}
779
780	return Status;
781	}