blob: d9d2b14f61244dcf8575e833b1e0c7318e256fde [file] [log] [blame]
/*
* EFI block driver
*
* Copyright (c) 2017 Heinrich Schuchardt
*
* SPDX-License-Identifier: GPL-2.0+
*
* The EFI uclass creates a handle for this driver and installs the
* driver binding protocol on it.
*
* The EFI block driver binds to controllers implementing the block io
* protocol.
*
* When the bind function of the EFI block driver is called it creates a
* new U-Boot block device. It installs child handles for all partitions and
* installs the simple file protocol on these.
*
* The read and write functions of the EFI block driver delegate calls to the
* controller that it is bound to.
*
* A usage example is as following:
*
* U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and
* exposes a handle with the block IO protocol. It calls ConnectController.
*
* Now the EFI block driver installs the partitions with the simple file
* protocol.
*
* iPXE uses the simple file protocol to load Grub or the Linux Kernel.
*/
#include <efi_driver.h>
#include <dm/device-internal.h>
#include <dm/root.h>
/*
* EFI attributes of the udevice handled by this driver.
*
* handle handle of the controller on which this driver is installed
* io block io protocol proxied by this driver
*/
struct efi_blk_priv {
efi_handle_t handle;
struct efi_block_io *io;
};
/*
* Read from block device
*
* @dev device
* @blknr first block to be read
* @blkcnt number of blocks to read
* @buffer output buffer
* @return number of blocks transferred
*/
static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
void *buffer)
{
struct efi_blk_priv *priv = dev->priv;
struct efi_block_io *io = priv->io;
efi_status_t ret;
EFI_PRINT("%s: read '%s', from block " LBAFU ", " LBAFU " blocks\n",
__func__, dev->name, blknr, blkcnt);
ret = EFI_CALL(io->read_blocks(
io, io->media->media_id, (u64)blknr,
(efi_uintn_t)blkcnt *
(efi_uintn_t)io->media->block_size, buffer));
EFI_PRINT("%s: r = %u\n", __func__,
(unsigned int)(ret & ~EFI_ERROR_MASK));
if (ret != EFI_SUCCESS)
return 0;
return blkcnt;
}
/*
* Write to block device
*
* @dev device
* @blknr first block to be write
* @blkcnt number of blocks to write
* @buffer input buffer
* @return number of blocks transferred
*/
static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
const void *buffer)
{
struct efi_blk_priv *priv = dev->priv;
struct efi_block_io *io = priv->io;
efi_status_t ret;
EFI_PRINT("%s: write '%s', from block " LBAFU ", " LBAFU " blocks\n",
__func__, dev->name, blknr, blkcnt);
ret = EFI_CALL(io->write_blocks(
io, io->media->media_id, (u64)blknr,
(efi_uintn_t)blkcnt *
(efi_uintn_t)io->media->block_size,
(void *)buffer));
EFI_PRINT("%s: r = %u\n", __func__,
(unsigned int)(ret & ~EFI_ERROR_MASK));
if (ret != EFI_SUCCESS)
return 0;
return blkcnt;
}
/*
* Create partions for the block device.
*
* @handle EFI handle of the block device
* @dev udevice of the block device
*/
static int efi_bl_bind_partitions(efi_handle_t handle, struct udevice *dev)
{
struct blk_desc *desc;
const char *if_typename;
desc = dev_get_uclass_platdata(dev);
if_typename = blk_get_if_type_name(desc->if_type);
return efi_disk_create_partitions(handle, desc, if_typename,
desc->devnum, dev->name);
}
/*
* Create a block device for a handle
*
* @handle handle
* @interface block io protocol
* @return 0 = success
*/
static int efi_bl_bind(efi_handle_t handle, void *interface)
{
struct udevice *bdev, *parent = dm_root();
int ret, devnum;
char *name;
struct efi_object *obj = efi_search_obj(handle);
struct efi_block_io *io = interface;
int disks;
struct efi_blk_priv *priv;
EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
if (!obj)
return -ENOENT;
devnum = blk_find_max_devnum(IF_TYPE_EFI);
if (devnum == -ENODEV)
devnum = 0;
else if (devnum < 0)
return devnum;
name = calloc(1, 18); /* strlen("efiblk#2147483648") + 1 */
if (!name)
return -ENOMEM;
sprintf(name, "efiblk#%d", devnum);
/* Create driver model udevice for the EFI block io device */
ret = blk_create_device(parent, "efi_blk", name, IF_TYPE_EFI, devnum,
io->media->block_size,
(lbaint_t)io->media->last_block, &bdev);
if (ret)
return ret;
if (!bdev)
return -ENOENT;
/* Allocate priv */
ret = device_probe(bdev);
if (ret)
return ret;
EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
priv = bdev->priv;
priv->handle = handle;
priv->io = interface;
ret = blk_prepare_device(bdev);
/* Create handles for the partions of the block device */
disks = efi_bl_bind_partitions(handle, bdev);
EFI_PRINT("Found %d partitions\n", disks);
return 0;
}
/* Block device driver operators */
static const struct blk_ops efi_blk_ops = {
.read = efi_bl_read,
.write = efi_bl_write,
};
/* Identify as block device driver */
U_BOOT_DRIVER(efi_blk) = {
.name = "efi_blk",
.id = UCLASS_BLK,
.ops = &efi_blk_ops,
.priv_auto_alloc_size = sizeof(struct efi_blk_priv),
};
/* EFI driver operators */
static const struct efi_driver_ops driver_ops = {
.protocol = &efi_block_io_guid,
.child_protocol = &efi_block_io_guid,
.bind = efi_bl_bind,
};
/* Identify as EFI driver */
U_BOOT_DRIVER(efi_block) = {
.name = "EFI block driver",
.id = UCLASS_EFI,
.ops = &driver_ops,
};