BmBootDescription.c@ 80721

Last change on this file since 80721 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 26.5 KB

Line
1	/** @file
2	Library functions which relate with boot option description.
3
4	Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
5	(C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include "InternalBm.h"
11
12	#define VENDOR_IDENTIFICATION_OFFSET 3
13	#define VENDOR_IDENTIFICATION_LENGTH 8
14	#define PRODUCT_IDENTIFICATION_OFFSET 11
15	#define PRODUCT_IDENTIFICATION_LENGTH 16
16
17	CONST UINT16 mBmUsbLangId = 0x0409; // English
18	CHAR16 mBmUefiPrefix[] = L"UEFI ";
19
20	LIST_ENTRY mPlatformBootDescriptionHandlers = INITIALIZE_LIST_HEAD_VARIABLE (mPlatformBootDescriptionHandlers);
21
22	/**
23	For a bootable Device path, return its boot type.
24
25	@param DevicePath The bootable device Path to check
26
27	@retval AcpiFloppyBoot If given device path contains ACPI_DEVICE_PATH type device path node
28	which HID is floppy device.
29	@retval MessageAtapiBoot If given device path contains MESSAGING_DEVICE_PATH type device path node
30	and its last device path node's subtype is MSG_ATAPI_DP.
31	@retval MessageSataBoot If given device path contains MESSAGING_DEVICE_PATH type device path node
32	and its last device path node's subtype is MSG_SATA_DP.
33	@retval MessageScsiBoot If given device path contains MESSAGING_DEVICE_PATH type device path node
34	and its last device path node's subtype is MSG_SCSI_DP.
35	@retval MessageUsbBoot If given device path contains MESSAGING_DEVICE_PATH type device path node
36	and its last device path node's subtype is MSG_USB_DP.
37	@retval BmMiscBoot If tiven device path doesn't match the above condition.
38
39	**/
40	BM_BOOT_TYPE
41	BmDevicePathType (
42	IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
43	)
44	{
45	EFI_DEVICE_PATH_PROTOCOL *Node;
46	EFI_DEVICE_PATH_PROTOCOL *NextNode;
47
48	ASSERT (DevicePath != NULL);
49
50	for (Node = DevicePath; !IsDevicePathEndType (Node); Node = NextDevicePathNode (Node)) {
51	switch (DevicePathType (Node)) {
52
53	case ACPI_DEVICE_PATH:
54	if (EISA_ID_TO_NUM (((ACPI_HID_DEVICE_PATH *) Node)->HID) == 0x0604) {
55	return BmAcpiFloppyBoot;
56	}
57	break;
58
59	case HARDWARE_DEVICE_PATH:
60	if (DevicePathSubType (Node) == HW_CONTROLLER_DP) {
61	return BmHardwareDeviceBoot;
62	}
63	break;
64
65	case MESSAGING_DEVICE_PATH:
66	//
67	// Skip LUN device node
68	//
69	NextNode = Node;
70	do {
71	NextNode = NextDevicePathNode (NextNode);
72	} while (
73	(DevicePathType (NextNode) == MESSAGING_DEVICE_PATH) &&
74	(DevicePathSubType(NextNode) == MSG_DEVICE_LOGICAL_UNIT_DP)
75	);
76
77	//
78	// If the device path not only point to driver device, it is not a messaging device path,
79	//
80	if (!IsDevicePathEndType (NextNode)) {
81	continue;
82	}
83
84	switch (DevicePathSubType (Node)) {
85	case MSG_ATAPI_DP:
86	return BmMessageAtapiBoot;
87	break;
88
89	case MSG_SATA_DP:
90	return BmMessageSataBoot;
91	break;
92
93	case MSG_USB_DP:
94	return BmMessageUsbBoot;
95	break;
96
97	case MSG_SCSI_DP:
98	return BmMessageScsiBoot;
99	break;
100	}
101	}
102	}
103
104	return BmMiscBoot;
105	}
106
107	/**
108	Eliminate the extra spaces in the Str to one space.
109
110	@param Str Input string info.
111	**/
112	VOID
113	BmEliminateExtraSpaces (
114	IN CHAR16 *Str
115	)
116	{
117	UINTN Index;
118	UINTN ActualIndex;
119
120	for (Index = 0, ActualIndex = 0; Str[Index] != L'\0'; Index++) {
121	if ((Str[Index] != L' ') \|\| ((ActualIndex > 0) && (Str[ActualIndex - 1] != L' '))) {
122	Str[ActualIndex++] = Str[Index];
123	}
124	}
125	Str[ActualIndex] = L'\0';
126	}
127
128	/**
129	Try to get the controller's ATA/ATAPI description.
130
131	@param Handle Controller handle.
132
133	@return The description string.
134	**/
135	CHAR16 *
136	BmGetDescriptionFromDiskInfo (
137	IN EFI_HANDLE Handle
138	)
139	{
140	UINTN Index;
141	EFI_STATUS Status;
142	EFI_DISK_INFO_PROTOCOL *DiskInfo;
143	UINT32 BufferSize;
144	EFI_ATAPI_IDENTIFY_DATA IdentifyData;
145	EFI_SCSI_INQUIRY_DATA InquiryData;
146	CHAR16 *Description;
147	UINTN Length;
148	CONST UINTN ModelNameLength = 40;
149	CONST UINTN SerialNumberLength = 20;
150	CHAR8 *StrPtr;
151	UINT8 Temp;
152	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
153
154	Description = NULL;
155
156	Status = gBS->HandleProtocol (
157	Handle,
158	&gEfiDiskInfoProtocolGuid,
159	(VOID **) &DiskInfo
160	);
161	if (EFI_ERROR (Status)) {
162	return NULL;
163	}
164
165	if (CompareGuid (&DiskInfo->Interface, &gEfiDiskInfoAhciInterfaceGuid) \|\|
166	CompareGuid (&DiskInfo->Interface, &gEfiDiskInfoIdeInterfaceGuid)) {
167	BufferSize = sizeof (EFI_ATAPI_IDENTIFY_DATA);
168	Status = DiskInfo->Identify (
169	DiskInfo,
170	&IdentifyData,
171	&BufferSize
172	);
173	if (!EFI_ERROR (Status)) {
174	Description = AllocateZeroPool ((ModelNameLength + SerialNumberLength + 2) * sizeof (CHAR16));
175	ASSERT (Description != NULL);
176	for (Index = 0; Index + 1 < ModelNameLength; Index += 2) {
177	Description[Index] = (CHAR16) IdentifyData.ModelName[Index + 1];
178	Description[Index + 1] = (CHAR16) IdentifyData.ModelName[Index];
179	}
180
181	Length = Index;
182	Description[Length++] = L' ';
183
184	for (Index = 0; Index + 1 < SerialNumberLength; Index += 2) {
185	Description[Length + Index] = (CHAR16) IdentifyData.SerialNo[Index + 1];
186	Description[Length + Index + 1] = (CHAR16) IdentifyData.SerialNo[Index];
187	}
188	Length += Index;
189	Description[Length++] = L'\0';
190	ASSERT (Length == ModelNameLength + SerialNumberLength + 2);
191
192	BmEliminateExtraSpaces (Description);
193	}
194	} else if (CompareGuid (&DiskInfo->Interface, &gEfiDiskInfoScsiInterfaceGuid)) {
195	BufferSize = sizeof (EFI_SCSI_INQUIRY_DATA);
196	Status = DiskInfo->Inquiry (
197	DiskInfo,
198	&InquiryData,
199	&BufferSize
200	);
201	if (!EFI_ERROR (Status)) {
202	Description = AllocateZeroPool ((VENDOR_IDENTIFICATION_LENGTH + PRODUCT_IDENTIFICATION_LENGTH + 2) * sizeof (CHAR16));
203	ASSERT (Description != NULL);
204
205	//
206	// Per SCSI spec, EFI_SCSI_INQUIRY_DATA.Reserved_5_95[3 - 10] save the Verdor identification
207	// EFI_SCSI_INQUIRY_DATA.Reserved_5_95[11 - 26] save the product identification,
208	// Here combine the vendor identification and product identification to the description.
209	//
210	StrPtr = (CHAR8 *) (&InquiryData.Reserved_5_95[VENDOR_IDENTIFICATION_OFFSET]);
211	Temp = StrPtr[VENDOR_IDENTIFICATION_LENGTH];
212	StrPtr[VENDOR_IDENTIFICATION_LENGTH] = '\0';
213	AsciiStrToUnicodeStrS (StrPtr, Description, VENDOR_IDENTIFICATION_LENGTH + 1);
214	StrPtr[VENDOR_IDENTIFICATION_LENGTH] = Temp;
215
216	//
217	// Add one space at the middle of vendor information and product information.
218	//
219	Description[VENDOR_IDENTIFICATION_LENGTH] = L' ';
220
221	StrPtr = (CHAR8 *) (&InquiryData.Reserved_5_95[PRODUCT_IDENTIFICATION_OFFSET]);
222	StrPtr[PRODUCT_IDENTIFICATION_LENGTH] = '\0';
223	AsciiStrToUnicodeStrS (StrPtr, Description + VENDOR_IDENTIFICATION_LENGTH + 1, PRODUCT_IDENTIFICATION_LENGTH + 1);
224
225	BmEliminateExtraSpaces (Description);
226	}
227	} else if (CompareGuid (&DiskInfo->Interface, &gEfiDiskInfoSdMmcInterfaceGuid)) {
228	DevicePath = DevicePathFromHandle (Handle);
229	if (DevicePath == NULL) {
230	return NULL;
231	}
232
233	while (!IsDevicePathEnd (DevicePath) && (DevicePathType (DevicePath) != MESSAGING_DEVICE_PATH)) {
234	DevicePath = NextDevicePathNode (DevicePath);
235	}
236	if (IsDevicePathEnd (DevicePath)) {
237	return NULL;
238	}
239
240	if (DevicePathSubType (DevicePath) == MSG_SD_DP) {
241	Description = L"SD Device";
242	} else if (DevicePathSubType (DevicePath) == MSG_EMMC_DP) {
243	Description = L"eMMC Device";
244	} else {
245	return NULL;
246	}
247
248	Description = AllocateCopyPool (StrSize (Description), Description);
249	}
250
251	return Description;
252	}
253
254	/**
255	Try to get the controller's USB description.
256
257	@param Handle Controller handle.
258
259	@return The description string.
260	**/
261	CHAR16 *
262	BmGetUsbDescription (
263	IN EFI_HANDLE Handle
264	)
265	{
266	EFI_STATUS Status;
267	EFI_USB_IO_PROTOCOL *UsbIo;
268	CHAR16 NullChar;
269	CHAR16 *Manufacturer;
270	CHAR16 *Product;
271	CHAR16 *SerialNumber;
272	CHAR16 *Description;
273	EFI_USB_DEVICE_DESCRIPTOR DevDesc;
274	UINTN DescMaxSize;
275
276	Status = gBS->HandleProtocol (
277	Handle,
278	&gEfiUsbIoProtocolGuid,
279	(VOID **) &UsbIo
280	);
281	if (EFI_ERROR (Status)) {
282	return NULL;
283	}
284
285	NullChar = L'\0';
286
287	Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);
288	if (EFI_ERROR (Status)) {
289	return NULL;
290	}
291
292	Status = UsbIo->UsbGetStringDescriptor (
293	UsbIo,
294	mBmUsbLangId,
295	DevDesc.StrManufacturer,
296	&Manufacturer
297	);
298	if (EFI_ERROR (Status)) {
299	Manufacturer = &NullChar;
300	}
301
302	Status = UsbIo->UsbGetStringDescriptor (
303	UsbIo,
304	mBmUsbLangId,
305	DevDesc.StrProduct,
306	&Product
307	);
308	if (EFI_ERROR (Status)) {
309	Product = &NullChar;
310	}
311
312	Status = UsbIo->UsbGetStringDescriptor (
313	UsbIo,
314	mBmUsbLangId,
315	DevDesc.StrSerialNumber,
316	&SerialNumber
317	);
318	if (EFI_ERROR (Status)) {
319	SerialNumber = &NullChar;
320	}
321
322	if ((Manufacturer == &NullChar) &&
323	(Product == &NullChar) &&
324	(SerialNumber == &NullChar)
325	) {
326	return NULL;
327	}
328
329	DescMaxSize = StrSize (Manufacturer) + StrSize (Product) + StrSize (SerialNumber);
330	Description = AllocateZeroPool (DescMaxSize);
331	ASSERT (Description != NULL);
332	StrCatS (Description, DescMaxSize/sizeof(CHAR16), Manufacturer);
333	StrCatS (Description, DescMaxSize/sizeof(CHAR16), L" ");
334
335	StrCatS (Description, DescMaxSize/sizeof(CHAR16), Product);
336	StrCatS (Description, DescMaxSize/sizeof(CHAR16), L" ");
337
338	StrCatS (Description, DescMaxSize/sizeof(CHAR16), SerialNumber);
339
340	if (Manufacturer != &NullChar) {
341	FreePool (Manufacturer);
342	}
343	if (Product != &NullChar) {
344	FreePool (Product);
345	}
346	if (SerialNumber != &NullChar) {
347	FreePool (SerialNumber);
348	}
349
350	BmEliminateExtraSpaces (Description);
351
352	return Description;
353	}
354
355	/**
356	Return the description for network boot device.
357
358	@param Handle Controller handle.
359
360	@return The description string.
361	**/
362	CHAR16 *
363	BmGetNetworkDescription (
364	IN EFI_HANDLE Handle
365	)
366	{
367	EFI_STATUS Status;
368	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
369	MAC_ADDR_DEVICE_PATH *Mac;
370	VLAN_DEVICE_PATH *Vlan;
371	EFI_DEVICE_PATH_PROTOCOL *Ip;
372	EFI_DEVICE_PATH_PROTOCOL *Uri;
373	CHAR16 *Description;
374	UINTN DescriptionSize;
375
376	Status = gBS->OpenProtocol (
377	Handle,
378	&gEfiLoadFileProtocolGuid,
379	NULL,
380	gImageHandle,
381	Handle,
382	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
383	);
384	if (EFI_ERROR (Status)) {
385	return NULL;
386	}
387
388	Status = gBS->OpenProtocol (
389	Handle,
390	&gEfiDevicePathProtocolGuid,
391	(VOID **) &DevicePath,
392	gImageHandle,
393	Handle,
394	EFI_OPEN_PROTOCOL_GET_PROTOCOL
395	);
396	if (EFI_ERROR (Status) \|\| (DevicePath == NULL)) {
397	return NULL;
398	}
399
400	//
401	// The PXE device path is like:
402	// ....../Mac(...)[/Vlan(...)][/Wi-Fi(...)]
403	// ....../Mac(...)[/Vlan(...)][/Wi-Fi(...)]/IPv4(...)
404	// ....../Mac(...)[/Vlan(...)][/Wi-Fi(...)]/IPv6(...)
405	//
406	// The HTTP device path is like:
407	// ....../Mac(...)[/Vlan(...)][/Wi-Fi(...)]/IPv4(...)[/Dns(...)]/Uri(...)
408	// ....../Mac(...)[/Vlan(...)][/Wi-Fi(...)]/IPv6(...)[/Dns(...)]/Uri(...)
409	//
410	while (!IsDevicePathEnd (DevicePath) &&
411	((DevicePathType (DevicePath) != MESSAGING_DEVICE_PATH) \|\|
412	(DevicePathSubType (DevicePath) != MSG_MAC_ADDR_DP))
413	) {
414	DevicePath = NextDevicePathNode (DevicePath);
415	}
416
417	if (IsDevicePathEnd (DevicePath)) {
418	return NULL;
419	}
420
421	Mac = (MAC_ADDR_DEVICE_PATH *) DevicePath;
422	DevicePath = NextDevicePathNode (DevicePath);
423
424	//
425	// Locate the optional Vlan node
426	//
427	if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
428	(DevicePathSubType (DevicePath) == MSG_VLAN_DP)
429	) {
430	Vlan = (VLAN_DEVICE_PATH *) DevicePath;
431	DevicePath = NextDevicePathNode (DevicePath);
432	} else {
433	Vlan = NULL;
434	}
435
436	//
437	// Skip the optional Wi-Fi node
438	//
439	if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
440	(DevicePathSubType (DevicePath) == MSG_WIFI_DP)
441	) {
442	DevicePath = NextDevicePathNode (DevicePath);
443	}
444
445	//
446	// Locate the IP node
447	//
448	if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
449	((DevicePathSubType (DevicePath) == MSG_IPv4_DP) \|\|
450	(DevicePathSubType (DevicePath) == MSG_IPv6_DP))
451	) {
452	Ip = DevicePath;
453	DevicePath = NextDevicePathNode (DevicePath);
454	} else {
455	Ip = NULL;
456	}
457
458	//
459	// Skip the optional DNS node
460	//
461	if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
462	(DevicePathSubType (DevicePath) == MSG_DNS_DP)
463	) {
464	DevicePath = NextDevicePathNode (DevicePath);
465	}
466
467	//
468	// Locate the URI node
469	//
470	if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
471	(DevicePathSubType (DevicePath) == MSG_URI_DP)
472	) {
473	Uri = DevicePath;
474	DevicePath = NextDevicePathNode (DevicePath);
475	} else {
476	Uri = NULL;
477	}
478
479	//
480	// Build description like below:
481	// "PXEv6 (MAC:112233445566 VLAN1)"
482	// "HTTPv4 (MAC:112233445566)"
483	//
484	DescriptionSize = sizeof (L"HTTPv6 (MAC:112233445566 VLAN65535)");
485	Description = AllocatePool (DescriptionSize);
486	ASSERT (Description != NULL);
487	UnicodeSPrint (
488	Description, DescriptionSize,
489	(Vlan == NULL) ?
490	L"%sv%d (MAC:%02x%02x%02x%02x%02x%02x)" :
491	L"%sv%d (MAC:%02x%02x%02x%02x%02x%02x VLAN%d)",
492	(Uri == NULL) ? L"PXE" : L"HTTP",
493	((Ip == NULL) \|\| (DevicePathSubType (Ip) == MSG_IPv4_DP)) ? 4 : 6,
494	Mac->MacAddress.Addr[0], Mac->MacAddress.Addr[1], Mac->MacAddress.Addr[2],
495	Mac->MacAddress.Addr[3], Mac->MacAddress.Addr[4], Mac->MacAddress.Addr[5],
496	(Vlan == NULL) ? 0 : Vlan->VlanId
497	);
498	return Description;
499	}
500
501	/**
502	Return the boot description for LoadFile
503
504	@param Handle Controller handle.
505
506	@return The description string.
507	**/
508	CHAR16 *
509	BmGetLoadFileDescription (
510	IN EFI_HANDLE Handle
511	)
512	{
513	EFI_STATUS Status;
514	EFI_DEVICE_PATH_PROTOCOL *FilePath;
515	EFI_DEVICE_PATH_PROTOCOL *DevicePathNode;
516	CHAR16 *Description;
517	EFI_LOAD_FILE_PROTOCOL *LoadFile;
518
519	Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID **)&LoadFile);
520	if (EFI_ERROR (Status)) {
521	return NULL;
522	}
523
524	//
525	// Get the file name
526	//
527	Description = NULL;
528	Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&FilePath);
529	if (!EFI_ERROR (Status)) {
530	DevicePathNode = FilePath;
531	while (!IsDevicePathEnd (DevicePathNode)) {
532	if (DevicePathNode->Type == MEDIA_DEVICE_PATH && DevicePathNode->SubType == MEDIA_FILEPATH_DP) {
533	Description = (CHAR16 *)(DevicePathNode + 1);
534	break;
535	}
536	DevicePathNode = NextDevicePathNode (DevicePathNode);
537	}
538	}
539
540	if (Description != NULL) {
541	return AllocateCopyPool (StrSize (Description), Description);
542	}
543
544	return NULL;
545	}
546
547	/**
548	Return the boot description for NVME boot device.
549
550	@param Handle Controller handle.
551
552	@return The description string.
553	**/
554	CHAR16 *
555	BmGetNvmeDescription (
556	IN EFI_HANDLE Handle
557	)
558	{
559	EFI_STATUS Status;
560	EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL *NvmePassthru;
561	EFI_DEV_PATH_PTR DevicePath;
562	EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET CommandPacket;
563	EFI_NVM_EXPRESS_COMMAND Command;
564	EFI_NVM_EXPRESS_COMPLETION Completion;
565	NVME_ADMIN_CONTROLLER_DATA ControllerData;
566	CHAR16 *Description;
567	CHAR16 *Char;
568	UINTN Index;
569
570	Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePath.DevPath);
571	if (EFI_ERROR (Status)) {
572	return NULL;
573	}
574
575	Status = gBS->LocateDevicePath (&gEfiNvmExpressPassThruProtocolGuid, &DevicePath.DevPath, &Handle);
576	if (EFI_ERROR (Status) \|\|
577	(DevicePathType (DevicePath.DevPath) != MESSAGING_DEVICE_PATH) \|\|
578	(DevicePathSubType (DevicePath.DevPath) != MSG_NVME_NAMESPACE_DP)) {
579	//
580	// Do not return description when the Handle is not a child of NVME controller.
581	//
582	return NULL;
583	}
584
585	//
586	// Send ADMIN_IDENTIFY command to NVME controller to get the model and serial number.
587	//
588	Status = gBS->HandleProtocol (Handle, &gEfiNvmExpressPassThruProtocolGuid, (VOID **) &NvmePassthru);
589	ASSERT_EFI_ERROR (Status);
590
591	ZeroMem (&CommandPacket, sizeof(EFI_NVM_EXPRESS_PASS_THRU_COMMAND_PACKET));
592	ZeroMem (&Command, sizeof(EFI_NVM_EXPRESS_COMMAND));
593	ZeroMem (&Completion, sizeof(EFI_NVM_EXPRESS_COMPLETION));
594
595	Command.Cdw0.Opcode = NVME_ADMIN_IDENTIFY_CMD;
596	//
597	// According to Nvm Express 1.1 spec Figure 38, When not used, the field shall be cleared to 0h.
598	// For the Identify command, the Namespace Identifier is only used for the Namespace data structure.
599	//
600	Command.Nsid = 0;
601	CommandPacket.NvmeCmd = &Command;
602	CommandPacket.NvmeCompletion = &Completion;
603	CommandPacket.TransferBuffer = &ControllerData;
604	CommandPacket.TransferLength = sizeof (ControllerData);
605	CommandPacket.CommandTimeout = EFI_TIMER_PERIOD_SECONDS (5);
606	CommandPacket.QueueType = NVME_ADMIN_QUEUE;
607	//
608	// Set bit 0 (Cns bit) to 1 to identify a controller
609	//
610	Command.Cdw10 = 1;
611	Command.Flags = CDW10_VALID;
612
613	Status = NvmePassthru->PassThru (
614	NvmePassthru,
615	0,
616	&CommandPacket,
617	NULL
618	);
619	if (EFI_ERROR (Status)) {
620	return NULL;
621	}
622
623	Description = AllocateZeroPool (
624	(ARRAY_SIZE (ControllerData.Mn) + 1
625	+ ARRAY_SIZE (ControllerData.Sn) + 1
626	+ MAXIMUM_VALUE_CHARACTERS + 1
627	) * sizeof (CHAR16));
628	if (Description != NULL) {
629	Char = Description;
630	for (Index = 0; Index < ARRAY_SIZE (ControllerData.Mn); Index++) {
631	*(Char++) = (CHAR16) ControllerData.Mn[Index];
632	}
633	*(Char++) = L' ';
634	for (Index = 0; Index < ARRAY_SIZE (ControllerData.Sn); Index++) {
635	*(Char++) = (CHAR16) ControllerData.Sn[Index];
636	}
637	*(Char++) = L' ';
638	UnicodeValueToStringS (
639	Char, sizeof (CHAR16) * (MAXIMUM_VALUE_CHARACTERS + 1),
640	0, DevicePath.NvmeNamespace->NamespaceId, 0
641	);
642	BmEliminateExtraSpaces (Description);
643	}
644
645	return Description;
646	}
647
648	/**
649	Return the boot description for the controller based on the type.
650
651	@param Handle Controller handle.
652
653	@return The description string.
654	**/
655	CHAR16 *
656	BmGetMiscDescription (
657	IN EFI_HANDLE Handle
658	)
659	{
660	EFI_STATUS Status;
661	CHAR16 *Description;
662	EFI_BLOCK_IO_PROTOCOL *BlockIo;
663	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Fs;
664
665	switch (BmDevicePathType (DevicePathFromHandle (Handle))) {
666	case BmAcpiFloppyBoot:
667	Description = L"Floppy";
668	break;
669
670	case BmMessageAtapiBoot:
671	case BmMessageSataBoot:
672	Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
673	ASSERT_EFI_ERROR (Status);
674	//
675	// Assume a removable SATA device should be the DVD/CD device
676	//
677	Description = BlockIo->Media->RemovableMedia ? L"DVD/CDROM" : L"Hard Drive";
678	break;
679
680	case BmMessageUsbBoot:
681	Description = L"USB Device";
682	break;
683
684	case BmMessageScsiBoot:
685	Description = L"SCSI Device";
686	break;
687
688	case BmHardwareDeviceBoot:
689	Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
690	if (!EFI_ERROR (Status)) {
691	Description = BlockIo->Media->RemovableMedia ? L"Removable Disk" : L"Hard Drive";
692	} else {
693	Description = L"Misc Device";
694	}
695	break;
696
697	default:
698	Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID **) &Fs);
699	if (!EFI_ERROR (Status)) {
700	Description = L"Non-Block Boot Device";
701	} else {
702	Description = L"Misc Device";
703	}
704	break;
705	}
706
707	return AllocateCopyPool (StrSize (Description), Description);
708	}
709
710	/**
711	Register the platform provided boot description handler.
712
713	@param Handler The platform provided boot description handler
714
715	@retval EFI_SUCCESS The handler was registered successfully.
716	@retval EFI_ALREADY_STARTED The handler was already registered.
717	@retval EFI_OUT_OF_RESOURCES There is not enough resource to perform the registration.
718	**/
719	EFI_STATUS
720	EFIAPI
721	EfiBootManagerRegisterBootDescriptionHandler (
722	IN EFI_BOOT_MANAGER_BOOT_DESCRIPTION_HANDLER Handler
723	)
724	{
725	LIST_ENTRY *Link;
726	BM_BOOT_DESCRIPTION_ENTRY *Entry;
727
728	for ( Link = GetFirstNode (&mPlatformBootDescriptionHandlers)
729	; !IsNull (&mPlatformBootDescriptionHandlers, Link)
730	; Link = GetNextNode (&mPlatformBootDescriptionHandlers, Link)
731	) {
732	Entry = CR (Link, BM_BOOT_DESCRIPTION_ENTRY, Link, BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE);
733	if (Entry->Handler == Handler) {
734	return EFI_ALREADY_STARTED;
735	}
736	}
737
738	Entry = AllocatePool (sizeof (BM_BOOT_DESCRIPTION_ENTRY));
739	if (Entry == NULL) {
740	return EFI_OUT_OF_RESOURCES;
741	}
742
743	Entry->Signature = BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE;
744	Entry->Handler = Handler;
745	InsertTailList (&mPlatformBootDescriptionHandlers, &Entry->Link);
746	return EFI_SUCCESS;
747	}
748
749	BM_GET_BOOT_DESCRIPTION mBmBootDescriptionHandlers[] = {
750	BmGetUsbDescription,
751	BmGetDescriptionFromDiskInfo,
752	BmGetNetworkDescription,
753	BmGetLoadFileDescription,
754	BmGetNvmeDescription,
755	BmGetMiscDescription
756	};
757
758	/**
759	Return the boot description for the controller.
760
761	@param Handle Controller handle.
762
763	@return The description string.
764	**/
765	CHAR16 *
766	BmGetBootDescription (
767	IN EFI_HANDLE Handle
768	)
769	{
770	LIST_ENTRY *Link;
771	BM_BOOT_DESCRIPTION_ENTRY *Entry;
772	CHAR16 *Description;
773	CHAR16 *DefaultDescription;
774	CHAR16 *Temp;
775	UINTN Index;
776
777	//
778	// Firstly get the default boot description
779	//
780	DefaultDescription = NULL;
781	for (Index = 0; Index < ARRAY_SIZE (mBmBootDescriptionHandlers); Index++) {
782	DefaultDescription = mBmBootDescriptionHandlers[Index] (Handle);
783	if (DefaultDescription != NULL) {
784	//
785	// Avoid description confusion between UEFI & Legacy boot option by adding "UEFI " prefix
786	// ONLY for core provided boot description handler.
787	//
788	Temp = AllocatePool (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix));
789	ASSERT (Temp != NULL);
790	StrCpyS (Temp, (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix)) / sizeof (CHAR16), mBmUefiPrefix);
791	StrCatS (Temp, (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix)) / sizeof (CHAR16), DefaultDescription);
792	FreePool (DefaultDescription);
793	DefaultDescription = Temp;
794	break;
795	}
796	}
797	ASSERT (DefaultDescription != NULL);
798
799	//
800	// Secondly query platform for the better boot description
801	//
802	for ( Link = GetFirstNode (&mPlatformBootDescriptionHandlers)
803	; !IsNull (&mPlatformBootDescriptionHandlers, Link)
804	; Link = GetNextNode (&mPlatformBootDescriptionHandlers, Link)
805	) {
806	Entry = CR (Link, BM_BOOT_DESCRIPTION_ENTRY, Link, BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE);
807	Description = Entry->Handler (Handle, DefaultDescription);
808	if (Description != NULL) {
809	FreePool (DefaultDescription);
810	return Description;
811	}
812	}
813
814	return DefaultDescription;
815	}
816
817	/**
818	Enumerate all boot option descriptions and append " 2"/" 3"/... to make
819	unique description.
820
821	@param BootOptions Array of boot options.
822	@param BootOptionCount Count of boot options.
823	**/
824	VOID
825	BmMakeBootOptionDescriptionUnique (
826	EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions,
827	UINTN BootOptionCount
828	)
829	{
830	UINTN Base;
831	UINTN Index;
832	UINTN DescriptionSize;
833	UINTN MaxSuffixSize;
834	BOOLEAN *Visited;
835	UINTN MatchCount;
836
837	if (BootOptionCount == 0) {
838	return;
839	}
840
841	//
842	// Calculate the maximum buffer size for the number suffix.
843	// The initial sizeof (CHAR16) is for the blank space before the number.
844	//
845	MaxSuffixSize = sizeof (CHAR16);
846	for (Index = BootOptionCount; Index != 0; Index = Index / 10) {
847	MaxSuffixSize += sizeof (CHAR16);
848	}
849
850	Visited = AllocateZeroPool (sizeof (BOOLEAN) * BootOptionCount);
851	ASSERT (Visited != NULL);
852
853	for (Base = 0; Base < BootOptionCount; Base++) {
854	if (!Visited[Base]) {
855	MatchCount = 1;
856	Visited[Base] = TRUE;
857	DescriptionSize = StrSize (BootOptions[Base].Description);
858	for (Index = Base + 1; Index < BootOptionCount; Index++) {
859	if (!Visited[Index] && StrCmp (BootOptions[Base].Description, BootOptions[Index].Description) == 0) {
860	Visited[Index] = TRUE;
861	MatchCount++;
862	FreePool (BootOptions[Index].Description);
863	BootOptions[Index].Description = AllocatePool (DescriptionSize + MaxSuffixSize);
864	UnicodeSPrint (
865	BootOptions[Index].Description, DescriptionSize + MaxSuffixSize,
866	L"%s %d",
867	BootOptions[Base].Description, MatchCount
868	);
869	}
870	}
871	}
872	}
873
874	FreePool (Visited);
875	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/UefiBootManagerLib/BmBootDescription.c@ 80721

Download in other formats: