1 /* 2 * EFI application disk support 3 * 4 * Copyright (c) 2016 Alexander Graf 5 * 6 * SPDX-License-Identifier: GPL-2.0+ 7 */ 8 9 #include <common.h> 10 #include <blk.h> 11 #include <dm.h> 12 #include <efi_loader.h> 13 #include <inttypes.h> 14 #include <part.h> 15 #include <malloc.h> 16 17 const efi_guid_t efi_block_io_guid = BLOCK_IO_GUID; 18 19 struct efi_disk_obj { 20 /* Generic EFI object parent class data */ 21 struct efi_object parent; 22 /* EFI Interface callback struct for block I/O */ 23 struct efi_block_io ops; 24 /* U-Boot ifname for block device */ 25 const char *ifname; 26 /* U-Boot dev_index for block device */ 27 int dev_index; 28 /* EFI Interface Media descriptor struct, referenced by ops */ 29 struct efi_block_io_media media; 30 /* EFI device path to this block device */ 31 struct efi_device_path *dp; 32 /* partition # */ 33 unsigned int part; 34 /* handle to filesys proto (for partition objects) */ 35 struct efi_simple_file_system_protocol *volume; 36 /* Offset into disk for simple partitions */ 37 lbaint_t offset; 38 /* Internal block device */ 39 struct blk_desc *desc; 40 }; 41 42 static efi_status_t EFIAPI efi_disk_reset(struct efi_block_io *this, 43 char extended_verification) 44 { 45 EFI_ENTRY("%p, %x", this, extended_verification); 46 return EFI_EXIT(EFI_DEVICE_ERROR); 47 } 48 49 enum efi_disk_direction { 50 EFI_DISK_READ, 51 EFI_DISK_WRITE, 52 }; 53 54 static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this, 55 u32 media_id, u64 lba, unsigned long buffer_size, 56 void *buffer, enum efi_disk_direction direction) 57 { 58 struct efi_disk_obj *diskobj; 59 struct blk_desc *desc; 60 int blksz; 61 int blocks; 62 unsigned long n; 63 64 diskobj = container_of(this, struct efi_disk_obj, ops); 65 desc = (struct blk_desc *) diskobj->desc; 66 blksz = desc->blksz; 67 blocks = buffer_size / blksz; 68 lba += diskobj->offset; 69 70 debug("EFI: %s:%d blocks=%x lba=%"PRIx64" blksz=%x dir=%d\n", __func__, 71 __LINE__, blocks, lba, blksz, direction); 72 73 /* We only support full block access */ 74 if (buffer_size & (blksz - 1)) 75 return EFI_DEVICE_ERROR; 76 77 if (direction == EFI_DISK_READ) 78 n = blk_dread(desc, lba, blocks, buffer); 79 else 80 n = blk_dwrite(desc, lba, blocks, buffer); 81 82 /* We don't do interrupts, so check for timers cooperatively */ 83 efi_timer_check(); 84 85 debug("EFI: %s:%d n=%lx blocks=%x\n", __func__, __LINE__, n, blocks); 86 87 if (n != blocks) 88 return EFI_DEVICE_ERROR; 89 90 return EFI_SUCCESS; 91 } 92 93 static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this, 94 u32 media_id, u64 lba, efi_uintn_t buffer_size, 95 void *buffer) 96 { 97 void *real_buffer = buffer; 98 efi_status_t r; 99 100 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER 101 if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) { 102 r = efi_disk_read_blocks(this, media_id, lba, 103 EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer); 104 if (r != EFI_SUCCESS) 105 return r; 106 return efi_disk_read_blocks(this, media_id, lba + 107 EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size, 108 buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE, 109 buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE); 110 } 111 112 real_buffer = efi_bounce_buffer; 113 #endif 114 115 EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba, 116 buffer_size, buffer); 117 118 r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer, 119 EFI_DISK_READ); 120 121 /* Copy from bounce buffer to real buffer if necessary */ 122 if ((r == EFI_SUCCESS) && (real_buffer != buffer)) 123 memcpy(buffer, real_buffer, buffer_size); 124 125 return EFI_EXIT(r); 126 } 127 128 static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this, 129 u32 media_id, u64 lba, efi_uintn_t buffer_size, 130 void *buffer) 131 { 132 void *real_buffer = buffer; 133 efi_status_t r; 134 135 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER 136 if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) { 137 r = efi_disk_write_blocks(this, media_id, lba, 138 EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer); 139 if (r != EFI_SUCCESS) 140 return r; 141 return efi_disk_write_blocks(this, media_id, lba + 142 EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size, 143 buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE, 144 buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE); 145 } 146 147 real_buffer = efi_bounce_buffer; 148 #endif 149 150 EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba, 151 buffer_size, buffer); 152 153 /* Populate bounce buffer if necessary */ 154 if (real_buffer != buffer) 155 memcpy(real_buffer, buffer, buffer_size); 156 157 r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer, 158 EFI_DISK_WRITE); 159 160 return EFI_EXIT(r); 161 } 162 163 static efi_status_t EFIAPI efi_disk_flush_blocks(struct efi_block_io *this) 164 { 165 /* We always write synchronously */ 166 EFI_ENTRY("%p", this); 167 return EFI_EXIT(EFI_SUCCESS); 168 } 169 170 static const struct efi_block_io block_io_disk_template = { 171 .reset = &efi_disk_reset, 172 .read_blocks = &efi_disk_read_blocks, 173 .write_blocks = &efi_disk_write_blocks, 174 .flush_blocks = &efi_disk_flush_blocks, 175 }; 176 177 /* 178 * Get the simple file system protocol for a file device path. 179 * 180 * The full path provided is split into device part and into a file 181 * part. The device part is used to find the handle on which the 182 * simple file system protocol is installed. 183 * 184 * @full_path device path including device and file 185 * @return simple file system protocol 186 */ 187 struct efi_simple_file_system_protocol * 188 efi_fs_from_path(struct efi_device_path *full_path) 189 { 190 struct efi_object *efiobj; 191 struct efi_handler *handler; 192 struct efi_device_path *device_path; 193 struct efi_device_path *file_path; 194 efi_status_t ret; 195 196 /* Split the path into a device part and a file part */ 197 ret = efi_dp_split_file_path(full_path, &device_path, &file_path); 198 if (ret != EFI_SUCCESS) 199 return NULL; 200 efi_free_pool(file_path); 201 202 /* Get the EFI object for the partition */ 203 efiobj = efi_dp_find_obj(device_path, NULL); 204 efi_free_pool(device_path); 205 if (!efiobj) 206 return NULL; 207 208 /* Find the simple file system protocol */ 209 ret = efi_search_protocol(efiobj, &efi_simple_file_system_protocol_guid, 210 &handler); 211 if (ret != EFI_SUCCESS) 212 return NULL; 213 214 /* Return the simple file system protocol for the partition */ 215 return handler->protocol_interface; 216 } 217 218 /* 219 * Create a handle for a partition or disk 220 * 221 * @parent parent handle 222 * @dp_parent parent device path 223 * @if_typename interface name for block device 224 * @desc internal block device 225 * @dev_index device index for block device 226 * @offset offset into disk for simple partitions 227 * @return disk object 228 */ 229 static efi_status_t efi_disk_add_dev( 230 efi_handle_t parent, 231 struct efi_device_path *dp_parent, 232 const char *if_typename, 233 struct blk_desc *desc, 234 int dev_index, 235 lbaint_t offset, 236 unsigned int part, 237 struct efi_disk_obj **disk) 238 { 239 struct efi_disk_obj *diskobj; 240 efi_status_t ret; 241 242 /* Don't add empty devices */ 243 if (!desc->lba) 244 return EFI_NOT_READY; 245 246 diskobj = calloc(1, sizeof(*diskobj)); 247 if (!diskobj) 248 return EFI_OUT_OF_RESOURCES; 249 250 /* Hook up to the device list */ 251 efi_add_handle(&diskobj->parent); 252 253 /* Fill in object data */ 254 if (part) { 255 struct efi_device_path *node = efi_dp_part_node(desc, part); 256 257 diskobj->dp = efi_dp_append_node(dp_parent, node); 258 efi_free_pool(node); 259 } else { 260 diskobj->dp = efi_dp_from_part(desc, part); 261 } 262 diskobj->part = part; 263 ret = efi_add_protocol(diskobj->parent.handle, &efi_block_io_guid, 264 &diskobj->ops); 265 if (ret != EFI_SUCCESS) 266 return ret; 267 ret = efi_add_protocol(diskobj->parent.handle, &efi_guid_device_path, 268 diskobj->dp); 269 if (ret != EFI_SUCCESS) 270 return ret; 271 if (part >= 1) { 272 diskobj->volume = efi_simple_file_system(desc, part, 273 diskobj->dp); 274 ret = efi_add_protocol(diskobj->parent.handle, 275 &efi_simple_file_system_protocol_guid, 276 diskobj->volume); 277 if (ret != EFI_SUCCESS) 278 return ret; 279 } 280 diskobj->ops = block_io_disk_template; 281 diskobj->ifname = if_typename; 282 diskobj->dev_index = dev_index; 283 diskobj->offset = offset; 284 diskobj->desc = desc; 285 286 /* Fill in EFI IO Media info (for read/write callbacks) */ 287 diskobj->media.removable_media = desc->removable; 288 diskobj->media.media_present = 1; 289 diskobj->media.block_size = desc->blksz; 290 diskobj->media.io_align = desc->blksz; 291 diskobj->media.last_block = desc->lba - offset; 292 if (part != 0) 293 diskobj->media.logical_partition = 1; 294 diskobj->ops.media = &diskobj->media; 295 if (disk) 296 *disk = diskobj; 297 return EFI_SUCCESS; 298 } 299 300 /* 301 * Create handles and protocols for the partitions of a block device 302 * 303 * @parent handle of the parent disk 304 * @blk_desc block device 305 * @if_typename interface type 306 * @diskid device number 307 * @pdevname device name 308 * @return number of partitions created 309 */ 310 int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, 311 const char *if_typename, int diskid, 312 const char *pdevname) 313 { 314 int disks = 0; 315 char devname[32] = { 0 }; /* dp->str is u16[32] long */ 316 disk_partition_t info; 317 int part; 318 struct efi_device_path *dp = NULL; 319 efi_status_t ret; 320 struct efi_handler *handler; 321 322 /* Get the device path of the parent */ 323 ret = efi_search_protocol(parent, &efi_guid_device_path, &handler); 324 if (ret == EFI_SUCCESS) 325 dp = handler->protocol_interface; 326 327 /* Add devices for each partition */ 328 for (part = 1; part <= MAX_SEARCH_PARTITIONS; part++) { 329 if (part_get_info(desc, part, &info)) 330 continue; 331 snprintf(devname, sizeof(devname), "%s:%d", pdevname, 332 part); 333 ret = efi_disk_add_dev(parent, dp, if_typename, desc, diskid, 334 info.start, part, NULL); 335 if (ret != EFI_SUCCESS) { 336 printf("Adding partition %s failed\n", pdevname); 337 continue; 338 } 339 disks++; 340 } 341 342 return disks; 343 } 344 345 /* 346 * U-Boot doesn't have a list of all online disk devices. So when running our 347 * EFI payload, we scan through all of the potentially available ones and 348 * store them in our object pool. 349 * 350 * TODO(sjg@chromium.org): Actually with CONFIG_BLK, U-Boot does have this. 351 * Consider converting the code to look up devices as needed. The EFI device 352 * could be a child of the UCLASS_BLK block device, perhaps. 353 * 354 * This gets called from do_bootefi_exec(). 355 */ 356 efi_status_t efi_disk_register(void) 357 { 358 struct efi_disk_obj *disk; 359 int disks = 0; 360 efi_status_t ret; 361 #ifdef CONFIG_BLK 362 struct udevice *dev; 363 364 for (uclass_first_device_check(UCLASS_BLK, &dev); dev; 365 uclass_next_device_check(&dev)) { 366 struct blk_desc *desc = dev_get_uclass_platdata(dev); 367 const char *if_typename = blk_get_if_type_name(desc->if_type); 368 369 /* Add block device for the full device */ 370 printf("Scanning disk %s...\n", dev->name); 371 ret = efi_disk_add_dev(NULL, NULL, if_typename, 372 desc, desc->devnum, 0, 0, &disk); 373 if (ret == EFI_NOT_READY) { 374 printf("Disk %s not ready\n", dev->name); 375 continue; 376 } 377 if (ret) { 378 printf("ERROR: failure to add disk device %s, r = %lu\n", 379 dev->name, ret & ~EFI_ERROR_MASK); 380 return ret; 381 } 382 disks++; 383 384 /* Partitions show up as block devices in EFI */ 385 disks += efi_disk_create_partitions( 386 disk->parent.handle, desc, if_typename, 387 desc->devnum, dev->name); 388 } 389 #else 390 int i, if_type; 391 392 /* Search for all available disk devices */ 393 for (if_type = 0; if_type < IF_TYPE_COUNT; if_type++) { 394 const struct blk_driver *cur_drvr; 395 const char *if_typename; 396 397 cur_drvr = blk_driver_lookup_type(if_type); 398 if (!cur_drvr) 399 continue; 400 401 if_typename = cur_drvr->if_typename; 402 printf("Scanning disks on %s...\n", if_typename); 403 for (i = 0; i < 4; i++) { 404 struct blk_desc *desc; 405 char devname[32] = { 0 }; /* dp->str is u16[32] long */ 406 407 desc = blk_get_devnum_by_type(if_type, i); 408 if (!desc) 409 continue; 410 if (desc->type == DEV_TYPE_UNKNOWN) 411 continue; 412 413 snprintf(devname, sizeof(devname), "%s%d", 414 if_typename, i); 415 416 /* Add block device for the full device */ 417 ret = efi_disk_add_dev(NULL, NULL, if_typename, desc, 418 i, 0, 0, &disk); 419 if (ret == EFI_NOT_READY) { 420 printf("Disk %s not ready\n", devname); 421 continue; 422 } 423 if (ret) { 424 printf("ERROR: failure to add disk device %s, r = %lu\n", 425 devname, ret & ~EFI_ERROR_MASK); 426 return ret; 427 } 428 disks++; 429 430 /* Partitions show up as block devices in EFI */ 431 disks += efi_disk_create_partitions( 432 disk->parent.handle, desc, 433 if_typename, i, devname); 434 } 435 } 436 #endif 437 printf("Found %d disks\n", disks); 438 439 return EFI_SUCCESS; 440 } 441