1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * EFI block driver 4 * 5 * Copyright (c) 2017 Heinrich Schuchardt 6 * 7 * The EFI uclass creates a handle for this driver and installs the 8 * driver binding protocol on it. 9 * 10 * The EFI block driver binds to controllers implementing the block io 11 * protocol. 12 * 13 * When the bind function of the EFI block driver is called it creates a 14 * new U-Boot block device. It installs child handles for all partitions and 15 * installs the simple file protocol on these. 16 * 17 * The read and write functions of the EFI block driver delegate calls to the 18 * controller that it is bound to. 19 * 20 * A usage example is as following: 21 * 22 * U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and 23 * exposes a handle with the block IO protocol. It calls ConnectController. 24 * 25 * Now the EFI block driver installs the partitions with the simple file 26 * protocol. 27 * 28 * iPXE uses the simple file protocol to load Grub or the Linux Kernel. 29 */ 30 31 #include <efi_driver.h> 32 #include <dm/device-internal.h> 33 #include <dm/root.h> 34 35 /* 36 * EFI attributes of the udevice handled by this driver. 37 * 38 * handle handle of the controller on which this driver is installed 39 * io block io protocol proxied by this driver 40 */ 41 struct efi_blk_priv { 42 efi_handle_t handle; 43 struct efi_block_io *io; 44 }; 45 46 /* 47 * Read from block device 48 * 49 * @dev device 50 * @blknr first block to be read 51 * @blkcnt number of blocks to read 52 * @buffer output buffer 53 * @return number of blocks transferred 54 */ 55 static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 56 void *buffer) 57 { 58 struct efi_blk_priv *priv = dev->priv; 59 struct efi_block_io *io = priv->io; 60 efi_status_t ret; 61 62 EFI_PRINT("%s: read '%s', from block " LBAFU ", " LBAFU " blocks\n", 63 __func__, dev->name, blknr, blkcnt); 64 ret = EFI_CALL(io->read_blocks( 65 io, io->media->media_id, (u64)blknr, 66 (efi_uintn_t)blkcnt * 67 (efi_uintn_t)io->media->block_size, buffer)); 68 EFI_PRINT("%s: r = %u\n", __func__, 69 (unsigned int)(ret & ~EFI_ERROR_MASK)); 70 if (ret != EFI_SUCCESS) 71 return 0; 72 return blkcnt; 73 } 74 75 /* 76 * Write to block device 77 * 78 * @dev device 79 * @blknr first block to be write 80 * @blkcnt number of blocks to write 81 * @buffer input buffer 82 * @return number of blocks transferred 83 */ 84 static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, 85 const void *buffer) 86 { 87 struct efi_blk_priv *priv = dev->priv; 88 struct efi_block_io *io = priv->io; 89 efi_status_t ret; 90 91 EFI_PRINT("%s: write '%s', from block " LBAFU ", " LBAFU " blocks\n", 92 __func__, dev->name, blknr, blkcnt); 93 ret = EFI_CALL(io->write_blocks( 94 io, io->media->media_id, (u64)blknr, 95 (efi_uintn_t)blkcnt * 96 (efi_uintn_t)io->media->block_size, 97 (void *)buffer)); 98 EFI_PRINT("%s: r = %u\n", __func__, 99 (unsigned int)(ret & ~EFI_ERROR_MASK)); 100 if (ret != EFI_SUCCESS) 101 return 0; 102 return blkcnt; 103 } 104 105 /* 106 * Create partions for the block device. 107 * 108 * @handle EFI handle of the block device 109 * @dev udevice of the block device 110 */ 111 static int efi_bl_bind_partitions(efi_handle_t handle, struct udevice *dev) 112 { 113 struct blk_desc *desc; 114 const char *if_typename; 115 116 desc = dev_get_uclass_platdata(dev); 117 if_typename = blk_get_if_type_name(desc->if_type); 118 119 return efi_disk_create_partitions(handle, desc, if_typename, 120 desc->devnum, dev->name); 121 } 122 123 /* 124 * Create a block device for a handle 125 * 126 * @handle handle 127 * @interface block io protocol 128 * @return 0 = success 129 */ 130 static int efi_bl_bind(efi_handle_t handle, void *interface) 131 { 132 struct udevice *bdev, *parent = dm_root(); 133 int ret, devnum; 134 char *name; 135 struct efi_object *obj = efi_search_obj(handle); 136 struct efi_block_io *io = interface; 137 int disks; 138 struct efi_blk_priv *priv; 139 140 EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io); 141 142 if (!obj) 143 return -ENOENT; 144 145 devnum = blk_find_max_devnum(IF_TYPE_EFI); 146 if (devnum == -ENODEV) 147 devnum = 0; 148 else if (devnum < 0) 149 return devnum; 150 151 name = calloc(1, 18); /* strlen("efiblk#2147483648") + 1 */ 152 if (!name) 153 return -ENOMEM; 154 sprintf(name, "efiblk#%d", devnum); 155 156 /* Create driver model udevice for the EFI block io device */ 157 ret = blk_create_device(parent, "efi_blk", name, IF_TYPE_EFI, devnum, 158 io->media->block_size, 159 (lbaint_t)io->media->last_block, &bdev); 160 if (ret) 161 return ret; 162 if (!bdev) 163 return -ENOENT; 164 /* Allocate priv */ 165 ret = device_probe(bdev); 166 if (ret) 167 return ret; 168 EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name); 169 170 priv = bdev->priv; 171 priv->handle = handle; 172 priv->io = interface; 173 174 ret = blk_prepare_device(bdev); 175 176 /* Create handles for the partions of the block device */ 177 disks = efi_bl_bind_partitions(handle, bdev); 178 EFI_PRINT("Found %d partitions\n", disks); 179 180 return 0; 181 } 182 183 /* Block device driver operators */ 184 static const struct blk_ops efi_blk_ops = { 185 .read = efi_bl_read, 186 .write = efi_bl_write, 187 }; 188 189 /* Identify as block device driver */ 190 U_BOOT_DRIVER(efi_blk) = { 191 .name = "efi_blk", 192 .id = UCLASS_BLK, 193 .ops = &efi_blk_ops, 194 .priv_auto_alloc_size = sizeof(struct efi_blk_priv), 195 }; 196 197 /* EFI driver operators */ 198 static const struct efi_driver_ops driver_ops = { 199 .protocol = &efi_block_io_guid, 200 .child_protocol = &efi_block_io_guid, 201 .bind = efi_bl_bind, 202 }; 203 204 /* Identify as EFI driver */ 205 U_BOOT_DRIVER(efi_block) = { 206 .name = "EFI block driver", 207 .id = UCLASS_EFI, 208 .ops = &driver_ops, 209 }; 210
