blob: a50a46ce8d000f68522fbea2be1d2746aa964023 [file] [log] [blame]
Tom Rini70df9d62018-05-07 17:02:21 -04001// SPDX-License-Identifier: GPL-2.0+
Alexander Grafe83be452016-03-04 01:10:02 +01002/*
3 * EFI application disk support
4 *
5 * Copyright (c) 2016 Alexander Graf
Alexander Grafe83be452016-03-04 01:10:02 +01006 */
7
Heinrich Schuchardt37240572020-07-17 20:33:05 +02008#define LOG_CATEGORY LOGC_EFI
9
Alexander Grafe83be452016-03-04 01:10:02 +010010#include <common.h>
Simon Glasse3dfa912016-05-01 13:52:32 -060011#include <blk.h>
Simon Glass302d4f82016-05-14 14:03:05 -060012#include <dm.h>
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +090013#include <dm/device-internal.h>
14#include <dm/tag.h>
15#include <event.h>
Alexander Grafe83be452016-03-04 01:10:02 +010016#include <efi_loader.h>
AKASHI Takahiro120a01a2019-10-07 14:59:38 +090017#include <fs.h>
Heinrich Schuchardt37240572020-07-17 20:33:05 +020018#include <log.h>
Alexander Grafe83be452016-03-04 01:10:02 +010019#include <part.h>
20#include <malloc.h>
21
Heinrich Schuchardt0397d812022-10-21 08:33:44 +020022struct efi_system_partition efi_system_partition = {
23 .uclass_id = UCLASS_INVALID,
24};
Heinrich Schuchardta9931732020-03-19 15:16:31 +010025
Heinrich Schuchardt788ad412019-04-20 07:39:11 +020026const efi_guid_t efi_block_io_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
Heinrich Schuchardt26397622021-02-02 17:53:14 +010027const efi_guid_t efi_system_partition_guid = PARTITION_SYSTEM_GUID;
Alexander Grafe83be452016-03-04 01:10:02 +010028
Heinrich Schuchardt72928722018-09-26 05:27:56 +020029/**
30 * struct efi_disk_obj - EFI disk object
31 *
32 * @header: EFI object header
33 * @ops: EFI disk I/O protocol interface
Heinrich Schuchardt72928722018-09-26 05:27:56 +020034 * @dev_index: device index of block device
35 * @media: block I/O media information
36 * @dp: device path to the block device
37 * @part: partition
38 * @volume: simple file system protocol of the partition
AKASHI Takahiro808ece12022-04-19 10:05:17 +090039 * @dev: associated DM device
Heinrich Schuchardt72928722018-09-26 05:27:56 +020040 */
Alexander Grafe83be452016-03-04 01:10:02 +010041struct efi_disk_obj {
Heinrich Schuchardt72928722018-09-26 05:27:56 +020042 struct efi_object header;
Alexander Grafe83be452016-03-04 01:10:02 +010043 struct efi_block_io ops;
Alexander Grafe83be452016-03-04 01:10:02 +010044 int dev_index;
Alexander Grafe83be452016-03-04 01:10:02 +010045 struct efi_block_io_media media;
Rob Clarka83272f2017-09-13 18:05:31 -040046 struct efi_device_path *dp;
Rob Clarka83272f2017-09-13 18:05:31 -040047 unsigned int part;
Rob Clark53142032017-09-13 18:05:34 -040048 struct efi_simple_file_system_protocol *volume;
Alexander Grafe83be452016-03-04 01:10:02 +010049};
50
Heinrich Schuchardt670198c2019-09-05 20:13:46 +020051/**
52 * efi_disk_reset() - reset block device
53 *
54 * This function implements the Reset service of the EFI_BLOCK_IO_PROTOCOL.
55 *
56 * As U-Boot's block devices do not have a reset function simply return
57 * EFI_SUCCESS.
58 *
59 * See the Unified Extensible Firmware Interface (UEFI) specification for
60 * details.
61 *
62 * @this: pointer to the BLOCK_IO_PROTOCOL
63 * @extended_verification: extended verification
64 * Return: status code
65 */
Alexander Grafe83be452016-03-04 01:10:02 +010066static efi_status_t EFIAPI efi_disk_reset(struct efi_block_io *this,
67 char extended_verification)
68{
69 EFI_ENTRY("%p, %x", this, extended_verification);
Heinrich Schuchardt670198c2019-09-05 20:13:46 +020070 return EFI_EXIT(EFI_SUCCESS);
Alexander Grafe83be452016-03-04 01:10:02 +010071}
72
AKASHI Takahiroba647af2022-05-12 11:29:01 +090073/**
74 * efi_disk_is_removable() - check if the device is removable media
75 * @handle: efi object handle;
76 *
77 * Examine the device and determine if the device is a local block device
78 * and removable media.
79 *
80 * Return: true if removable, false otherwise
81 */
82bool efi_disk_is_removable(efi_handle_t handle)
83{
84 struct efi_handler *handler;
85 struct efi_block_io *io;
86 efi_status_t ret;
87
88 ret = efi_search_protocol(handle, &efi_block_io_guid, &handler);
89 if (ret != EFI_SUCCESS)
90 return false;
91
92 io = handler->protocol_interface;
93
94 if (!io || !io->media)
95 return false;
96
97 return (bool)io->media->removable_media;
98}
99
Alexander Grafe83be452016-03-04 01:10:02 +0100100enum efi_disk_direction {
101 EFI_DISK_READ,
102 EFI_DISK_WRITE,
103};
104
Heinrich Schuchardt9ce06172017-08-26 22:33:13 +0200105static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this,
Alexander Grafe83be452016-03-04 01:10:02 +0100106 u32 media_id, u64 lba, unsigned long buffer_size,
107 void *buffer, enum efi_disk_direction direction)
108{
109 struct efi_disk_obj *diskobj;
Alexander Grafe83be452016-03-04 01:10:02 +0100110 int blksz;
111 int blocks;
112 unsigned long n;
113
Alexander Grafe83be452016-03-04 01:10:02 +0100114 diskobj = container_of(this, struct efi_disk_obj, ops);
AKASHI Takahiro808ece12022-04-19 10:05:17 +0900115 blksz = diskobj->media.block_size;
Alexander Grafe83be452016-03-04 01:10:02 +0100116 blocks = buffer_size / blksz;
117
Heinrich Schuchardtee6ef8b2019-09-05 19:43:17 +0200118 EFI_PRINT("blocks=%x lba=%llx blksz=%x dir=%d\n",
119 blocks, lba, blksz, direction);
Alexander Grafe83be452016-03-04 01:10:02 +0100120
121 /* We only support full block access */
122 if (buffer_size & (blksz - 1))
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200123 return EFI_BAD_BUFFER_SIZE;
Alexander Grafe83be452016-03-04 01:10:02 +0100124
AKASHI Takahiro8c591132022-04-28 13:49:16 +0900125 if (CONFIG_IS_ENABLED(PARTITIONS) &&
Masahisa Kojimac9611082022-07-22 11:39:10 +0900126 device_get_uclass_id(diskobj->header.dev) == UCLASS_PARTITION) {
AKASHI Takahiro8c591132022-04-28 13:49:16 +0900127 if (direction == EFI_DISK_READ)
Simon Glass4e93eea2022-10-20 18:22:52 -0600128 n = disk_blk_read(diskobj->header.dev, lba, blocks,
129 buffer);
AKASHI Takahiro8c591132022-04-28 13:49:16 +0900130 else
Simon Glass4e93eea2022-10-20 18:22:52 -0600131 n = disk_blk_write(diskobj->header.dev, lba, blocks,
132 buffer);
AKASHI Takahiro8c591132022-04-28 13:49:16 +0900133 } else {
134 /* dev is a block device (UCLASS_BLK) */
135 struct blk_desc *desc;
AKASHI Takahiro808ece12022-04-19 10:05:17 +0900136
Masahisa Kojimac9611082022-07-22 11:39:10 +0900137 desc = dev_get_uclass_plat(diskobj->header.dev);
AKASHI Takahiro8c591132022-04-28 13:49:16 +0900138 if (direction == EFI_DISK_READ)
139 n = blk_dread(desc, lba, blocks, buffer);
140 else
141 n = blk_dwrite(desc, lba, blocks, buffer);
142 }
Alexander Grafe83be452016-03-04 01:10:02 +0100143
144 /* We don't do interrupts, so check for timers cooperatively */
145 efi_timer_check();
146
Heinrich Schuchardtee6ef8b2019-09-05 19:43:17 +0200147 EFI_PRINT("n=%lx blocks=%x\n", n, blocks);
Alexander Graf62a67482016-06-02 11:38:27 +0200148
Alexander Grafe83be452016-03-04 01:10:02 +0100149 if (n != blocks)
Rob Clark99c43872017-07-25 20:28:29 -0400150 return EFI_DEVICE_ERROR;
Alexander Grafe83be452016-03-04 01:10:02 +0100151
Rob Clark99c43872017-07-25 20:28:29 -0400152 return EFI_SUCCESS;
Alexander Grafe83be452016-03-04 01:10:02 +0100153}
154
Heinrich Schuchardt76f57892020-04-10 17:10:34 +0200155/**
156 * efi_disk_read_blocks() - reads blocks from device
157 *
158 * This function implements the ReadBlocks service of the EFI_BLOCK_IO_PROTOCOL.
159 *
160 * See the Unified Extensible Firmware Interface (UEFI) specification for
161 * details.
162 *
163 * @this: pointer to the BLOCK_IO_PROTOCOL
164 * @media_id: id of the medium to be read from
165 * @lba: starting logical block for reading
166 * @buffer_size: size of the read buffer
167 * @buffer: pointer to the destination buffer
168 * Return: status code
169 */
Simon Glassc2194bf2016-09-25 15:27:32 -0600170static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
Heinrich Schuchardt0844f792018-01-19 20:24:48 +0100171 u32 media_id, u64 lba, efi_uintn_t buffer_size,
Alexander Grafe83be452016-03-04 01:10:02 +0100172 void *buffer)
173{
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200174 void *real_buffer = buffer;
175 efi_status_t r;
176
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200177 if (!this)
178 return EFI_INVALID_PARAMETER;
179 /* TODO: check for media changes */
180 if (media_id != this->media->media_id)
181 return EFI_MEDIA_CHANGED;
182 if (!this->media->media_present)
183 return EFI_NO_MEDIA;
Heinrich Schuchardt0bb73892021-01-23 19:33:11 +0100184 /* media->io_align is a power of 2 or 0 */
185 if (this->media->io_align &&
186 (uintptr_t)buffer & (this->media->io_align - 1))
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200187 return EFI_INVALID_PARAMETER;
188 if (lba * this->media->block_size + buffer_size >
Jesper Schmitz Mouridsenf1424932021-02-09 17:17:17 +0100189 (this->media->last_block + 1) * this->media->block_size)
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200190 return EFI_INVALID_PARAMETER;
191
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200192#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
193 if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) {
194 r = efi_disk_read_blocks(this, media_id, lba,
195 EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer);
196 if (r != EFI_SUCCESS)
197 return r;
198 return efi_disk_read_blocks(this, media_id, lba +
199 EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size,
200 buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE,
201 buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE);
202 }
203
204 real_buffer = efi_bounce_buffer;
205#endif
206
Masahiro Yamadac7570a32018-08-06 20:47:40 +0900207 EFI_ENTRY("%p, %x, %llx, %zx, %p", this, media_id, lba,
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200208 buffer_size, buffer);
209
210 r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
211 EFI_DISK_READ);
212
213 /* Copy from bounce buffer to real buffer if necessary */
214 if ((r == EFI_SUCCESS) && (real_buffer != buffer))
215 memcpy(buffer, real_buffer, buffer_size);
216
217 return EFI_EXIT(r);
Alexander Grafe83be452016-03-04 01:10:02 +0100218}
219
Heinrich Schuchardt76f57892020-04-10 17:10:34 +0200220/**
221 * efi_disk_write_blocks() - writes blocks to device
222 *
223 * This function implements the WriteBlocks service of the
224 * EFI_BLOCK_IO_PROTOCOL.
225 *
226 * See the Unified Extensible Firmware Interface (UEFI) specification for
227 * details.
228 *
229 * @this: pointer to the BLOCK_IO_PROTOCOL
230 * @media_id: id of the medium to be written to
231 * @lba: starting logical block for writing
232 * @buffer_size: size of the write buffer
233 * @buffer: pointer to the source buffer
234 * Return: status code
235 */
Simon Glassc2194bf2016-09-25 15:27:32 -0600236static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
Heinrich Schuchardt0844f792018-01-19 20:24:48 +0100237 u32 media_id, u64 lba, efi_uintn_t buffer_size,
Alexander Grafe83be452016-03-04 01:10:02 +0100238 void *buffer)
239{
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200240 void *real_buffer = buffer;
241 efi_status_t r;
242
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200243 if (!this)
244 return EFI_INVALID_PARAMETER;
245 if (this->media->read_only)
246 return EFI_WRITE_PROTECTED;
247 /* TODO: check for media changes */
248 if (media_id != this->media->media_id)
249 return EFI_MEDIA_CHANGED;
250 if (!this->media->media_present)
251 return EFI_NO_MEDIA;
Heinrich Schuchardt0bb73892021-01-23 19:33:11 +0100252 /* media->io_align is a power of 2 or 0 */
253 if (this->media->io_align &&
254 (uintptr_t)buffer & (this->media->io_align - 1))
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200255 return EFI_INVALID_PARAMETER;
256 if (lba * this->media->block_size + buffer_size >
Jesper Schmitz Mouridsenf1424932021-02-09 17:17:17 +0100257 (this->media->last_block + 1) * this->media->block_size)
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200258 return EFI_INVALID_PARAMETER;
259
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200260#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
261 if (buffer_size > EFI_LOADER_BOUNCE_BUFFER_SIZE) {
262 r = efi_disk_write_blocks(this, media_id, lba,
263 EFI_LOADER_BOUNCE_BUFFER_SIZE, buffer);
264 if (r != EFI_SUCCESS)
265 return r;
266 return efi_disk_write_blocks(this, media_id, lba +
267 EFI_LOADER_BOUNCE_BUFFER_SIZE / this->media->block_size,
268 buffer_size - EFI_LOADER_BOUNCE_BUFFER_SIZE,
269 buffer + EFI_LOADER_BOUNCE_BUFFER_SIZE);
270 }
271
272 real_buffer = efi_bounce_buffer;
273#endif
274
Masahiro Yamadac7570a32018-08-06 20:47:40 +0900275 EFI_ENTRY("%p, %x, %llx, %zx, %p", this, media_id, lba,
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200276 buffer_size, buffer);
277
278 /* Populate bounce buffer if necessary */
279 if (real_buffer != buffer)
280 memcpy(real_buffer, buffer, buffer_size);
281
282 r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
283 EFI_DISK_WRITE);
284
285 return EFI_EXIT(r);
Alexander Grafe83be452016-03-04 01:10:02 +0100286}
287
Heinrich Schuchardt76f57892020-04-10 17:10:34 +0200288/**
289 * efi_disk_flush_blocks() - flushes modified data to the device
290 *
291 * This function implements the FlushBlocks service of the
292 * EFI_BLOCK_IO_PROTOCOL.
293 *
294 * As we always write synchronously nothing is done here.
295 *
296 * See the Unified Extensible Firmware Interface (UEFI) specification for
297 * details.
298 *
299 * @this: pointer to the BLOCK_IO_PROTOCOL
300 * Return: status code
301 */
Alexander Grafe83be452016-03-04 01:10:02 +0100302static efi_status_t EFIAPI efi_disk_flush_blocks(struct efi_block_io *this)
303{
Alexander Grafe83be452016-03-04 01:10:02 +0100304 EFI_ENTRY("%p", this);
305 return EFI_EXIT(EFI_SUCCESS);
306}
307
308static const struct efi_block_io block_io_disk_template = {
309 .reset = &efi_disk_reset,
310 .read_blocks = &efi_disk_read_blocks,
311 .write_blocks = &efi_disk_write_blocks,
312 .flush_blocks = &efi_disk_flush_blocks,
313};
314
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100315/**
316 * efi_fs_from_path() - retrieve simple file system protocol
317 *
318 * Gets the simple file system protocol for a file device path.
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100319 *
320 * The full path provided is split into device part and into a file
321 * part. The device part is used to find the handle on which the
322 * simple file system protocol is installed.
323 *
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100324 * @full_path: device path including device and file
325 * Return: simple file system protocol
Rob Clark53142032017-09-13 18:05:34 -0400326 */
327struct efi_simple_file_system_protocol *
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100328efi_fs_from_path(struct efi_device_path *full_path)
Rob Clark53142032017-09-13 18:05:34 -0400329{
330 struct efi_object *efiobj;
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100331 struct efi_handler *handler;
332 struct efi_device_path *device_path;
333 struct efi_device_path *file_path;
334 efi_status_t ret;
Rob Clark53142032017-09-13 18:05:34 -0400335
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100336 /* Split the path into a device part and a file part */
337 ret = efi_dp_split_file_path(full_path, &device_path, &file_path);
338 if (ret != EFI_SUCCESS)
339 return NULL;
340 efi_free_pool(file_path);
341
342 /* Get the EFI object for the partition */
Heinrich Schuchardt0a04a412022-03-19 06:35:43 +0100343 efiobj = efi_dp_find_obj(device_path, NULL, NULL);
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100344 efi_free_pool(device_path);
Rob Clark53142032017-09-13 18:05:34 -0400345 if (!efiobj)
346 return NULL;
347
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100348 /* Find the simple file system protocol */
349 ret = efi_search_protocol(efiobj, &efi_simple_file_system_protocol_guid,
350 &handler);
351 if (ret != EFI_SUCCESS)
352 return NULL;
Rob Clark53142032017-09-13 18:05:34 -0400353
Heinrich Schuchardt39578762018-01-19 20:24:39 +0100354 /* Return the simple file system protocol for the partition */
355 return handler->protocol_interface;
Rob Clark53142032017-09-13 18:05:34 -0400356}
357
AKASHI Takahiro120a01a2019-10-07 14:59:38 +0900358/**
359 * efi_fs_exists() - check if a partition bears a file system
360 *
361 * @desc: block device descriptor
362 * @part: partition number
363 * Return: 1 if a file system exists on the partition
364 * 0 otherwise
365 */
366static int efi_fs_exists(struct blk_desc *desc, int part)
367{
368 if (fs_set_blk_dev_with_part(desc, part))
369 return 0;
370
371 if (fs_get_type() == FS_TYPE_ANY)
372 return 0;
373
374 fs_close();
375
376 return 1;
377}
378
Heinrich Schuchardt76f57892020-04-10 17:10:34 +0200379/**
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100380 * efi_disk_add_dev() - create a handle for a partition or disk
Heinrich Schuchardt34f51832017-10-26 19:25:46 +0200381 *
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100382 * @parent: parent handle
383 * @dp_parent: parent device path
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100384 * @desc: internal block device
385 * @dev_index: device index for block device
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100386 * @part_info: partition info
Heinrich Schuchardt76f57892020-04-10 17:10:34 +0200387 * @part: partition
388 * @disk: pointer to receive the created handle
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100389 * Return: disk object
Heinrich Schuchardt34f51832017-10-26 19:25:46 +0200390 */
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100391static efi_status_t efi_disk_add_dev(
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100392 efi_handle_t parent,
393 struct efi_device_path *dp_parent,
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100394 struct blk_desc *desc,
395 int dev_index,
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100396 struct disk_partition *part_info,
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100397 unsigned int part,
398 struct efi_disk_obj **disk)
Alexander Graf06fe57b2016-04-11 16:16:17 +0200399{
400 struct efi_disk_obj *diskobj;
Heinrich Schuchardt2321b552020-05-21 09:22:06 +0200401 struct efi_object *handle;
Heinrich Schuchardt31d63b82022-10-07 11:03:01 +0200402 const efi_guid_t *esp_guid = NULL;
Heinrich Schuchardt9fb0f2f2017-11-26 14:05:12 +0100403 efi_status_t ret;
Alexander Graf06fe57b2016-04-11 16:16:17 +0200404
Alexander Graf601db1f2016-08-05 14:51:47 +0200405 /* Don't add empty devices */
406 if (!desc->lba)
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100407 return EFI_NOT_READY;
Alexander Graf601db1f2016-08-05 14:51:47 +0200408
Rob Clarka83272f2017-09-13 18:05:31 -0400409 diskobj = calloc(1, sizeof(*diskobj));
Heinrich Schuchardt9fb0f2f2017-11-26 14:05:12 +0100410 if (!diskobj)
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100411 return EFI_OUT_OF_RESOURCES;
Heinrich Schuchardt9fb0f2f2017-11-26 14:05:12 +0100412
413 /* Hook up to the device list */
Heinrich Schuchardt72928722018-09-26 05:27:56 +0200414 efi_add_handle(&diskobj->header);
Alexander Graf06fe57b2016-04-11 16:16:17 +0200415
416 /* Fill in object data */
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100417 if (part_info) {
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100418 struct efi_device_path *node = efi_dp_part_node(desc, part);
Heinrich Schuchardtcb9ff4e2020-01-10 12:36:01 +0100419 struct efi_handler *handler;
420 void *protocol_interface;
421
Heinrich Schuchardte29fbb32022-10-06 13:36:02 +0200422 if (!node) {
423 ret = EFI_OUT_OF_RESOURCES;
424 goto error;
425 }
426
Heinrich Schuchardtcb9ff4e2020-01-10 12:36:01 +0100427 /* Parent must expose EFI_BLOCK_IO_PROTOCOL */
428 ret = efi_search_protocol(parent, &efi_block_io_guid, &handler);
429 if (ret != EFI_SUCCESS)
430 goto error;
431
432 /*
433 * Link the partition (child controller) to the block device
434 * (controller).
435 */
436 ret = efi_protocol_open(handler, &protocol_interface, NULL,
437 &diskobj->header,
438 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER);
439 if (ret != EFI_SUCCESS)
440 goto error;
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100441
442 diskobj->dp = efi_dp_append_node(dp_parent, node);
443 efi_free_pool(node);
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100444 diskobj->media.last_block = part_info->size - 1;
Heinrich Schuchardt26397622021-02-02 17:53:14 +0100445 if (part_info->bootable & PART_EFI_SYSTEM_PARTITION)
Heinrich Schuchardt31d63b82022-10-07 11:03:01 +0200446 esp_guid = &efi_system_partition_guid;
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100447 } else {
448 diskobj->dp = efi_dp_from_part(desc, part);
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100449 diskobj->media.last_block = desc->lba - 1;
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100450 }
Rob Clarka83272f2017-09-13 18:05:31 -0400451 diskobj->part = part;
Heinrich Schuchardt2321b552020-05-21 09:22:06 +0200452
453 /*
454 * Install the device path and the block IO protocol.
455 *
456 * InstallMultipleProtocolInterfaces() checks if the device path is
457 * already installed on an other handle and returns EFI_ALREADY_STARTED
458 * in this case.
459 */
460 handle = &diskobj->header;
Heinrich Schuchardt31d63b82022-10-07 11:03:01 +0200461 ret = efi_install_multiple_protocol_interfaces(
462 &handle,
463 &efi_guid_device_path, diskobj->dp,
464 &efi_block_io_guid, &diskobj->ops,
465 /*
466 * esp_guid must be last entry as it
467 * can be NULL. Its interface is NULL.
468 */
469 esp_guid, NULL,
470 NULL);
Heinrich Schuchardt9fb0f2f2017-11-26 14:05:12 +0100471 if (ret != EFI_SUCCESS)
Heinrich Schuchardte47b68b2021-11-20 13:56:02 +0100472 goto error;
Heinrich Schuchardt2321b552020-05-21 09:22:06 +0200473
474 /*
475 * On partitions or whole disks without partitions install the
476 * simple file system protocol if a file system is available.
477 */
AKASHI Takahiro356ef902019-10-07 14:59:39 +0900478 if ((part || desc->part_type == PART_TYPE_UNKNOWN) &&
479 efi_fs_exists(desc, part)) {
Rob Clark53142032017-09-13 18:05:34 -0400480 diskobj->volume = efi_simple_file_system(desc, part,
481 diskobj->dp);
Heinrich Schuchardt72928722018-09-26 05:27:56 +0200482 ret = efi_add_protocol(&diskobj->header,
Heinrich Schuchardt9fb0f2f2017-11-26 14:05:12 +0100483 &efi_simple_file_system_protocol_guid,
Heinrich Schuchardtce721a82018-01-19 20:24:38 +0100484 diskobj->volume);
Heinrich Schuchardt9fb0f2f2017-11-26 14:05:12 +0100485 if (ret != EFI_SUCCESS)
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100486 return ret;
Rob Clark53142032017-09-13 18:05:34 -0400487 }
Alexander Graf06fe57b2016-04-11 16:16:17 +0200488 diskobj->ops = block_io_disk_template;
Alexander Graf06fe57b2016-04-11 16:16:17 +0200489 diskobj->dev_index = dev_index;
490
491 /* Fill in EFI IO Media info (for read/write callbacks) */
492 diskobj->media.removable_media = desc->removable;
493 diskobj->media.media_present = 1;
Heinrich Schuchardt35922522019-09-05 19:31:23 +0200494 /*
495 * MediaID is just an arbitrary counter.
496 * We have to change it if the medium is removed or changed.
497 */
498 diskobj->media.media_id = 1;
Alexander Graf06fe57b2016-04-11 16:16:17 +0200499 diskobj->media.block_size = desc->blksz;
500 diskobj->media.io_align = desc->blksz;
Heinrich Schuchardtaf8c5b62020-03-19 15:45:52 +0100501 if (part)
Emmanuel Vadot5bf29642017-12-11 19:22:33 +0100502 diskobj->media.logical_partition = 1;
Alexander Graf06fe57b2016-04-11 16:16:17 +0200503 diskobj->ops.media = &diskobj->media;
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100504 if (disk)
505 *disk = diskobj;
Heinrich Schuchardta9931732020-03-19 15:16:31 +0100506
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100507 EFI_PRINT("BlockIO: part %u, present %d, logical %d, removable %d"
Paul Barbieriab814f12022-06-30 07:02:04 -0400508 ", last_block %llu\n",
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100509 diskobj->part,
510 diskobj->media.media_present,
511 diskobj->media.logical_partition,
512 diskobj->media.removable_media,
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100513 diskobj->media.last_block);
514
Heinrich Schuchardta9931732020-03-19 15:16:31 +0100515 /* Store first EFI system partition */
Heinrich Schuchardt0397d812022-10-21 08:33:44 +0200516 if (part && efi_system_partition.uclass_id == UCLASS_INVALID) {
Heinrich Schuchardt26397622021-02-02 17:53:14 +0100517 if (part_info->bootable & PART_EFI_SYSTEM_PARTITION) {
Simon Glassfada3f92022-09-17 09:00:09 -0600518 efi_system_partition.uclass_id = desc->uclass_id;
Heinrich Schuchardta9931732020-03-19 15:16:31 +0100519 efi_system_partition.devnum = desc->devnum;
520 efi_system_partition.part = part;
Heinrich Schuchardt54f180d2021-05-25 18:00:13 +0200521 EFI_PRINT("EFI system partition: %s %x:%x\n",
Simon Glassfada3f92022-09-17 09:00:09 -0600522 blk_get_uclass_name(desc->uclass_id),
Heinrich Schuchardta9931732020-03-19 15:16:31 +0100523 desc->devnum, part);
524 }
525 }
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100526 return EFI_SUCCESS;
Heinrich Schuchardtcb9ff4e2020-01-10 12:36:01 +0100527error:
528 efi_delete_handle(&diskobj->header);
529 return ret;
Alexander Graf06fe57b2016-04-11 16:16:17 +0200530}
531
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900532/*
533 * Create a handle for a whole raw disk
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100534 *
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900535 * @dev uclass device (UCLASS_BLK)
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100536 *
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900537 * Create an efi_disk object which is associated with @dev.
538 * The type of @dev must be UCLASS_BLK.
539 *
540 * @return 0 on success, -1 otherwise
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100541 */
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900542static int efi_disk_create_raw(struct udevice *dev)
Alexander Grafeb8d82c2016-04-11 16:16:18 +0200543{
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900544 struct efi_disk_obj *disk;
545 struct blk_desc *desc;
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900546 int diskid;
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100547 efi_status_t ret;
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100548
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900549 desc = dev_get_uclass_plat(dev);
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900550 diskid = desc->devnum;
Alexander Grafeb8d82c2016-04-11 16:16:18 +0200551
AKASHI Takahiro7ec925d2022-08-19 09:48:30 +0900552 ret = efi_disk_add_dev(NULL, NULL, desc,
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900553 diskid, NULL, 0, &disk);
554 if (ret != EFI_SUCCESS) {
555 if (ret == EFI_NOT_READY)
556 log_notice("Disk %s not ready\n", dev->name);
557 else
558 log_err("Adding disk for %s failed\n", dev->name);
Heinrich Schuchardtb56e7192021-01-23 06:52:21 +0100559
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900560 return -1;
Alexander Grafeb8d82c2016-04-11 16:16:18 +0200561 }
Masahisa Kojimac9611082022-07-22 11:39:10 +0900562 if (efi_link_dev(&disk->header, dev)) {
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900563 efi_free_pool(disk->dp);
564 efi_delete_handle(&disk->header);
Rob Clarka83272f2017-09-13 18:05:31 -0400565
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900566 return -1;
567 }
568
569 return 0;
Alexander Grafeb8d82c2016-04-11 16:16:18 +0200570}
571
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900572/*
573 * Create a handle for a disk partition
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100574 *
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900575 * @dev uclass device (UCLASS_PARTITION)
Alexander Grafe83be452016-03-04 01:10:02 +0100576 *
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900577 * Create an efi_disk object which is associated with @dev.
578 * The type of @dev must be UCLASS_PARTITION.
Heinrich Schuchardt62036062020-03-19 13:49:34 +0100579 *
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900580 * @return 0 on success, -1 otherwise
Alexander Grafe83be452016-03-04 01:10:02 +0100581 */
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900582static int efi_disk_create_part(struct udevice *dev)
Alexander Grafe83be452016-03-04 01:10:02 +0100583{
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900584 efi_handle_t parent;
585 struct blk_desc *desc;
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900586 struct disk_part *part_data;
587 struct disk_partition *info;
588 unsigned int part;
589 int diskid;
590 struct efi_handler *handler;
591 struct efi_device_path *dp_parent;
Heinrich Schuchardt6f3de6b2018-01-19 20:24:47 +0100592 struct efi_disk_obj *disk;
Heinrich Schuchardtcde7a362018-02-09 20:55:47 +0100593 efi_status_t ret;
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900594
595 if (dev_tag_get_ptr(dev_get_parent(dev), DM_TAG_EFI, (void **)&parent))
596 return -1;
597
598 desc = dev_get_uclass_plat(dev_get_parent(dev));
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900599 diskid = desc->devnum;
600
601 part_data = dev_get_uclass_plat(dev);
602 part = part_data->partnum;
603 info = &part_data->gpt_part_info;
604
605 ret = efi_search_protocol(parent, &efi_guid_device_path, &handler);
606 if (ret != EFI_SUCCESS)
607 return -1;
608 dp_parent = (struct efi_device_path *)handler->protocol_interface;
609
AKASHI Takahiro7ec925d2022-08-19 09:48:30 +0900610 ret = efi_disk_add_dev(parent, dp_parent, desc, diskid,
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900611 info, part, &disk);
612 if (ret != EFI_SUCCESS) {
613 log_err("Adding partition for %s failed\n", dev->name);
614 return -1;
615 }
Masahisa Kojimac9611082022-07-22 11:39:10 +0900616 if (efi_link_dev(&disk->header, dev)) {
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900617 efi_free_pool(disk->dp);
618 efi_delete_handle(&disk->header);
619
620 return -1;
621 }
622
623 return 0;
624}
625
626/*
627 * Create efi_disk objects for a block device
628 *
629 * @dev uclass device (UCLASS_BLK)
630 *
631 * Create efi_disk objects for partitions as well as a raw disk
632 * which is associated with @dev.
633 * The type of @dev must be UCLASS_BLK.
634 * This function is expected to be called at EV_PM_POST_PROBE.
635 *
636 * @return 0 on success, -1 otherwise
637 */
Heinrich Schuchardtda620cf2022-10-06 07:29:41 +0200638int efi_disk_probe(void *ctx, struct event *event)
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900639{
Simon Glass302d4f82016-05-14 14:03:05 -0600640 struct udevice *dev;
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900641 enum uclass_id id;
AKASHI Takahirocdd245a2022-04-19 10:05:13 +0900642 struct blk_desc *desc;
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900643 struct udevice *child;
644 int ret;
Simon Glass302d4f82016-05-14 14:03:05 -0600645
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900646 dev = event->data.dm.dev;
647 id = device_get_uclass_id(dev);
Simon Glass302d4f82016-05-14 14:03:05 -0600648
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900649 /* TODO: We won't support partitions in a partition */
650 if (id != UCLASS_BLK)
651 return 0;
652
AKASHI Takahirocdd245a2022-04-19 10:05:13 +0900653 /*
654 * avoid creating duplicated objects now that efi_driver
655 * has already created an efi_disk at this moment.
656 */
657 desc = dev_get_uclass_plat(dev);
Simon Glassfada3f92022-09-17 09:00:09 -0600658 if (desc->uclass_id != UCLASS_EFI_LOADER) {
AKASHI Takahirocdd245a2022-04-19 10:05:13 +0900659 ret = efi_disk_create_raw(dev);
660 if (ret)
661 return -1;
662 }
Simon Glass302d4f82016-05-14 14:03:05 -0600663
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900664 device_foreach_child(child, dev) {
665 ret = efi_disk_create_part(child);
666 if (ret)
667 return -1;
Simon Glass302d4f82016-05-14 14:03:05 -0600668 }
Alexander Grafe83be452016-03-04 01:10:02 +0100669
AKASHI Takahiro2381f2e2022-04-19 10:05:12 +0900670 return 0;
671}
672
AKASHI Takahiro7cebb752022-04-19 10:05:14 +0900673/*
674 * Delete an efi_disk object for a whole raw disk
675 *
676 * @dev uclass device (UCLASS_BLK)
677 *
678 * Delete an efi_disk object which is associated with @dev.
679 * The type of @dev must be UCLASS_BLK.
680 *
681 * @return 0 on success, -1 otherwise
682 */
683static int efi_disk_delete_raw(struct udevice *dev)
684{
685 efi_handle_t handle;
AKASHI Takahiroaff330a2022-04-19 10:05:15 +0900686 struct blk_desc *desc;
AKASHI Takahiro7cebb752022-04-19 10:05:14 +0900687 struct efi_disk_obj *diskobj;
688
689 if (dev_tag_get_ptr(dev, DM_TAG_EFI, (void **)&handle))
690 return -1;
691
AKASHI Takahiroaff330a2022-04-19 10:05:15 +0900692 desc = dev_get_uclass_plat(dev);
Simon Glassfada3f92022-09-17 09:00:09 -0600693 if (desc->uclass_id != UCLASS_EFI_LOADER) {
AKASHI Takahiroaff330a2022-04-19 10:05:15 +0900694 diskobj = container_of(handle, struct efi_disk_obj, header);
695 efi_free_pool(diskobj->dp);
696 }
AKASHI Takahiro7cebb752022-04-19 10:05:14 +0900697
698 efi_delete_handle(handle);
699 dev_tag_del(dev, DM_TAG_EFI);
700
701 return 0;
702}
703
704/*
705 * Delete an efi_disk object for a disk partition
706 *
707 * @dev uclass device (UCLASS_PARTITION)
708 *
709 * Delete an efi_disk object which is associated with @dev.
710 * The type of @dev must be UCLASS_PARTITION.
711 *
712 * @return 0 on success, -1 otherwise
713 */
714static int efi_disk_delete_part(struct udevice *dev)
715{
716 efi_handle_t handle;
717 struct efi_disk_obj *diskobj;
718
719 if (dev_tag_get_ptr(dev, DM_TAG_EFI, (void **)&handle))
720 return -1;
721
722 diskobj = container_of(handle, struct efi_disk_obj, header);
723
724 efi_free_pool(diskobj->dp);
725 efi_delete_handle(handle);
726 dev_tag_del(dev, DM_TAG_EFI);
727
728 return 0;
729}
730
731/*
732 * Delete an efi_disk object for a block device
733 *
734 * @dev uclass device (UCLASS_BLK or UCLASS_PARTITION)
735 *
736 * Delete an efi_disk object which is associated with @dev.
737 * The type of @dev must be either UCLASS_BLK or UCLASS_PARTITION.
738 * This function is expected to be called at EV_PM_PRE_REMOVE.
739 *
740 * @return 0 on success, -1 otherwise
741 */
Heinrich Schuchardtda620cf2022-10-06 07:29:41 +0200742int efi_disk_remove(void *ctx, struct event *event)
AKASHI Takahiro7cebb752022-04-19 10:05:14 +0900743{
744 enum uclass_id id;
745 struct udevice *dev;
746
747 dev = event->data.dm.dev;
748 id = device_get_uclass_id(dev);
749
750 if (id == UCLASS_BLK)
751 return efi_disk_delete_raw(dev);
752 else if (id == UCLASS_PARTITION)
753 return efi_disk_delete_part(dev);
754 else
755 return 0;
756}
757
Masahisa Kojimac5ff0a02022-09-12 17:33:50 +0900758/**
759 * efi_disk_get_device_name() - get U-Boot device name associated with EFI handle
760 *
761 * @handle: pointer to the EFI handle
762 * @buf: pointer to the buffer to store the string
763 * @size: size of buffer
764 * Return: status code
765 */
766efi_status_t efi_disk_get_device_name(const efi_handle_t handle, char *buf, int size)
767{
768 int count;
769 int diskid;
770 enum uclass_id id;
771 unsigned int part;
772 struct udevice *dev;
773 struct blk_desc *desc;
774 const char *if_typename;
775 bool is_partition = false;
776 struct disk_part *part_data;
777
778 if (!handle || !buf || !size)
779 return EFI_INVALID_PARAMETER;
780
781 dev = handle->dev;
782 id = device_get_uclass_id(dev);
783 if (id == UCLASS_BLK) {
784 desc = dev_get_uclass_plat(dev);
785 } else if (id == UCLASS_PARTITION) {
786 desc = dev_get_uclass_plat(dev_get_parent(dev));
787 is_partition = true;
788 } else {
789 return EFI_INVALID_PARAMETER;
790 }
Simon Glassfada3f92022-09-17 09:00:09 -0600791 if_typename = blk_get_uclass_name(desc->uclass_id);
Masahisa Kojimac5ff0a02022-09-12 17:33:50 +0900792 diskid = desc->devnum;
793
794 if (is_partition) {
795 part_data = dev_get_uclass_plat(dev);
796 part = part_data->partnum;
Heinrich Schuchardt217cb202022-10-07 12:55:16 +0200797 count = snprintf(buf, size, "%s %d:%u", if_typename, diskid,
798 part);
Masahisa Kojimac5ff0a02022-09-12 17:33:50 +0900799 } else {
800 count = snprintf(buf, size, "%s %d", if_typename, diskid);
801 }
802
803 if (count < 0 || (count + 1) > size)
804 return EFI_INVALID_PARAMETER;
805
806 return EFI_SUCCESS;
807}
Tom Rini586c22b2022-09-19 13:19:39 -0400808
809/**
Heinrich Schuchardta02228f2022-08-31 16:37:35 +0200810 * efi_disks_register() - ensure all block devices are available in UEFI
811 *
812 * The function probes all block devices. As we store UEFI variables on the
813 * EFI system partition this function has to be called before enabling
814 * variable services.
815 */
816efi_status_t efi_disks_register(void)
817{
818 struct udevice *dev;
819
820 uclass_foreach_dev_probe(UCLASS_BLK, dev) {
821 }
822
823 return EFI_SUCCESS;
824}