2 * EFI application disk support
4 * Copyright (c) 2016 Alexander Graf
6 * SPDX-License-Identifier: GPL-2.0+
12 #include <efi_loader.h>
17 static 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_file_path
*dp
;
32 /* Offset into disk for simple partitions */
34 /* Internal block device */
35 const struct blk_desc
*desc
;
38 static efi_status_t EFIAPI
efi_disk_open_block(void *handle
,
39 efi_guid_t
*protocol
, void **protocol_interface
,
40 void *agent_handle
, void *controller_handle
,
43 struct efi_disk_obj
*diskobj
= handle
;
45 *protocol_interface
= &diskobj
->ops
;
50 static efi_status_t EFIAPI
efi_disk_open_dp(void *handle
, efi_guid_t
*protocol
,
51 void **protocol_interface
, void *agent_handle
,
52 void *controller_handle
, uint32_t attributes
)
54 struct efi_disk_obj
*diskobj
= handle
;
56 *protocol_interface
= diskobj
->dp
;
61 static efi_status_t EFIAPI
efi_disk_reset(struct efi_block_io
*this,
62 char extended_verification
)
64 EFI_ENTRY("%p, %x", this, extended_verification
);
65 return EFI_EXIT(EFI_DEVICE_ERROR
);
68 enum efi_disk_direction
{
73 static efi_status_t EFIAPI
efi_disk_rw_blocks(struct efi_block_io
*this,
74 u32 media_id
, u64 lba
, unsigned long buffer_size
,
75 void *buffer
, enum efi_disk_direction direction
)
77 struct efi_disk_obj
*diskobj
;
78 struct blk_desc
*desc
;
83 diskobj
= container_of(this, struct efi_disk_obj
, ops
);
84 desc
= (struct blk_desc
*) diskobj
->desc
;
86 blocks
= buffer_size
/ blksz
;
87 lba
+= diskobj
->offset
;
89 debug("EFI: %s:%d blocks=%x lba=%"PRIx64
" blksz=%x dir=%d\n", __func__
,
90 __LINE__
, blocks
, lba
, blksz
, direction
);
92 /* We only support full block access */
93 if (buffer_size
& (blksz
- 1))
94 return EFI_EXIT(EFI_DEVICE_ERROR
);
96 if (direction
== EFI_DISK_READ
)
97 n
= blk_dread(desc
, lba
, blocks
, buffer
);
99 n
= blk_dwrite(desc
, lba
, blocks
, buffer
);
101 /* We don't do interrupts, so check for timers cooperatively */
104 debug("EFI: %s:%d n=%lx blocks=%x\n", __func__
, __LINE__
, n
, blocks
);
107 return EFI_EXIT(EFI_DEVICE_ERROR
);
109 return EFI_EXIT(EFI_SUCCESS
);
112 static efi_status_t EFIAPI
efi_disk_read_blocks(struct efi_block_io
*this,
113 u32 media_id
, u64 lba
, unsigned long buffer_size
,
116 void *real_buffer
= buffer
;
119 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
120 if (buffer_size
> EFI_LOADER_BOUNCE_BUFFER_SIZE
) {
121 r
= efi_disk_read_blocks(this, media_id
, lba
,
122 EFI_LOADER_BOUNCE_BUFFER_SIZE
, buffer
);
123 if (r
!= EFI_SUCCESS
)
125 return efi_disk_read_blocks(this, media_id
, lba
+
126 EFI_LOADER_BOUNCE_BUFFER_SIZE
/ this->media
->block_size
,
127 buffer_size
- EFI_LOADER_BOUNCE_BUFFER_SIZE
,
128 buffer
+ EFI_LOADER_BOUNCE_BUFFER_SIZE
);
131 real_buffer
= efi_bounce_buffer
;
134 EFI_ENTRY("%p, %x, %"PRIx64
", %lx, %p", this, media_id
, lba
,
135 buffer_size
, buffer
);
137 r
= efi_disk_rw_blocks(this, media_id
, lba
, buffer_size
, real_buffer
,
140 /* Copy from bounce buffer to real buffer if necessary */
141 if ((r
== EFI_SUCCESS
) && (real_buffer
!= buffer
))
142 memcpy(buffer
, real_buffer
, buffer_size
);
147 static efi_status_t EFIAPI
efi_disk_write_blocks(struct efi_block_io
*this,
148 u32 media_id
, u64 lba
, unsigned long buffer_size
,
151 void *real_buffer
= buffer
;
154 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
155 if (buffer_size
> EFI_LOADER_BOUNCE_BUFFER_SIZE
) {
156 r
= efi_disk_write_blocks(this, media_id
, lba
,
157 EFI_LOADER_BOUNCE_BUFFER_SIZE
, buffer
);
158 if (r
!= EFI_SUCCESS
)
160 return efi_disk_write_blocks(this, media_id
, lba
+
161 EFI_LOADER_BOUNCE_BUFFER_SIZE
/ this->media
->block_size
,
162 buffer_size
- EFI_LOADER_BOUNCE_BUFFER_SIZE
,
163 buffer
+ EFI_LOADER_BOUNCE_BUFFER_SIZE
);
166 real_buffer
= efi_bounce_buffer
;
169 EFI_ENTRY("%p, %x, %"PRIx64
", %lx, %p", this, media_id
, lba
,
170 buffer_size
, buffer
);
172 /* Populate bounce buffer if necessary */
173 if (real_buffer
!= buffer
)
174 memcpy(real_buffer
, buffer
, buffer_size
);
176 r
= efi_disk_rw_blocks(this, media_id
, lba
, buffer_size
, real_buffer
,
182 static efi_status_t EFIAPI
efi_disk_flush_blocks(struct efi_block_io
*this)
184 /* We always write synchronously */
185 EFI_ENTRY("%p", this);
186 return EFI_EXIT(EFI_SUCCESS
);
189 static const struct efi_block_io block_io_disk_template
= {
190 .reset
= &efi_disk_reset
,
191 .read_blocks
= &efi_disk_read_blocks
,
192 .write_blocks
= &efi_disk_write_blocks
,
193 .flush_blocks
= &efi_disk_flush_blocks
,
196 static void efi_disk_add_dev(const char *name
,
197 const char *if_typename
,
198 const struct blk_desc
*desc
,
202 struct efi_disk_obj
*diskobj
;
203 struct efi_device_path_file_path
*dp
;
204 int objlen
= sizeof(*diskobj
) + (sizeof(*dp
) * 2);
206 /* Don't add empty devices */
210 diskobj
= calloc(1, objlen
);
212 /* Fill in object data */
213 diskobj
->parent
.protocols
[0].guid
= &efi_block_io_guid
;
214 diskobj
->parent
.protocols
[0].open
= efi_disk_open_block
;
215 diskobj
->parent
.protocols
[1].guid
= &efi_guid_device_path
;
216 diskobj
->parent
.protocols
[1].open
= efi_disk_open_dp
;
217 diskobj
->parent
.handle
= diskobj
;
218 diskobj
->ops
= block_io_disk_template
;
219 diskobj
->ifname
= if_typename
;
220 diskobj
->dev_index
= dev_index
;
221 diskobj
->offset
= offset
;
222 diskobj
->desc
= desc
;
224 /* Fill in EFI IO Media info (for read/write callbacks) */
225 diskobj
->media
.removable_media
= desc
->removable
;
226 diskobj
->media
.media_present
= 1;
227 diskobj
->media
.block_size
= desc
->blksz
;
228 diskobj
->media
.io_align
= desc
->blksz
;
229 diskobj
->media
.last_block
= desc
->lba
- offset
;
230 diskobj
->ops
.media
= &diskobj
->media
;
232 /* Fill in device path */
233 dp
= (void*)&diskobj
[1];
235 dp
[0].dp
.type
= DEVICE_PATH_TYPE_MEDIA_DEVICE
;
236 dp
[0].dp
.sub_type
= DEVICE_PATH_SUB_TYPE_FILE_PATH
;
237 dp
[0].dp
.length
= sizeof(*dp
);
238 ascii2unicode(dp
[0].str
, name
);
240 dp
[1].dp
.type
= DEVICE_PATH_TYPE_END
;
241 dp
[1].dp
.sub_type
= DEVICE_PATH_SUB_TYPE_END
;
242 dp
[1].dp
.length
= sizeof(*dp
);
244 /* Hook up to the device list */
245 list_add_tail(&diskobj
->parent
.link
, &efi_obj_list
);
248 static int efi_disk_create_eltorito(struct blk_desc
*desc
,
249 const char *if_typename
,
251 const char *pdevname
)
254 #ifdef CONFIG_ISO_PARTITION
255 char devname
[32] = { 0 }; /* dp->str is u16[32] long */
256 disk_partition_t info
;
259 if (desc
->part_type
!= PART_TYPE_ISO
)
262 while (!part_get_info(desc
, part
, &info
)) {
263 snprintf(devname
, sizeof(devname
), "%s:%d", pdevname
,
265 efi_disk_add_dev(devname
, if_typename
, desc
, diskid
,
276 * U-Boot doesn't have a list of all online disk devices. So when running our
277 * EFI payload, we scan through all of the potentially available ones and
278 * store them in our object pool.
280 * TODO(sjg@chromium.org): Actually with CONFIG_BLK, U-Boot does have this.
281 * Consider converting the code to look up devices as needed. The EFI device
282 * could be a child of the UCLASS_BLK block device, perhaps.
284 * This gets called from do_bootefi_exec().
286 int efi_disk_register(void)
292 for (uclass_first_device(UCLASS_BLK
, &dev
);
294 uclass_next_device(&dev
)) {
295 struct blk_desc
*desc
= dev_get_uclass_platdata(dev
);
296 const char *if_typename
= dev
->driver
->name
;
298 printf("Scanning disk %s...\n", dev
->name
);
299 efi_disk_add_dev(dev
->name
, if_typename
, desc
, desc
->devnum
, 0);
303 * El Torito images show up as block devices in an EFI world,
304 * so let's create them here
306 disks
+= efi_disk_create_eltorito(desc
, if_typename
,
307 desc
->devnum
, dev
->name
);
312 /* Search for all available disk devices */
313 for (if_type
= 0; if_type
< IF_TYPE_COUNT
; if_type
++) {
314 const struct blk_driver
*cur_drvr
;
315 const char *if_typename
;
317 cur_drvr
= blk_driver_lookup_type(if_type
);
321 if_typename
= cur_drvr
->if_typename
;
322 printf("Scanning disks on %s...\n", if_typename
);
323 for (i
= 0; i
< 4; i
++) {
324 struct blk_desc
*desc
;
325 char devname
[32] = { 0 }; /* dp->str is u16[32] long */
327 desc
= blk_get_devnum_by_type(if_type
, i
);
330 if (desc
->type
== DEV_TYPE_UNKNOWN
)
333 snprintf(devname
, sizeof(devname
), "%s%d",
335 efi_disk_add_dev(devname
, if_typename
, desc
, i
, 0);
339 * El Torito images show up as block devices
340 * in an EFI world, so let's create them here
342 disks
+= efi_disk_create_eltorito(desc
, if_typename
,
347 printf("Found %d disks\n", disks
);