]>
Commit | Line | Data |
---|---|---|
2a22d05d AG |
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> | |
6dd9faf8 | 10 | #include <blk.h> |
487d756f | 11 | #include <dm.h> |
2a22d05d AG |
12 | #include <efi_loader.h> |
13 | #include <inttypes.h> | |
14 | #include <part.h> | |
15 | #include <malloc.h> | |
16 | ||
b3dd14b6 | 17 | const efi_guid_t efi_block_io_guid = BLOCK_IO_GUID; |
2a22d05d AG |
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 */ | |
884bcf6f RC |
31 | struct efi_device_path *dp; |
32 | /* partition # */ | |
33 | unsigned int part; | |
2a92080d RC |
34 | /* handle to filesys proto (for partition objects) */ |
35 | struct efi_simple_file_system_protocol *volume; | |
8c3df0bf AG |
36 | /* Offset into disk for simple partitions */ |
37 | lbaint_t offset; | |
f9d334bd | 38 | /* Internal block device */ |
884bcf6f | 39 | struct blk_desc *desc; |
2a22d05d AG |
40 | }; |
41 | ||
2a22d05d AG |
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 | ||
a80a232e | 54 | static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this, |
2a22d05d AG |
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 | ||
2a22d05d | 64 | diskobj = container_of(this, struct efi_disk_obj, ops); |
f9d334bd | 65 | desc = (struct blk_desc *) diskobj->desc; |
2a22d05d AG |
66 | blksz = desc->blksz; |
67 | blocks = buffer_size / blksz; | |
8c3df0bf | 68 | lba += diskobj->offset; |
2a22d05d | 69 | |
edcef3ba AG |
70 | debug("EFI: %s:%d blocks=%x lba=%"PRIx64" blksz=%x dir=%d\n", __func__, |
71 | __LINE__, blocks, lba, blksz, direction); | |
2a22d05d AG |
72 | |
73 | /* We only support full block access */ | |
74 | if (buffer_size & (blksz - 1)) | |
3304990b | 75 | return EFI_DEVICE_ERROR; |
2a22d05d AG |
76 | |
77 | if (direction == EFI_DISK_READ) | |
487d756f | 78 | n = blk_dread(desc, lba, blocks, buffer); |
2a22d05d | 79 | else |
487d756f | 80 | n = blk_dwrite(desc, lba, blocks, buffer); |
2a22d05d AG |
81 | |
82 | /* We don't do interrupts, so check for timers cooperatively */ | |
83 | efi_timer_check(); | |
84 | ||
edcef3ba AG |
85 | debug("EFI: %s:%d n=%lx blocks=%x\n", __func__, __LINE__, n, blocks); |
86 | ||
2a22d05d | 87 | if (n != blocks) |
3304990b | 88 | return EFI_DEVICE_ERROR; |
2a22d05d | 89 | |
3304990b | 90 | return EFI_SUCCESS; |
2a22d05d AG |
91 | } |
92 | ||
e275458c | 93 | static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this, |
4f94865b | 94 | u32 media_id, u64 lba, efi_uintn_t buffer_size, |
2a22d05d AG |
95 | void *buffer) |
96 | { | |
51735ae0 AG |
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 | ||
4f94865b | 115 | EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba, |
51735ae0 AG |
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); | |
2a22d05d AG |
126 | } |
127 | ||
e275458c | 128 | static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this, |
4f94865b | 129 | u32 media_id, u64 lba, efi_uintn_t buffer_size, |
2a22d05d AG |
130 | void *buffer) |
131 | { | |
51735ae0 AG |
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 | ||
4f94865b | 150 | EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba, |
51735ae0 AG |
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); | |
2a22d05d AG |
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 | ||
2a92080d | 177 | /* |
110d80a1 HS |
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 | |
2a92080d RC |
186 | */ |
187 | struct efi_simple_file_system_protocol * | |
110d80a1 | 188 | efi_fs_from_path(struct efi_device_path *full_path) |
2a92080d RC |
189 | { |
190 | struct efi_object *efiobj; | |
110d80a1 HS |
191 | struct efi_handler *handler; |
192 | struct efi_device_path *device_path; | |
193 | struct efi_device_path *file_path; | |
194 | efi_status_t ret; | |
2a92080d | 195 | |
110d80a1 HS |
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); | |
2a92080d RC |
205 | if (!efiobj) |
206 | return NULL; | |
207 | ||
110d80a1 HS |
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; | |
2a92080d | 213 | |
110d80a1 HS |
214 | /* Return the simple file system protocol for the partition */ |
215 | return handler->protocol_interface; | |
2a92080d RC |
216 | } |
217 | ||
93945f2c | 218 | /* |
64e4db0f | 219 | * Create a handle for a partition or disk |
93945f2c | 220 | * |
64e4db0f HS |
221 | * @parent parent handle |
222 | * @dp_parent parent device path | |
93945f2c HS |
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 | |
64e4db0f | 227 | * @return disk object |
93945f2c | 228 | */ |
df9cf561 | 229 | static efi_status_t efi_disk_add_dev( |
64e4db0f HS |
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, | |
df9cf561 HS |
236 | unsigned int part, |
237 | struct efi_disk_obj **disk) | |
4a12a97c AG |
238 | { |
239 | struct efi_disk_obj *diskobj; | |
4b9f7aaf | 240 | efi_status_t ret; |
4a12a97c | 241 | |
0812d1a0 AG |
242 | /* Don't add empty devices */ |
243 | if (!desc->lba) | |
df9cf561 | 244 | return EFI_NOT_READY; |
0812d1a0 | 245 | |
884bcf6f | 246 | diskobj = calloc(1, sizeof(*diskobj)); |
4b9f7aaf | 247 | if (!diskobj) |
df9cf561 | 248 | return EFI_OUT_OF_RESOURCES; |
4b9f7aaf HS |
249 | |
250 | /* Hook up to the device list */ | |
44549d62 | 251 | efi_add_handle(&diskobj->parent); |
4a12a97c AG |
252 | |
253 | /* Fill in object data */ | |
64e4db0f HS |
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 | } | |
884bcf6f | 262 | diskobj->part = part; |
4b9f7aaf HS |
263 | ret = efi_add_protocol(diskobj->parent.handle, &efi_block_io_guid, |
264 | &diskobj->ops); | |
265 | if (ret != EFI_SUCCESS) | |
df9cf561 | 266 | return ret; |
4b9f7aaf HS |
267 | ret = efi_add_protocol(diskobj->parent.handle, &efi_guid_device_path, |
268 | diskobj->dp); | |
269 | if (ret != EFI_SUCCESS) | |
df9cf561 | 270 | return ret; |
2a92080d RC |
271 | if (part >= 1) { |
272 | diskobj->volume = efi_simple_file_system(desc, part, | |
273 | diskobj->dp); | |
4b9f7aaf HS |
274 | ret = efi_add_protocol(diskobj->parent.handle, |
275 | &efi_simple_file_system_protocol_guid, | |
22de1de9 | 276 | diskobj->volume); |
4b9f7aaf | 277 | if (ret != EFI_SUCCESS) |
df9cf561 | 278 | return ret; |
2a92080d | 279 | } |
4a12a97c | 280 | diskobj->ops = block_io_disk_template; |
487d756f | 281 | diskobj->ifname = if_typename; |
4a12a97c | 282 | diskobj->dev_index = dev_index; |
8c3df0bf | 283 | diskobj->offset = offset; |
f9d334bd | 284 | diskobj->desc = desc; |
4a12a97c AG |
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; | |
0812d1a0 | 291 | diskobj->media.last_block = desc->lba - offset; |
5f770836 EV |
292 | if (part != 0) |
293 | diskobj->media.logical_partition = 1; | |
4a12a97c | 294 | diskobj->ops.media = &diskobj->media; |
df9cf561 HS |
295 | if (disk) |
296 | *disk = diskobj; | |
297 | return EFI_SUCCESS; | |
4a12a97c AG |
298 | } |
299 | ||
64e4db0f HS |
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) | |
8c3df0bf AG |
313 | { |
314 | int disks = 0; | |
ecbe1a07 | 315 | char devname[32] = { 0 }; /* dp->str is u16[32] long */ |
8c3df0bf | 316 | disk_partition_t info; |
16a73b24 | 317 | int part; |
64e4db0f HS |
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; | |
8c3df0bf | 326 | |
c034b7fd | 327 | /* Add devices for each partition */ |
16a73b24 JG |
328 | for (part = 1; part <= MAX_SEARCH_PARTITIONS; part++) { |
329 | if (part_get_info(desc, part, &info)) | |
330 | continue; | |
f9d334bd AG |
331 | snprintf(devname, sizeof(devname), "%s:%d", pdevname, |
332 | part); | |
df9cf561 HS |
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 | } | |
8c3df0bf AG |
339 | disks++; |
340 | } | |
884bcf6f | 341 | |
8c3df0bf AG |
342 | return disks; |
343 | } | |
344 | ||
2a22d05d AG |
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 | * | |
487d756f SG |
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 | * | |
2a22d05d AG |
354 | * This gets called from do_bootefi_exec(). |
355 | */ | |
df9cf561 | 356 | efi_status_t efi_disk_register(void) |
2a22d05d | 357 | { |
64e4db0f | 358 | struct efi_disk_obj *disk; |
2a22d05d | 359 | int disks = 0; |
df9cf561 | 360 | efi_status_t ret; |
487d756f SG |
361 | #ifdef CONFIG_BLK |
362 | struct udevice *dev; | |
363 | ||
df9cf561 | 364 | for (uclass_first_device_check(UCLASS_BLK, &dev); dev; |
70bfcdc6 | 365 | uclass_next_device_check(&dev)) { |
487d756f | 366 | struct blk_desc *desc = dev_get_uclass_platdata(dev); |
9bfca9f9 | 367 | const char *if_typename = blk_get_if_type_name(desc->if_type); |
487d756f | 368 | |
c034b7fd | 369 | /* Add block device for the full device */ |
df9cf561 HS |
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 | } | |
487d756f SG |
382 | disks++; |
383 | ||
c034b7fd | 384 | /* Partitions show up as block devices in EFI */ |
64e4db0f HS |
385 | disks += efi_disk_create_partitions( |
386 | disk->parent.handle, desc, if_typename, | |
387 | desc->devnum, dev->name); | |
487d756f SG |
388 | } |
389 | #else | |
390 | int i, if_type; | |
2a22d05d AG |
391 | |
392 | /* Search for all available disk devices */ | |
6dd9faf8 | 393 | for (if_type = 0; if_type < IF_TYPE_COUNT; if_type++) { |
487d756f SG |
394 | const struct blk_driver *cur_drvr; |
395 | const char *if_typename; | |
396 | ||
6dd9faf8 SG |
397 | cur_drvr = blk_driver_lookup_type(if_type); |
398 | if (!cur_drvr) | |
399 | continue; | |
400 | ||
487d756f SG |
401 | if_typename = cur_drvr->if_typename; |
402 | printf("Scanning disks on %s...\n", if_typename); | |
2a22d05d AG |
403 | for (i = 0; i < 4; i++) { |
404 | struct blk_desc *desc; | |
ecbe1a07 | 405 | char devname[32] = { 0 }; /* dp->str is u16[32] long */ |
2a22d05d | 406 | |
6dd9faf8 | 407 | desc = blk_get_devnum_by_type(if_type, i); |
2a22d05d AG |
408 | if (!desc) |
409 | continue; | |
410 | if (desc->type == DEV_TYPE_UNKNOWN) | |
411 | continue; | |
412 | ||
2a22d05d | 413 | snprintf(devname, sizeof(devname), "%s%d", |
487d756f | 414 | if_typename, i); |
77511b3b | 415 | |
c034b7fd | 416 | /* Add block device for the full device */ |
df9cf561 HS |
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 | } | |
2a22d05d | 428 | disks++; |
8c3df0bf | 429 | |
c034b7fd | 430 | /* Partitions show up as block devices in EFI */ |
64e4db0f HS |
431 | disks += efi_disk_create_partitions( |
432 | disk->parent.handle, desc, | |
433 | if_typename, i, devname); | |
2a22d05d AG |
434 | } |
435 | } | |
487d756f | 436 | #endif |
2a22d05d AG |
437 | printf("Found %d disks\n", disks); |
438 | ||
df9cf561 | 439 | return EFI_SUCCESS; |
2a22d05d | 440 | } |