lib/efi_loader/efi_disk.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  EFI application disk support
   4  *
   5  *  Copyright (c) 2016 Alexander Graf
   6  */
   7
   8 #define LOG_CATEGORY LOGC_EFI
   9
  10 #include <common.h>
  11 #include <blk.h>
  12 #include <dm.h>
  13 #include <dm/device-internal.h>
  14 #include <dm/tag.h>
  15 #include <event.h>
  16 #include <efi_driver.h>
  17 #include <efi_loader.h>
  18 #include <fs.h>
  19 #include <log.h>
  20 #include <part.h>
  21 #include <malloc.h>
  22
  23 struct efi_system_partition efi_system_partition = {
  24         .uclass_id = UCLASS_INVALID,
  25 };
  26
  27 const efi_guid_t efi_block_io_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
  28 const efi_guid_t efi_system_partition_guid = PARTITION_SYSTEM_GUID;
  29
  30 /**
  31  * struct efi_disk_obj - EFI disk object
  32  *
  33  * @header:     EFI object header
  34  * @ops:        EFI disk I/O protocol interface
  35  * @dev_index:  device index of block device
  36  * @media:      block I/O media information
  37  * @dp:         device path to the block device
  38  * @part:       partition
  39  * @volume:     simple file system protocol of the partition
  40  * @dev:        associated DM device
  41  */
  42 struct efi_disk_obj {
  43         struct efi_object header;
  44         struct efi_block_io ops;
  45         int dev_index;
  46         struct efi_block_io_media media;
  47         struct efi_device_path *dp;
  48         unsigned int part;
  49         struct efi_simple_file_system_protocol *volume;
  50 };
  51
  52 /**
  53  * efi_disk_reset() - reset block device
  54  *
  55  * This function implements the Reset service of the EFI_BLOCK_IO_PROTOCOL.
  56  *
  57  * As U-Boot's block devices do not have a reset function simply return
  58  * EFI_SUCCESS.
  59  *
  60  * See the Unified Extensible Firmware Interface (UEFI) specification for
  61  * details.
  62  *
  63  * @this:                       pointer to the BLOCK_IO_PROTOCOL
  64  * @extended_verification:      extended verification
  65  * Return:                      status code
  66  */
  67 static efi_status_t EFIAPI efi_disk_reset(struct efi_block_io *this,
  68                         char extended_verification)
  69 {
  70         EFI_ENTRY("%p, %x", this, extended_verification);
  71         return EFI_EXIT(EFI_SUCCESS);
  72 }
  73
  74 /**
  75  * efi_disk_is_removable() - check if the device is removable media
  76  * @handle:             efi object handle;
  77  *
  78  * Examine the device and determine if the device is a local block device
  79  * and removable media.
  80  *
  81  * Return:              true if removable, false otherwise
  82  */
  83 bool efi_disk_is_removable(efi_handle_t handle)
  84 {
  85         struct efi_handler *handler;
  86         struct efi_block_io *io;
  87         efi_status_t ret;
  88
  89         ret = efi_search_protocol(handle, &efi_block_io_guid, &handler);
  90         if (ret != EFI_SUCCESS)
  91                 return false;
  92
  93         io = handler->protocol_interface;
  94
  95         if (!io || !io->media)
  96                 return false;
  97
  98         return (bool)io->media->removable_media;
  99 }
 100
 101 enum efi_disk_direction {
 102         EFI_DISK_READ,
 103         EFI_DISK_WRITE,
 104 };
 105
 106 static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this,
 107                         u32 media_id, u64 lba, unsigned long buffer_size,
 108                         void *buffer, enum efi_disk_direction direction)
 109 {
 110         struct efi_disk_obj *diskobj;
 111         int blksz;
 112         int blocks;
 113         unsigned long n;
 114
 115         diskobj = container_of(this, struct efi_disk_obj, ops);
 116         blksz = diskobj->media.block_size;
 117         blocks = buffer_size / blksz;
 118
 119         EFI_PRINT("blocks=%x lba=%llx blksz=%x dir=%d\n",
 120                   blocks, lba, blksz, direction);
 121
 122         /* We only support full block access */
 123         if (buffer_size & (blksz - 1))
 124                 return EFI_BAD_BUFFER_SIZE;
 125
 126         if (CONFIG_IS_ENABLED(PARTITIONS) &&
 127             device_get_uclass_id(diskobj->header.dev) == UCLASS_PARTITION) {
 128                 if (direction == EFI_DISK_READ)
 129                         n = disk_blk_read(diskobj->header.dev, lba, blocks,
 130                                           buffer);
 131                 else
 132                         n = disk_blk_write(diskobj->header.dev, lba, blocks,
 133                                            buffer);
 134         } else {
 135                 /* dev is a block device (UCLASS_BLK) */
 136                 struct blk_desc *desc;
 137
 138                 desc = dev_get_uclass_plat(diskobj->header.dev);
 139                 if (direction == EFI_DISK_READ)
 140                         n = blk_dread(desc, lba, blocks, buffer);
 141                 else
 142                         n = blk_dwrite(desc, lba, blocks, buffer);
 143         }
 144
 145         /* We don't do interrupts, so check for timers cooperatively */
 146         efi_timer_check();
 147
 148         EFI_PRINT("n=%lx blocks=%x\n", n, blocks);
 149
 150         if (n != blocks)
 151                 return EFI_DEVICE_ERROR;
 152
 153         return EFI_SUCCESS;
 154 }
 155
 156 /**
 157  * efi_disk_read_blocks() - reads blocks from device
 158  *
 159  * This function implements the ReadBlocks service of the EFI_BLOCK_IO_PROTOCOL.
 160  *
 161  * See the Unified Extensible Firmware Interface (UEFI) specification for
 162  * details.
 163  *
 164  * @this:                       pointer to the BLOCK_IO_PROTOCOL
 165  * @media_id:                   id of the medium to be read from
 166  * @lba:                        starting logical block for reading
 167  * @buffer_size:                size of the read buffer
 168  * @buffer:                     pointer to the destination buffer
 169  * Return:                      status code
 170  */
 171 static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
 172                         u32 media_id, u64 lba, efi_uintn_t buffer_size,
 173                         void *buffer)
 174 {
 175         void *real_buffer = buffer;
 176         efi_status_t r;
 177
 178         if (!this)
 179                 return EFI_INVALID_PARAMETER;
 180         /* TODO: check for media changes */
 181         if (media_id != this->media->media_id)
 182                 return EFI_MEDIA_CHANGED;
 183         if (!this->media->media_present)
 184                 return EFI_NO_MEDIA;
 185         /* media->io_align is a power of 2 or 0 */
 186         if (this->media->io_align &&
 187             (uintptr_t)buffer & (this->media->io_align - 1))
 188                 return EFI_INVALID_PARAMETER;
 189         if (lba * this->media->block_size + buffer_size >
 190             (this->media->last_block + 1) * this->media->block_size)
 191                 return EFI_INVALID_PARAMETER;
 192
 193 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
 194         if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) {
 195                 r = efi_disk_read_blocks(this, media_id, lba,
 196                         EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer);
 197                 if (r != EFI_SUCCESS)
 198                         return r;
 199                 return efi_disk_read_blocks(this, media_id, lba +
 200                         EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size,
 201                         buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE,
 202                         buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE);
 203         }
 204
 205         real_buffer = efi_bounce_buffer;
 206 #endif
 207
 208         EFI_ENTRY("%p, %x, %llx, %zx, %p", this, media_id, lba,
 209                   buffer_size, buffer);
 210
 211         r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
 212                                EFI_DISK_READ);
 213
 214         /* Copy from bounce buffer to real buffer if necessary */
 215         if ((r == EFI_SUCCESS) && (real_buffer != buffer))
 216                 memcpy(buffer, real_buffer, buffer_size);
 217
 218         return EFI_EXIT(r);
 219 }
 220
 221 /**
 222  * efi_disk_write_blocks() - writes blocks to device
 223  *
 224  * This function implements the WriteBlocks service of the
 225  * EFI_BLOCK_IO_PROTOCOL.
 226  *
 227  * See the Unified Extensible Firmware Interface (UEFI) specification for
 228  * details.
 229  *
 230  * @this:                       pointer to the BLOCK_IO_PROTOCOL
 231  * @media_id:                   id of the medium to be written to
 232  * @lba:                        starting logical block for writing
 233  * @buffer_size:                size of the write buffer
 234  * @buffer:                     pointer to the source buffer
 235  * Return:                      status code
 236  */
 237 static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
 238                         u32 media_id, u64 lba, efi_uintn_t buffer_size,
 239                         void *buffer)
 240 {
 241         void *real_buffer = buffer;
 242         efi_status_t r;
 243
 244         if (!this)
 245                 return EFI_INVALID_PARAMETER;
 246         if (this->media->read_only)
 247                 return EFI_WRITE_PROTECTED;
 248         /* TODO: check for media changes */
 249         if (media_id != this->media->media_id)
 250                 return EFI_MEDIA_CHANGED;
 251         if (!this->media->media_present)
 252                 return EFI_NO_MEDIA;
 253         /* media->io_align is a power of 2 or 0 */
 254         if (this->media->io_align &&
 255             (uintptr_t)buffer & (this->media->io_align - 1))
 256                 return EFI_INVALID_PARAMETER;
 257         if (lba * this->media->block_size + buffer_size >
 258             (this->media->last_block + 1) * this->media->block_size)
 259                 return EFI_INVALID_PARAMETER;
 260
 261 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
 262         if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) {
 263                 r = efi_disk_write_blocks(this, media_id, lba,
 264                         EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer);
 265                 if (r != EFI_SUCCESS)
 266                         return r;
 267                 return efi_disk_write_blocks(this, media_id, lba +
 268                         EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size,
 269                         buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE,
 270                         buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE);
 271         }
 272
 273         real_buffer = efi_bounce_buffer;
 274 #endif
 275
 276         EFI_ENTRY("%p, %x, %llx, %zx, %p", this, media_id, lba,
 277                   buffer_size, buffer);
 278
 279         /* Populate bounce buffer if necessary */
 280         if (real_buffer != buffer)
 281                 memcpy(real_buffer, buffer, buffer_size);
 282
 283         r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
 284                                EFI_DISK_WRITE);
 285
 286         return EFI_EXIT(r);
 287 }
 288
 289 /**
 290  * efi_disk_flush_blocks() - flushes modified data to the device
 291  *
 292  * This function implements the FlushBlocks service of the
 293  * EFI_BLOCK_IO_PROTOCOL.
 294  *
 295  * As we always write synchronously nothing is done here.
 296  *
 297  * See the Unified Extensible Firmware Interface (UEFI) specification for
 298  * details.
 299  *
 300  * @this:                       pointer to the BLOCK_IO_PROTOCOL
 301  * Return:                      status code
 302  */
 303 static efi_status_t EFIAPI efi_disk_flush_blocks(struct efi_block_io *this)
 304 {
 305         EFI_ENTRY("%p", this);
 306         return EFI_EXIT(EFI_SUCCESS);
 307 }
 308
 309 static const struct efi_block_io block_io_disk_template = {
 310         .reset = &efi_disk_reset,
 311         .read_blocks = &efi_disk_read_blocks,
 312         .write_blocks = &efi_disk_write_blocks,
 313         .flush_blocks = &efi_disk_flush_blocks,
 314 };
 315
 316 /**
 317  * efi_fs_from_path() - retrieve simple file system protocol
 318  *
 319  * Gets the simple file system protocol for a file device path.
 320  *
 321  * The full path provided is split into device part and into a file
 322  * part. The device part is used to find the handle on which the
 323  * simple file system protocol is installed.
 324  *
 325  * @full_path:  device path including device and file
 326  * Return:      simple file system protocol
 327  */
 328 struct efi_simple_file_system_protocol *
 329 efi_fs_from_path(struct efi_device_path *full_path)
 330 {
 331         struct efi_object *efiobj;
 332         struct efi_handler *handler;
 333         struct efi_device_path *device_path;
 334         struct efi_device_path *file_path;
 335         efi_status_t ret;
 336
 337         /* Split the path into a device part and a file part */
 338         ret = efi_dp_split_file_path(full_path, &device_path, &file_path);
 339         if (ret != EFI_SUCCESS)
 340                 return NULL;
 341         efi_free_pool(file_path);
 342
 343         /* Get the EFI object for the partition */
 344         efiobj = efi_dp_find_obj(device_path, NULL, NULL);
 345         efi_free_pool(device_path);
 346         if (!efiobj)
 347                 return NULL;
 348
 349         /* Find the simple file system protocol */
 350         ret = efi_search_protocol(efiobj, &efi_simple_file_system_protocol_guid,
 351                                   &handler);
 352         if (ret != EFI_SUCCESS)
 353                 return NULL;
 354
 355         /* Return the simple file system protocol for the partition */
 356         return handler->protocol_interface;
 357 }
 358
 359 /**
 360  * efi_fs_exists() - check if a partition bears a file system
 361  *
 362  * @desc:       block device descriptor
 363  * @part:       partition number
 364  * Return:      1 if a file system exists on the partition
 365  *              0 otherwise
 366  */
 367 static int efi_fs_exists(struct blk_desc *desc, int part)
 368 {
 369         if (fs_set_blk_dev_with_part(desc, part))
 370                 return 0;
 371
 372         if (fs_get_type() == FS_TYPE_ANY)
 373                 return 0;
 374
 375         fs_close();
 376
 377         return 1;
 378 }
 379
 380 /**
 381  * efi_disk_add_dev() - create a handle for a partition or disk
 382  *
 383  * @parent:             parent handle
 384  * @dp_parent:          parent device path
 385  * @desc:               internal block device
 386  * @dev_index:          device index for block device
 387  * @part_info:          partition info
 388  * @part:               partition
 389  * @disk:               pointer to receive the created handle
 390  * @agent_handle:       handle of the EFI block driver
 391  * Return:              disk object
 392  */
 393 static efi_status_t efi_disk_add_dev(
 394                                 efi_handle_t parent,
 395                                 struct efi_device_path *dp_parent,
 396                                 struct blk_desc *desc,
 397                                 int dev_index,
 398                                 struct disk_partition *part_info,
 399                                 unsigned int part,
 400                                 struct efi_disk_obj **disk,
 401                                 efi_handle_t agent_handle)
 402 {
 403         struct efi_disk_obj *diskobj;
 404         struct efi_object *handle;
 405         const efi_guid_t *esp_guid = NULL;
 406         efi_status_t ret;
 407
 408         /* Don't add empty devices */
 409         if (!desc->lba)
 410                 return EFI_NOT_READY;
 411
 412         diskobj = calloc(1, sizeof(*diskobj));
 413         if (!diskobj)
 414                 return EFI_OUT_OF_RESOURCES;
 415
 416         /* Hook up to the device list */
 417         efi_add_handle(&diskobj->header);
 418
 419         /* Fill in object data */
 420         if (part_info) {
 421                 struct efi_device_path *node = efi_dp_part_node(desc, part);
 422                 struct efi_handler *handler;
 423                 void *protocol_interface;
 424
 425                 if (!node) {
 426                         ret = EFI_OUT_OF_RESOURCES;
 427                         log_debug("no node\n");
 428                         goto error;
 429                 }
 430
 431                 /* Parent must expose EFI_BLOCK_IO_PROTOCOL */
 432                 ret = efi_search_protocol(parent, &efi_block_io_guid, &handler);
 433                 if (ret != EFI_SUCCESS) {
 434                         log_debug("search failed\n");
 435                         goto error;
 436                 }
 437
 438                 /*
 439                  * Link the partition (child controller) to the block device
 440                  * (controller).
 441                  */
 442                 ret = efi_protocol_open(handler, &protocol_interface, NULL,
 443                                         &diskobj->header,
 444                                         EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER);
 445                 if (ret != EFI_SUCCESS) {
 446                         log_debug("prot open failed\n");
 447                         goto error;
 448                 }
 449
 450                 diskobj->dp = efi_dp_append_node(dp_parent, node);
 451                 efi_free_pool(node);
 452                 diskobj->media.last_block = part_info->size - 1;
 453                 if (part_info->bootable & PART_EFI_SYSTEM_PARTITION)
 454                         esp_guid = &efi_system_partition_guid;
 455         } else {
 456                 diskobj->dp = efi_dp_from_part(desc, part);
 457                 diskobj->media.last_block = desc->lba - 1;
 458         }
 459         diskobj->part = part;
 460
 461         /*
 462          * Install the device path and the block IO protocol.
 463          *
 464          * InstallMultipleProtocolInterfaces() checks if the device path is
 465          * already installed on an other handle and returns EFI_ALREADY_STARTED
 466          * in this case.
 467          */
 468         handle = &diskobj->header;
 469         ret = efi_install_multiple_protocol_interfaces(
 470                                         &handle,
 471                                         &efi_guid_device_path, diskobj->dp,
 472                                         &efi_block_io_guid, &diskobj->ops,
 473                                         /*
 474                                          * esp_guid must be last entry as it
 475                                          * can be NULL. Its interface is NULL.
 476                                          */
 477                                         esp_guid, NULL,
 478                                         NULL);
 479         if (ret != EFI_SUCCESS) {
 480                 log_debug("install failed %lx\n", ret);
 481                 goto error;
 482         }
 483
 484         /*
 485          * On partitions or whole disks without partitions install the
 486          * simple file system protocol if a file system is available.
 487          */
 488         if ((part || desc->part_type == PART_TYPE_UNKNOWN) &&
 489             efi_fs_exists(desc, part)) {
 490                 ret = efi_create_simple_file_system(desc, part, diskobj->dp,
 491                                                     &diskobj->volume);
 492                 if (ret != EFI_SUCCESS)
 493                         goto error;
 494
 495                 ret = efi_add_protocol(&diskobj->header,
 496                                        &efi_simple_file_system_protocol_guid,
 497                                        diskobj->volume);
 498                 if (ret != EFI_SUCCESS)
 499                         goto error;
 500         }
 501         diskobj->ops = block_io_disk_template;
 502         diskobj->dev_index = dev_index;
 503
 504         /* Fill in EFI IO Media info (for read/write callbacks) */
 505         diskobj->media.removable_media = desc->removable;
 506         diskobj->media.media_present = 1;
 507         /*
 508          * MediaID is just an arbitrary counter.
 509          * We have to change it if the medium is removed or changed.
 510          */
 511         diskobj->media.media_id = 1;
 512         diskobj->media.block_size = desc->blksz;
 513         diskobj->media.io_align = desc->blksz;
 514         if (part)
 515                 diskobj->media.logical_partition = 1;
 516         diskobj->ops.media = &diskobj->media;
 517         if (disk)
 518                 *disk = diskobj;
 519
 520         EFI_PRINT("BlockIO: part %u, present %d, logical %d, removable %d"
 521                   ", last_block %llu\n",
 522                   diskobj->part,
 523                   diskobj->media.media_present,
 524                   diskobj->media.logical_partition,
 525                   diskobj->media.removable_media,
 526                   diskobj->media.last_block);
 527
 528         /* Store first EFI system partition */
 529         if (part && efi_system_partition.uclass_id == UCLASS_INVALID) {
 530                 if (part_info->bootable & PART_EFI_SYSTEM_PARTITION) {
 531                         efi_system_partition.uclass_id = desc->uclass_id;
 532                         efi_system_partition.devnum = desc->devnum;
 533                         efi_system_partition.part = part;
 534                         EFI_PRINT("EFI system partition: %s %x:%x\n",
 535                                   blk_get_uclass_name(desc->uclass_id),
 536                                   desc->devnum, part);
 537                 }
 538         }
 539         return EFI_SUCCESS;
 540 error:
 541         efi_delete_handle(&diskobj->header);
 542         free(diskobj->volume);
 543         free(diskobj);
 544         return ret;
 545 }
 546
 547 /**
 548  * efi_disk_create_raw() - create a handle for a whole raw disk
 549  *
 550  * @dev:                udevice (UCLASS_BLK)
 551  * @agent_handle:       handle of the EFI block driver
 552  *
 553  * Create an efi_disk object which is associated with @dev.
 554  * The type of @dev must be UCLASS_BLK.
 555  *
 556  * Return:              0 on success, -1 otherwise
 557  */
 558 static int efi_disk_create_raw(struct udevice *dev, efi_handle_t agent_handle)
 559 {
 560         struct efi_disk_obj *disk;
 561         struct blk_desc *desc;
 562         int diskid;
 563         efi_status_t ret;
 564
 565         desc = dev_get_uclass_plat(dev);
 566         diskid = desc->devnum;
 567
 568         ret = efi_disk_add_dev(NULL, NULL, desc,
 569                                diskid, NULL, 0, &disk, agent_handle);
 570         if (ret != EFI_SUCCESS) {
 571                 if (ret == EFI_NOT_READY) {
 572                         log_notice("Disk %s not ready\n", dev->name);
 573                         ret = -EBUSY;
 574                 } else {
 575                         log_err("Adding disk for %s failed (err=%ld/%#lx)\n", dev->name, ret, ret);
 576                         ret = -ENOENT;
 577                 }
 578
 579                 return ret;
 580         }
 581         if (efi_link_dev(&disk->header, dev)) {
 582                 efi_free_pool(disk->dp);
 583                 efi_delete_handle(&disk->header);
 584
 585                 return -EINVAL;
 586         }
 587
 588         return 0;
 589 }
 590
 591 /**
 592  * efi_disk_create_part() - create a handle for a disk partition
 593  *
 594  * @dev:                udevice (UCLASS_PARTITION)
 595  * @agent_handle:       handle of the EFI block driver
 596  *
 597  * Create an efi_disk object which is associated with @dev.
 598  * The type of @dev must be UCLASS_PARTITION.
 599  *
 600  * Return:              0 on success, -1 otherwise
 601  */
 602 static int efi_disk_create_part(struct udevice *dev, efi_handle_t agent_handle)
 603 {
 604         efi_handle_t parent;
 605         struct blk_desc *desc;
 606         struct disk_part *part_data;
 607         struct disk_partition *info;
 608         unsigned int part;
 609         int diskid;
 610         struct efi_handler *handler;
 611         struct efi_device_path *dp_parent;
 612         struct efi_disk_obj *disk;
 613         efi_status_t ret;
 614
 615         if (dev_tag_get_ptr(dev_get_parent(dev), DM_TAG_EFI, (void **)&parent))
 616                 return -1;
 617
 618         desc = dev_get_uclass_plat(dev_get_parent(dev));
 619         diskid = desc->devnum;
 620
 621         part_data = dev_get_uclass_plat(dev);
 622         part = part_data->partnum;
 623         info = &part_data->gpt_part_info;
 624
 625         ret = efi_search_protocol(parent, &efi_guid_device_path, &handler);
 626         if (ret != EFI_SUCCESS)
 627                 return -1;
 628         dp_parent = (struct efi_device_path *)handler->protocol_interface;
 629
 630         ret = efi_disk_add_dev(parent, dp_parent, desc, diskid,
 631                                info, part, &disk, agent_handle);
 632         if (ret != EFI_SUCCESS) {
 633                 log_err("Adding partition for %s failed\n", dev->name);
 634                 return -1;
 635         }
 636         if (efi_link_dev(&disk->header, dev)) {
 637                 efi_free_pool(disk->dp);
 638                 efi_delete_handle(&disk->header);
 639
 640                 return -1;
 641         }
 642
 643         return 0;
 644 }
 645
 646 /**
 647  * efi_disk_probe() - create efi_disk objects for a block device
 648  *
 649  * @ctx:        event context - driver binding protocol
 650  * @event:      EV_PM_POST_PROBE event
 651  *
 652  * Create efi_disk objects for partitions as well as a raw disk
 653  * which is associated with @dev.
 654  * The type of @dev must be UCLASS_BLK.
 655  * This function is expected to be called at EV_PM_POST_PROBE.
 656  *
 657  * Return:      0 on success, -1 otherwise
 658  */
 659 int efi_disk_probe(void *ctx, struct event *event)
 660 {
 661         struct udevice *dev;
 662         enum uclass_id id;
 663         struct blk_desc *desc;
 664         struct udevice *child;
 665         struct efi_driver_binding_extended_protocol *db_prot = ctx;
 666         efi_handle_t agent_handle = db_prot->bp.driver_binding_handle;
 667         int ret;
 668
 669         dev = event->data.dm.dev;
 670         id = device_get_uclass_id(dev);
 671
 672         /* We won't support partitions in a partition */
 673         if (id != UCLASS_BLK)
 674                 return 0;
 675
 676         /*
 677          * Avoid creating duplicated objects now that efi_driver
 678          * has already created an efi_disk at this moment.
 679          */
 680         desc = dev_get_uclass_plat(dev);
 681         if (desc->uclass_id != UCLASS_EFI_LOADER) {
 682                 ret = efi_disk_create_raw(dev, agent_handle);
 683                 if (ret)
 684                         return -1;
 685         }
 686
 687         device_foreach_child(child, dev) {
 688                 ret = efi_disk_create_part(child, agent_handle);
 689                 if (ret)
 690                         return -1;
 691         }
 692
 693         return 0;
 694 }
 695
 696 /**
 697  * efi_disk_remove - delete an efi_disk object for a block device or partition
 698  *
 699  * @ctx:        event context: driver binding protocol
 700  * @event:      EV_PM_PRE_REMOVE event
 701  *
 702  * Delete an efi_disk object which is associated with the UCLASS_BLK or
 703  * UCLASS_PARTITION device for which the EV_PM_PRE_REMOVE event is raised.
 704  *
 705  * Return:      0 on success, -1 otherwise
 706  */
 707 int efi_disk_remove(void *ctx, struct event *event)
 708 {
 709         enum uclass_id id;
 710         struct udevice *dev = event->data.dm.dev;
 711         efi_handle_t handle;
 712         struct blk_desc *desc;
 713         struct efi_disk_obj *diskobj = NULL;
 714         efi_status_t ret;
 715
 716         if (dev_tag_get_ptr(dev, DM_TAG_EFI, (void **)&handle))
 717                 return 0;
 718
 719         id = device_get_uclass_id(dev);
 720         switch (id) {
 721         case UCLASS_BLK:
 722                 desc = dev_get_uclass_plat(dev);
 723                 if (desc && desc->uclass_id != UCLASS_EFI_LOADER)
 724                         diskobj = container_of(handle, struct efi_disk_obj,
 725                                                header);
 726                 break;
 727         case UCLASS_PARTITION:
 728                 diskobj = container_of(handle, struct efi_disk_obj, header);
 729                 break;
 730         default:
 731                 return 0;
 732         }
 733
 734         ret = efi_delete_handle(handle);
 735         /* Do not delete DM device if there are still EFI drivers attached. */
 736         if (ret != EFI_SUCCESS)
 737                 return -1;
 738
 739         if (diskobj)
 740                 efi_free_pool(diskobj->dp);
 741
 742         dev_tag_del(dev, DM_TAG_EFI);
 743
 744         return 0;
 745 }
 746
 747 /**
 748  * efi_disk_get_device_name() - get U-Boot device name associated with EFI handle
 749  *
 750  * @handle:     pointer to the EFI handle
 751  * @buf:        pointer to the buffer to store the string
 752  * @size:       size of buffer
 753  * Return:      status code
 754  */
 755 efi_status_t efi_disk_get_device_name(const efi_handle_t handle, char *buf, int size)
 756 {
 757         int count;
 758         int diskid;
 759         enum uclass_id id;
 760         unsigned int part;
 761         struct udevice *dev;
 762         struct blk_desc *desc;
 763         const char *if_typename;
 764         bool is_partition = false;
 765         struct disk_part *part_data;
 766
 767         if (!handle || !buf || !size)
 768                 return EFI_INVALID_PARAMETER;
 769
 770         dev = handle->dev;
 771         id = device_get_uclass_id(dev);
 772         if (id == UCLASS_BLK) {
 773                 desc = dev_get_uclass_plat(dev);
 774         } else if (id == UCLASS_PARTITION) {
 775                 desc = dev_get_uclass_plat(dev_get_parent(dev));
 776                 is_partition = true;
 777         } else {
 778                 return EFI_INVALID_PARAMETER;
 779         }
 780         if_typename = blk_get_uclass_name(desc->uclass_id);
 781         diskid = desc->devnum;
 782
 783         if (is_partition) {
 784                 part_data = dev_get_uclass_plat(dev);
 785                 part = part_data->partnum;
 786                 count = snprintf(buf, size, "%s %d:%u", if_typename, diskid,
 787                                  part);
 788         } else {
 789                 count = snprintf(buf, size, "%s %d", if_typename, diskid);
 790         }
 791
 792         if (count < 0 || (count + 1) > size)
 793                 return EFI_INVALID_PARAMETER;
 794
 795         return EFI_SUCCESS;
 796 }
 797
 798 /**
 799  * efi_disks_register() - ensure all block devices are available in UEFI
 800  *
 801  * The function probes all block devices. As we store UEFI variables on the
 802  * EFI system partition this function has to be called before enabling
 803  * variable services.
 804  */
 805 efi_status_t efi_disks_register(void)
 806 {
 807         struct udevice *dev;
 808
 809         uclass_foreach_dev_probe(UCLASS_BLK, dev) {
 810         }
 811
 812         return EFI_SUCCESS;
 813 }