2 * EFI application disk support
4 * Copyright (c) 2016 Alexander Graf
6 * SPDX-License-Identifier: GPL-2.0+
12 #include <efi_loader.h>
17 const efi_guid_t efi_block_io_guid
= BLOCK_IO_GUID
;
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 */
26 /* U-Boot dev_index for block device */
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
;
34 /* handle to filesys proto (for partition objects) */
35 struct efi_simple_file_system_protocol
*volume
;
36 /* Offset into disk for simple partitions */
38 /* Internal block device */
39 struct blk_desc
*desc
;
42 static efi_status_t EFIAPI
efi_disk_reset(struct efi_block_io
*this,
43 char extended_verification
)
45 EFI_ENTRY("%p, %x", this, extended_verification
);
46 return EFI_EXIT(EFI_DEVICE_ERROR
);
49 enum efi_disk_direction
{
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
)
58 struct efi_disk_obj
*diskobj
;
59 struct blk_desc
*desc
;
64 diskobj
= container_of(this, struct efi_disk_obj
, ops
);
65 desc
= (struct blk_desc
*) diskobj
->desc
;
67 blocks
= buffer_size
/ blksz
;
68 lba
+= diskobj
->offset
;
70 debug("EFI: %s:%d blocks=%x lba=%"PRIx64
" blksz=%x dir=%d\n", __func__
,
71 __LINE__
, blocks
, lba
, blksz
, direction
);
73 /* We only support full block access */
74 if (buffer_size
& (blksz
- 1))
75 return EFI_DEVICE_ERROR
;
77 if (direction
== EFI_DISK_READ
)
78 n
= blk_dread(desc
, lba
, blocks
, buffer
);
80 n
= blk_dwrite(desc
, lba
, blocks
, buffer
);
82 /* We don't do interrupts, so check for timers cooperatively */
85 debug("EFI: %s:%d n=%lx blocks=%x\n", __func__
, __LINE__
, n
, blocks
);
88 return EFI_DEVICE_ERROR
;
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
,
97 void *real_buffer
= buffer
;
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
)
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
);
112 real_buffer
= efi_bounce_buffer
;
115 EFI_ENTRY("%p, %x, %" PRIx64
", %zx, %p", this, media_id
, lba
,
116 buffer_size
, buffer
);
118 r
= efi_disk_rw_blocks(this, media_id
, lba
, buffer_size
, real_buffer
,
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
);
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
,
132 void *real_buffer
= buffer
;
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
)
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
);
147 real_buffer
= efi_bounce_buffer
;
150 EFI_ENTRY("%p, %x, %" PRIx64
", %zx, %p", this, media_id
, lba
,
151 buffer_size
, buffer
);
153 /* Populate bounce buffer if necessary */
154 if (real_buffer
!= buffer
)
155 memcpy(real_buffer
, buffer
, buffer_size
);
157 r
= efi_disk_rw_blocks(this, media_id
, lba
, buffer_size
, real_buffer
,
163 static efi_status_t EFIAPI
efi_disk_flush_blocks(struct efi_block_io
*this)
165 /* We always write synchronously */
166 EFI_ENTRY("%p", this);
167 return EFI_EXIT(EFI_SUCCESS
);
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
,
178 * Get the simple file system protocol for a file device path.
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.
184 * @full_path device path including device and file
185 * @return simple file system protocol
187 struct efi_simple_file_system_protocol
*
188 efi_fs_from_path(struct efi_device_path
*full_path
)
190 struct efi_object
*efiobj
;
191 struct efi_handler
*handler
;
192 struct efi_device_path
*device_path
;
193 struct efi_device_path
*file_path
;
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
)
200 efi_free_pool(file_path
);
202 /* Get the EFI object for the partition */
203 efiobj
= efi_dp_find_obj(device_path
, NULL
);
204 efi_free_pool(device_path
);
208 /* Find the simple file system protocol */
209 ret
= efi_search_protocol(efiobj
, &efi_simple_file_system_protocol_guid
,
211 if (ret
!= EFI_SUCCESS
)
214 /* Return the simple file system protocol for the partition */
215 return handler
->protocol_interface
;
219 * Create a handle for a partition or disk
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
229 static struct efi_disk_obj
*efi_disk_add_dev(
231 struct efi_device_path
*dp_parent
,
232 const char *if_typename
,
233 struct blk_desc
*desc
,
238 struct efi_disk_obj
*diskobj
;
241 /* Don't add empty devices */
245 diskobj
= calloc(1, sizeof(*diskobj
));
249 /* Hook up to the device list */
250 efi_add_handle(&diskobj
->parent
);
252 /* Fill in object data */
254 struct efi_device_path
*node
= efi_dp_part_node(desc
, part
);
256 diskobj
->dp
= efi_dp_append_node(dp_parent
, node
);
259 diskobj
->dp
= efi_dp_from_part(desc
, part
);
261 diskobj
->part
= part
;
262 ret
= efi_add_protocol(diskobj
->parent
.handle
, &efi_block_io_guid
,
264 if (ret
!= EFI_SUCCESS
)
266 ret
= efi_add_protocol(diskobj
->parent
.handle
, &efi_guid_device_path
,
268 if (ret
!= EFI_SUCCESS
)
271 diskobj
->volume
= efi_simple_file_system(desc
, part
,
273 ret
= efi_add_protocol(diskobj
->parent
.handle
,
274 &efi_simple_file_system_protocol_guid
,
276 if (ret
!= EFI_SUCCESS
)
279 diskobj
->ops
= block_io_disk_template
;
280 diskobj
->ifname
= if_typename
;
281 diskobj
->dev_index
= dev_index
;
282 diskobj
->offset
= offset
;
283 diskobj
->desc
= desc
;
285 /* Fill in EFI IO Media info (for read/write callbacks) */
286 diskobj
->media
.removable_media
= desc
->removable
;
287 diskobj
->media
.media_present
= 1;
288 diskobj
->media
.block_size
= desc
->blksz
;
289 diskobj
->media
.io_align
= desc
->blksz
;
290 diskobj
->media
.last_block
= desc
->lba
- offset
;
292 diskobj
->media
.logical_partition
= 1;
293 diskobj
->ops
.media
= &diskobj
->media
;
296 printf("ERROR: Out of memory\n");
301 * Create handles and protocols for the partitions of a block device
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
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
)
315 char devname
[32] = { 0 }; /* dp->str is u16[32] long */
316 disk_partition_t info
;
318 struct efi_device_path
*dp
= NULL
;
320 struct efi_handler
*handler
;
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
;
327 /* Add devices for each partition */
328 for (part
= 1; part
<= MAX_SEARCH_PARTITIONS
; part
++) {
329 if (part_get_info(desc
, part
, &info
))
331 snprintf(devname
, sizeof(devname
), "%s:%d", pdevname
,
333 efi_disk_add_dev(parent
, dp
, if_typename
, desc
, diskid
,
342 * U-Boot doesn't have a list of all online disk devices. So when running our
343 * EFI payload, we scan through all of the potentially available ones and
344 * store them in our object pool.
346 * TODO(sjg@chromium.org): Actually with CONFIG_BLK, U-Boot does have this.
347 * Consider converting the code to look up devices as needed. The EFI device
348 * could be a child of the UCLASS_BLK block device, perhaps.
350 * This gets called from do_bootefi_exec().
352 int efi_disk_register(void)
354 struct efi_disk_obj
*disk
;
359 for (uclass_first_device_check(UCLASS_BLK
, &dev
);
361 uclass_next_device_check(&dev
)) {
362 struct blk_desc
*desc
= dev_get_uclass_platdata(dev
);
363 const char *if_typename
= blk_get_if_type_name(desc
->if_type
);
365 printf("Scanning disk %s...\n", dev
->name
);
367 /* Add block device for the full device */
368 disk
= efi_disk_add_dev(NULL
, NULL
, if_typename
,
369 desc
, desc
->devnum
, 0, 0);
374 /* Partitions show up as block devices in EFI */
375 disks
+= efi_disk_create_partitions(
376 disk
->parent
.handle
, desc
, if_typename
,
377 desc
->devnum
, dev
->name
);
382 /* Search for all available disk devices */
383 for (if_type
= 0; if_type
< IF_TYPE_COUNT
; if_type
++) {
384 const struct blk_driver
*cur_drvr
;
385 const char *if_typename
;
387 cur_drvr
= blk_driver_lookup_type(if_type
);
391 if_typename
= cur_drvr
->if_typename
;
392 printf("Scanning disks on %s...\n", if_typename
);
393 for (i
= 0; i
< 4; i
++) {
394 struct blk_desc
*desc
;
395 char devname
[32] = { 0 }; /* dp->str is u16[32] long */
397 desc
= blk_get_devnum_by_type(if_type
, i
);
400 if (desc
->type
== DEV_TYPE_UNKNOWN
)
403 snprintf(devname
, sizeof(devname
), "%s%d",
406 /* Add block device for the full device */
407 disk
= efi_disk_add_dev(NULL
, NULL
, if_typename
, desc
,
413 /* Partitions show up as block devices in EFI */
414 disks
+= efi_disk_create_partitions(
415 disk
->parent
.handle
, desc
,
416 if_typename
, i
, devname
);
420 printf("Found %d disks\n", disks
);