1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * EFI-app board implementation
4 *
5 * Copyright 2023 Google LLC
6 * Written by Simon Glass <sjg@chromium.org>
7 */
8
9 #include <dm.h>
10 #include <efi.h>
11 #include <efi_api.h>
12 #include <errno.h>
13 #include <malloc.h>
14 #include <asm/global_data.h>
15 #include <dm/device-internal.h>
16 #include <dm/root.h>
17 #include <linux/types.h>
18
19 DECLARE_GLOBAL_DATA_PTR;
20
21 /**
22 * efi_bind_block() - bind a new block device to an EFI device
23 *
24 * Binds a new top-level EFI_MEDIA device as well as a child block device so
25 * that the block device can be accessed in U-Boot.
26 *
27 * The device can then be accessed using 'part list efi 0', 'fat ls efi 0:1',
28 * for example, just like any other interface type.
29 *
30 * @handle: handle of the controller on which this driver is installed
31 * @blkio: block io protocol proxied by this driver
32 * @device_path: EFI device path structure for this
33 * @len: Length of @device_path in bytes
34 * @devp: Returns the bound device
35 * Return: 0 if OK, -ve on error
36 */
efi_bind_block(efi_handle_t handle,struct efi_block_io * blkio,struct efi_device_path * device_path,int len,struct udevice ** devp)37 int efi_bind_block(efi_handle_t handle, struct efi_block_io *blkio,
38 struct efi_device_path *device_path, int len,
39 struct udevice **devp)
40 {
41 struct efi_media_plat plat;
42 struct udevice *dev;
43 char name[18];
44 int ret;
45
46 plat.handle = handle;
47 plat.blkio = blkio;
48 plat.device_path = malloc(device_path->length);
49 if (!plat.device_path)
50 return log_msg_ret("path", -ENOMEM);
51 memcpy(plat.device_path, device_path, device_path->length);
52 ret = device_bind(dm_root(), DM_DRIVER_GET(efi_media), "efi_media",
53 &plat, ofnode_null(), &dev);
54 if (ret)
55 return log_msg_ret("bind", ret);
56
57 snprintf(name, sizeof(name), "efi_media_%x", dev_seq(dev));
58 device_set_name(dev, name);
59 *devp = dev;
60
61 return 0;
62 }
63
64 /**
65 * devpath_is_partition() - Figure out if a device path is a partition
66 *
67 * Checks if a device path refers to a partition on some media device. This
68 * works by checking for a valid partition number in a hard-driver media device
69 * as the final component of the device path.
70 *
71 * @path: device path
72 * Return: true if a partition, false if not
73 * (e.g. it might be media which contains partitions)
74 */
devpath_is_partition(const struct efi_device_path * path)75 static bool devpath_is_partition(const struct efi_device_path *path)
76 {
77 const struct efi_device_path *p;
78 bool was_part = false;
79
80 for (p = path; p->type != DEVICE_PATH_TYPE_END;
81 p = (void *)p + p->length) {
82 was_part = false;
83 if (p->type == DEVICE_PATH_TYPE_MEDIA_DEVICE &&
84 p->sub_type == DEVICE_PATH_SUB_TYPE_HARD_DRIVE_PATH) {
85 struct efi_device_path_hard_drive_path *hd =
86 (void *)path;
87
88 if (hd->partition_number)
89 was_part = true;
90 }
91 }
92
93 return was_part;
94 }
95
96 /**
97 * setup_block() - Find all block devices and setup EFI devices for them
98 *
99 * Partitions are ignored, since U-Boot has partition handling. Errors with
100 * particular devices produce a warning but execution continues to try to
101 * find others.
102 *
103 * Return: 0 if found, -ENOSYS if there is no boot-services table, -ENOTSUPP
104 * if a required protocol is not supported
105 */
setup_block(void)106 static int setup_block(void)
107 {
108 efi_guid_t efi_blkio_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
109 efi_guid_t efi_devpath_guid = EFI_DEVICE_PATH_PROTOCOL_GUID;
110 efi_guid_t efi_pathutil_guid = EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID;
111 efi_guid_t efi_pathtext_guid = EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID;
112 struct efi_boot_services *boot = efi_get_boot();
113 struct efi_device_path_utilities_protocol *util;
114 struct efi_device_path_to_text_protocol *text;
115 struct efi_device_path *path;
116 struct efi_block_io *blkio;
117 efi_uintn_t num_handles;
118 efi_handle_t *handle;
119 int ret, i;
120
121 if (!boot)
122 return log_msg_ret("sys", -ENOSYS);
123
124 /* Find all devices which support the block I/O protocol */
125 ret = boot->locate_handle_buffer(BY_PROTOCOL, &efi_blkio_guid, NULL,
126 &num_handles, &handle);
127 if (ret)
128 return log_msg_ret("loc", -ENOTSUPP);
129 log_debug("Found %d handles:\n", (int)num_handles);
130
131 /* We need to look up the path size and convert it to text */
132 ret = boot->locate_protocol(&efi_pathutil_guid, NULL, (void **)&util);
133 if (ret)
134 return log_msg_ret("util", -ENOTSUPP);
135 ret = boot->locate_protocol(&efi_pathtext_guid, NULL, (void **)&text);
136 if (ret)
137 return log_msg_ret("text", -ENOTSUPP);
138
139 for (i = 0; i < num_handles; i++) {
140 struct udevice *dev;
141 const u16 *name;
142 bool is_part;
143 int len;
144
145 ret = boot->handle_protocol(handle[i], &efi_devpath_guid,
146 (void **)&path);
147 if (ret) {
148 log_warning("- devpath %d failed (ret=%d)\n", i, ret);
149 continue;
150 }
151
152 ret = boot->handle_protocol(handle[i], &efi_blkio_guid,
153 (void **)&blkio);
154 if (ret) {
155 log_warning("- blkio %d failed (ret=%d)\n", i, ret);
156 continue;
157 }
158
159 name = text->convert_device_path_to_text(path, true, false);
160 is_part = devpath_is_partition(path);
161
162 if (!is_part) {
163 len = util->get_device_path_size(path);
164 ret = efi_bind_block(handle[i], blkio, path, len, &dev);
165 if (ret) {
166 log_warning("- blkio bind %d failed (ret=%d)\n",
167 i, ret);
168 continue;
169 }
170 } else {
171 dev = NULL;
172 }
173
174 /*
175 * Show the device name if we created one. Otherwise indicate
176 * that it is a partition.
177 */
178 printf("%2d: %-12s %ls\n", i, dev ? dev->name : "<partition>",
179 name);
180 }
181 boot->free_pool(handle);
182
183 return 0;
184 }
185
186 /**
187 * board_early_init_r() - Scan for UEFI devices that should be available
188 *
189 * This sets up block devices within U-Boot for those found in UEFI. With this,
190 * U-Boot can access those devices
191 *
192 * Returns: 0 on success, -ve on error
193 */
board_early_init_r(void)194 int board_early_init_r(void)
195 {
196 if (gd->flags & GD_FLG_RELOC) {
197 int ret;
198
199 ret = setup_block();
200 if (ret)
201 return ret;
202 }
203
204 return 0;
205 }
206