]>
Commit | Line | Data |
---|---|---|
cc5b7081 | 1 | /* |
2 | * EFI device path interface | |
3 | * | |
4 | * Copyright (c) 2017 Heinrich Schuchardt | |
5 | * | |
6 | * SPDX-License-Identifier: GPL-2.0+ | |
7 | */ | |
8 | ||
9 | #include <common.h> | |
10 | #include <efi_loader.h> | |
11 | ||
09c5ab90 | 12 | #define MAC_OUTPUT_LEN 22 |
13 | #define UNKNOWN_OUTPUT_LEN 23 | |
cc5b7081 | 14 | |
61aba193 HS |
15 | #define MAX_NODE_LEN 512 |
16 | #define MAX_PATH_LEN 1024 | |
17 | ||
cc5b7081 | 18 | const efi_guid_t efi_guid_device_path_to_text_protocol = |
19 | EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID; | |
20 | ||
61aba193 HS |
21 | static u16 *efi_str_to_u16(char *str) |
22 | { | |
23 | efi_uintn_t len; | |
24 | u16 *out; | |
25 | efi_status_t ret; | |
26 | ||
27 | len = strlen(str) + 1; | |
28 | ret = efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, len * sizeof(u16), | |
29 | (void **)&out); | |
30 | if (ret != EFI_SUCCESS) | |
31 | return NULL; | |
32 | ascii2unicode(out, str); | |
33 | out[len - 1] = 0; | |
34 | return out; | |
35 | } | |
36 | ||
adae4313 RC |
37 | static char *dp_unknown(char *s, struct efi_device_path *dp) |
38 | { | |
61aba193 | 39 | s += sprintf(s, "UNKNOWN(%04x,%04x)", dp->type, dp->sub_type); |
adae4313 RC |
40 | return s; |
41 | } | |
42 | ||
43 | static char *dp_hardware(char *s, struct efi_device_path *dp) | |
44 | { | |
45 | switch (dp->sub_type) { | |
bf19273e RC |
46 | case DEVICE_PATH_SUB_TYPE_MEMORY: { |
47 | struct efi_device_path_memory *mdp = | |
48 | (struct efi_device_path_memory *)dp; | |
61aba193 | 49 | s += sprintf(s, "MemoryMapped(0x%x,0x%llx,0x%llx)", |
bf19273e RC |
50 | mdp->memory_type, |
51 | mdp->start_address, | |
52 | mdp->end_address); | |
53 | break; | |
54 | } | |
adae4313 RC |
55 | case DEVICE_PATH_SUB_TYPE_VENDOR: { |
56 | struct efi_device_path_vendor *vdp = | |
57 | (struct efi_device_path_vendor *)dp; | |
61aba193 | 58 | s += sprintf(s, "VenHw(%pUl)", &vdp->guid); |
adae4313 RC |
59 | break; |
60 | } | |
61 | default: | |
62 | s = dp_unknown(s, dp); | |
63 | break; | |
64 | } | |
65 | return s; | |
66 | } | |
67 | ||
68 | static char *dp_acpi(char *s, struct efi_device_path *dp) | |
69 | { | |
70 | switch (dp->sub_type) { | |
71 | case DEVICE_PATH_SUB_TYPE_ACPI_DEVICE: { | |
72 | struct efi_device_path_acpi_path *adp = | |
73 | (struct efi_device_path_acpi_path *)dp; | |
61aba193 | 74 | s += sprintf(s, "Acpi(PNP%04x", EISA_PNP_NUM(adp->hid)); |
adae4313 RC |
75 | if (adp->uid) |
76 | s += sprintf(s, ",%d", adp->uid); | |
77 | s += sprintf(s, ")"); | |
78 | break; | |
79 | } | |
80 | default: | |
81 | s = dp_unknown(s, dp); | |
82 | break; | |
83 | } | |
84 | return s; | |
85 | } | |
86 | ||
87 | static char *dp_msging(char *s, struct efi_device_path *dp) | |
88 | { | |
89 | switch (dp->sub_type) { | |
af3106a1 HS |
90 | case DEVICE_PATH_SUB_TYPE_MSG_ATAPI: { |
91 | struct efi_device_path_atapi *ide = | |
92 | (struct efi_device_path_atapi *)dp; | |
93 | s += sprintf(s, "Ata(%d,%d,%d)", ide->primary_secondary, | |
94 | ide->slave_master, ide->logical_unit_number); | |
95 | break; | |
96 | } | |
97 | case DEVICE_PATH_SUB_TYPE_MSG_SCSI: { | |
98 | struct efi_device_path_scsi *ide = | |
99 | (struct efi_device_path_scsi *)dp; | |
100 | s += sprintf(s, "Scsi(%u,%u)", ide->target_id, | |
101 | ide->logical_unit_number); | |
102 | break; | |
103 | } | |
adae4313 RC |
104 | case DEVICE_PATH_SUB_TYPE_MSG_USB: { |
105 | struct efi_device_path_usb *udp = | |
106 | (struct efi_device_path_usb *)dp; | |
6ea8b580 | 107 | s += sprintf(s, "USB(0x%x,0x%x)", udp->parent_port_number, |
adae4313 RC |
108 | udp->usb_interface); |
109 | break; | |
110 | } | |
111 | case DEVICE_PATH_SUB_TYPE_MSG_MAC_ADDR: { | |
112 | struct efi_device_path_mac_addr *mdp = | |
113 | (struct efi_device_path_mac_addr *)dp; | |
114 | ||
115 | if (mdp->if_type != 0 && mdp->if_type != 1) | |
116 | break; | |
117 | ||
61aba193 | 118 | s += sprintf(s, "MAC(%02x%02x%02x%02x%02x%02x,0x%1x)", |
adae4313 RC |
119 | mdp->mac.addr[0], mdp->mac.addr[1], |
120 | mdp->mac.addr[2], mdp->mac.addr[3], | |
121 | mdp->mac.addr[4], mdp->mac.addr[5], | |
122 | mdp->if_type); | |
123 | ||
124 | break; | |
125 | } | |
126 | case DEVICE_PATH_SUB_TYPE_MSG_USB_CLASS: { | |
127 | struct efi_device_path_usb_class *ucdp = | |
128 | (struct efi_device_path_usb_class *)dp; | |
129 | ||
61aba193 | 130 | s += sprintf(s, "USBClass(%x,%x,%x,%x,%x)", |
adae4313 RC |
131 | ucdp->vendor_id, ucdp->product_id, |
132 | ucdp->device_class, ucdp->device_subclass, | |
133 | ucdp->device_protocol); | |
134 | ||
135 | break; | |
136 | } | |
137 | case DEVICE_PATH_SUB_TYPE_MSG_SD: | |
138 | case DEVICE_PATH_SUB_TYPE_MSG_MMC: { | |
139 | const char *typename = | |
140 | (dp->sub_type == DEVICE_PATH_SUB_TYPE_MSG_SD) ? | |
6ea8b580 | 141 | "SD" : "eMMC"; |
adae4313 RC |
142 | struct efi_device_path_sd_mmc_path *sddp = |
143 | (struct efi_device_path_sd_mmc_path *)dp; | |
6ea8b580 | 144 | s += sprintf(s, "%s(%u)", typename, sddp->slot_number); |
adae4313 RC |
145 | break; |
146 | } | |
147 | default: | |
148 | s = dp_unknown(s, dp); | |
149 | break; | |
150 | } | |
151 | return s; | |
152 | } | |
153 | ||
6ea8b580 HS |
154 | /* |
155 | * Convert a media device path node to text. | |
156 | * | |
157 | * @s output buffer | |
158 | * @dp device path node | |
159 | * @return next unused buffer address | |
160 | */ | |
adae4313 RC |
161 | static char *dp_media(char *s, struct efi_device_path *dp) |
162 | { | |
163 | switch (dp->sub_type) { | |
164 | case DEVICE_PATH_SUB_TYPE_HARD_DRIVE_PATH: { | |
165 | struct efi_device_path_hard_drive_path *hddp = | |
166 | (struct efi_device_path_hard_drive_path *)dp; | |
167 | void *sig = hddp->partition_signature; | |
6ea8b580 HS |
168 | u64 start; |
169 | u64 end; | |
170 | ||
171 | /* Copy from packed structure to aligned memory */ | |
172 | memcpy(&start, &hddp->partition_start, sizeof(start)); | |
173 | memcpy(&end, &hddp->partition_end, sizeof(end)); | |
adae4313 RC |
174 | |
175 | switch (hddp->signature_type) { | |
6ea8b580 HS |
176 | case SIG_TYPE_MBR: { |
177 | u32 signature; | |
178 | ||
179 | memcpy(&signature, sig, sizeof(signature)); | |
180 | s += sprintf( | |
181 | s, "HD(%d,MBR,0x%08x,0x%llx,0x%llx)", | |
182 | hddp->partition_number, signature, start, end); | |
adae4313 | 183 | break; |
6ea8b580 | 184 | } |
adae4313 | 185 | case SIG_TYPE_GUID: |
6ea8b580 HS |
186 | s += sprintf( |
187 | s, "HD(%d,GPT,%pUl,0x%llx,0x%llx)", | |
188 | hddp->partition_number, sig, start, end); | |
1a0b4d22 | 189 | break; |
adae4313 | 190 | default: |
6ea8b580 HS |
191 | s += sprintf( |
192 | s, "HD(%d,0x%02x,0,0x%llx,0x%llx)", | |
193 | hddp->partition_number, hddp->partmap_type, | |
194 | start, end); | |
1a0b4d22 | 195 | break; |
adae4313 RC |
196 | } |
197 | ||
198 | break; | |
199 | } | |
200 | case DEVICE_PATH_SUB_TYPE_CDROM_PATH: { | |
201 | struct efi_device_path_cdrom_path *cddp = | |
202 | (struct efi_device_path_cdrom_path *)dp; | |
61aba193 | 203 | s += sprintf(s, "CDROM(0x%x)", cddp->boot_entry); |
adae4313 RC |
204 | break; |
205 | } | |
206 | case DEVICE_PATH_SUB_TYPE_FILE_PATH: { | |
207 | struct efi_device_path_file_path *fp = | |
208 | (struct efi_device_path_file_path *)dp; | |
209 | int slen = (dp->length - sizeof(*dp)) / 2; | |
61aba193 HS |
210 | if (slen > MAX_NODE_LEN - 2) |
211 | slen = MAX_NODE_LEN - 2; | |
212 | s += sprintf(s, "%-.*ls", slen, fp->str); | |
adae4313 RC |
213 | break; |
214 | } | |
215 | default: | |
216 | s = dp_unknown(s, dp); | |
217 | break; | |
218 | } | |
219 | return s; | |
220 | } | |
221 | ||
61aba193 HS |
222 | /* |
223 | * Converts a single node to a char string. | |
224 | * | |
225 | * @buffer output buffer | |
226 | * @dp device path or node | |
227 | * @return end of string | |
228 | */ | |
229 | static char *efi_convert_single_device_node_to_text( | |
230 | char *buffer, | |
231 | struct efi_device_path *dp) | |
cc5b7081 | 232 | { |
61aba193 | 233 | char *str = buffer; |
cc5b7081 | 234 | |
61aba193 HS |
235 | switch (dp->type) { |
236 | case DEVICE_PATH_TYPE_HARDWARE_DEVICE: | |
237 | str = dp_hardware(str, dp); | |
238 | break; | |
239 | case DEVICE_PATH_TYPE_ACPI_DEVICE: | |
240 | str = dp_acpi(str, dp); | |
241 | break; | |
242 | case DEVICE_PATH_TYPE_MESSAGING_DEVICE: | |
243 | str = dp_msging(str, dp); | |
244 | break; | |
245 | case DEVICE_PATH_TYPE_MEDIA_DEVICE: | |
246 | str = dp_media(str, dp); | |
247 | break; | |
3c950b31 HS |
248 | case DEVICE_PATH_TYPE_END: |
249 | break; | |
61aba193 HS |
250 | default: |
251 | str = dp_unknown(str, dp); | |
cc5b7081 | 252 | } |
253 | ||
61aba193 HS |
254 | *str = '\0'; |
255 | return str; | |
cc5b7081 | 256 | } |
257 | ||
c4574208 HS |
258 | /* |
259 | * This function implements the ConvertDeviceNodeToText service of the | |
260 | * EFI_DEVICE_PATH_TO_TEXT_PROTOCOL. | |
261 | * See the Unified Extensible Firmware Interface (UEFI) specification | |
262 | * for details. | |
263 | * | |
264 | * device_node device node to be converted | |
265 | * display_only true if the shorter text represenation shall be used | |
266 | * allow_shortcuts true if shortcut forms may be used | |
267 | * @return text represenation of the device path | |
268 | * NULL if out of memory of device_path is NULL | |
269 | */ | |
61aba193 | 270 | static uint16_t EFIAPI *efi_convert_device_node_to_text( |
9309a1b7 | 271 | struct efi_device_path *device_node, |
09c5ab90 | 272 | bool display_only, |
273 | bool allow_shortcuts) | |
274 | { | |
61aba193 HS |
275 | char str[MAX_NODE_LEN]; |
276 | uint16_t *text = NULL; | |
09c5ab90 | 277 | |
278 | EFI_ENTRY("%p, %d, %d", device_node, display_only, allow_shortcuts); | |
279 | ||
61aba193 HS |
280 | if (!device_node) |
281 | goto out; | |
282 | efi_convert_single_device_node_to_text(str, device_node); | |
283 | ||
284 | text = efi_str_to_u16(str); | |
09c5ab90 | 285 | |
61aba193 | 286 | out: |
09c5ab90 | 287 | EFI_EXIT(EFI_SUCCESS); |
61aba193 | 288 | return text; |
09c5ab90 | 289 | } |
290 | ||
c4574208 HS |
291 | /* |
292 | * This function implements the ConvertDevicePathToText service of the | |
293 | * EFI_DEVICE_PATH_TO_TEXT_PROTOCOL. | |
294 | * See the Unified Extensible Firmware Interface (UEFI) specification | |
295 | * for details. | |
296 | * | |
297 | * device_path device path to be converted | |
298 | * display_only true if the shorter text represenation shall be used | |
299 | * allow_shortcuts true if shortcut forms may be used | |
300 | * @return text represenation of the device path | |
301 | * NULL if out of memory of device_path is NULL | |
302 | */ | |
09c5ab90 | 303 | static uint16_t EFIAPI *efi_convert_device_path_to_text( |
9309a1b7 | 304 | struct efi_device_path *device_path, |
09c5ab90 | 305 | bool display_only, |
306 | bool allow_shortcuts) | |
307 | { | |
61aba193 HS |
308 | uint16_t *text = NULL; |
309 | char buffer[MAX_PATH_LEN]; | |
310 | char *str = buffer; | |
09c5ab90 | 311 | |
312 | EFI_ENTRY("%p, %d, %d", device_path, display_only, allow_shortcuts); | |
313 | ||
61aba193 HS |
314 | if (!device_path) |
315 | goto out; | |
316 | while (device_path && | |
317 | str + MAX_NODE_LEN < buffer + MAX_PATH_LEN) { | |
318 | *str++ = '/'; | |
319 | str = efi_convert_single_device_node_to_text(str, device_path); | |
320 | device_path = efi_dp_next(device_path); | |
321 | } | |
322 | ||
323 | text = efi_str_to_u16(buffer); | |
09c5ab90 | 324 | |
61aba193 | 325 | out: |
09c5ab90 | 326 | EFI_EXIT(EFI_SUCCESS); |
61aba193 | 327 | return text; |
09c5ab90 | 328 | } |
329 | ||
908cf9a3 HS |
330 | /* helper for debug prints.. efi_free_pool() the result. */ |
331 | uint16_t *efi_dp_str(struct efi_device_path *dp) | |
332 | { | |
333 | return EFI_CALL(efi_convert_device_path_to_text(dp, true, true)); | |
334 | } | |
335 | ||
cc5b7081 | 336 | const struct efi_device_path_to_text_protocol efi_device_path_to_text = { |
61aba193 | 337 | .convert_device_node_to_text = efi_convert_device_node_to_text, |
cc5b7081 | 338 | .convert_device_path_to_text = efi_convert_device_path_to_text, |
339 | }; |