CapsuleApp.c@ 89977

最後變更在這個檔案從89977是 85718,由 vboxsync 提交於 5 年前
Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
屬性 svn:eol-style 設為 `native`
檔案大小: 30.4 KB

行
1	/** @file
2	A shell application that triggers capsule update process.
3
4	Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR>
5	SPDX-License-Identifier: BSD-2-Clause-Patent
6
7	**/
8
9	#include "CapsuleApp.h"
10
11	//
12	// Define how many block descriptors we want to test with.
13	//
14	UINTN NumberOfDescriptors = 1;
15	UINTN CapsuleFirstIndex;
16	UINTN CapsuleLastIndex;
17
18	/**
19	Create UX capsule.
20
21	@retval EFI_SUCCESS The capsule header is appended.
22	@retval EFI_UNSUPPORTED Input parameter is not valid.
23	@retval EFI_OUT_OF_RESOURCES No enough resource to create UX capsule.
24	**/
25	EFI_STATUS
26	CreateBmpFmp (
27	VOID
28	)
29	{
30	CHAR16 *OutputCapsuleName;
31	VOID *BmpBuffer;
32	UINTN FileSize;
33	CHAR16 *BmpName;
34	UINT8 *FullCapsuleBuffer;
35	UINTN FullCapsuleBufferSize;
36	EFI_DISPLAY_CAPSULE *DisplayCapsule;
37	EFI_STATUS Status;
38	EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop;
39	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
40	EFI_GRAPHICS_OUTPUT_BLT_PIXEL *GopBlt;
41	UINTN GopBltSize;
42	UINTN Height;
43	UINTN Width;
44
45	Status = gBS->LocateProtocol(&gEfiGraphicsOutputProtocolGuid, NULL, (VOID **)&Gop);
46	if (EFI_ERROR(Status)) {
47	Print(L"CapsuleApp: NO GOP is found.\n");
48	return EFI_UNSUPPORTED;
49	}
50	Info = Gop->Mode->Info;
51	Print(L"Current GOP: Mode - %d, ", Gop->Mode->Mode);
52	Print(L"HorizontalResolution - %d, ", Info->HorizontalResolution);
53	Print(L"VerticalResolution - %d\n", Info->VerticalResolution);
54	// HorizontalResolution >= BMP_IMAGE_HEADER.PixelWidth
55	// VerticalResolution >= BMP_IMAGE_HEADER.PixelHeight
56
57	if (Argc != 5) {
58	Print(L"CapsuleApp: Incorrect parameter count.\n");
59	return EFI_UNSUPPORTED;
60	}
61
62	if (StrCmp(Argv[3], L"-O") != 0) {
63	Print(L"CapsuleApp: NO output capsule name.\n");
64	return EFI_UNSUPPORTED;
65	}
66	OutputCapsuleName = Argv[4];
67
68	BmpBuffer = NULL;
69	FileSize = 0;
70	FullCapsuleBuffer = NULL;
71
72	BmpName = Argv[2];
73	Status = ReadFileToBuffer(BmpName, &FileSize, &BmpBuffer);
74	if (EFI_ERROR(Status)) {
75	Print(L"CapsuleApp: BMP image (%s) is not found.\n", BmpName);
76	goto Done;
77	}
78
79	GopBlt = NULL;
80	Status = TranslateBmpToGopBlt (
81	BmpBuffer,
82	FileSize,
83	&GopBlt,
84	&GopBltSize,
85	&Height,
86	&Width
87	);
88	if (EFI_ERROR(Status)) {
89	Print(L"CapsuleApp: BMP image (%s) is not valid.\n", BmpName);
90	goto Done;
91	}
92	if (GopBlt != NULL) {
93	FreePool (GopBlt);
94	}
95	Print(L"BMP image (%s), Width - %d, Height - %d\n", BmpName, Width, Height);
96
97	if (Height > Info->VerticalResolution) {
98	Status = EFI_INVALID_PARAMETER;
99	Print(L"CapsuleApp: BMP image (%s) height is larger than current resolution.\n", BmpName);
100	goto Done;
101	}
102	if (Width > Info->HorizontalResolution) {
103	Status = EFI_INVALID_PARAMETER;
104	Print(L"CapsuleApp: BMP image (%s) width is larger than current resolution.\n", BmpName);
105	goto Done;
106	}
107
108	FullCapsuleBufferSize = sizeof(EFI_DISPLAY_CAPSULE) + FileSize;
109	FullCapsuleBuffer = AllocatePool(FullCapsuleBufferSize);
110	if (FullCapsuleBuffer == NULL) {
111	Print(L"CapsuleApp: Capsule Buffer size (0x%x) too big.\n", FullCapsuleBufferSize);
112	Status = EFI_OUT_OF_RESOURCES;
113	goto Done;
114	}
115
116	DisplayCapsule = (EFI_DISPLAY_CAPSULE *)FullCapsuleBuffer;
117	CopyGuid(&DisplayCapsule->CapsuleHeader.CapsuleGuid, &gWindowsUxCapsuleGuid);
118	DisplayCapsule->CapsuleHeader.HeaderSize = sizeof(DisplayCapsule->CapsuleHeader);
119	DisplayCapsule->CapsuleHeader.Flags = CAPSULE_FLAGS_PERSIST_ACROSS_RESET;
120	DisplayCapsule->CapsuleHeader.CapsuleImageSize = (UINT32)FullCapsuleBufferSize;
121
122	DisplayCapsule->ImagePayload.Version = 1;
123	DisplayCapsule->ImagePayload.Checksum = 0;
124	DisplayCapsule->ImagePayload.ImageType = 0; // BMP
125	DisplayCapsule->ImagePayload.Reserved = 0;
126	DisplayCapsule->ImagePayload.Mode = Gop->Mode->Mode;
127
128	//
129	// Center the bitmap horizontally
130	//
131	DisplayCapsule->ImagePayload.OffsetX = (UINT32)((Info->HorizontalResolution - Width) / 2);
132
133	//
134	// Put bitmap 3/4 down the display. If bitmap is too tall, then align bottom
135	// of bitmap at bottom of display.
136	//
137	DisplayCapsule->ImagePayload.OffsetY =
138	MIN (
139	(UINT32)(Info->VerticalResolution - Height),
140	(UINT32)(((3 * Info->VerticalResolution) - (2 * Height)) / 4)
141	);
142
143	Print(L"BMP image (%s), OffsetX - %d, OffsetY - %d\n",
144	BmpName,
145	DisplayCapsule->ImagePayload.OffsetX,
146	DisplayCapsule->ImagePayload.OffsetY
147	);
148
149	CopyMem((DisplayCapsule + 1), BmpBuffer, FileSize);
150
151	DisplayCapsule->ImagePayload.Checksum = CalculateCheckSum8(FullCapsuleBuffer, FullCapsuleBufferSize);
152
153	Status = WriteFileFromBuffer(OutputCapsuleName, FullCapsuleBufferSize, FullCapsuleBuffer);
154	Print(L"CapsuleApp: Write %s %r\n", OutputCapsuleName, Status);
155
156	Done:
157	if (BmpBuffer != NULL) {
158	FreePool(BmpBuffer);
159	}
160
161	if (FullCapsuleBuffer != NULL) {
162	FreePool(FullCapsuleBuffer);
163	}
164
165	return Status;
166	}
167
168	/**
169	Get ImageTypeId in the FMP capsule header.
170
171	@param[in] CapsuleHeader The FMP capsule image header.
172
173	@return ImageTypeId
174	**/
175	EFI_GUID *
176	GetCapsuleImageTypeId (
177	IN EFI_CAPSULE_HEADER *CapsuleHeader
178	)
179	{
180	EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER *FmpCapsuleHeader;
181	UINT64 *ItemOffsetList;
182	EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER *ImageHeader;
183
184	FmpCapsuleHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER )((UINT8 )CapsuleHeader + CapsuleHeader->HeaderSize);
185	ItemOffsetList = (UINT64 *)(FmpCapsuleHeader + 1);
186	if (FmpCapsuleHeader->PayloadItemCount == 0) {
187	return NULL;
188	}
189	ImageHeader = (EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER )((UINT8 )FmpCapsuleHeader + ItemOffsetList[FmpCapsuleHeader->EmbeddedDriverCount]);
190	return &ImageHeader->UpdateImageTypeId;
191	}
192
193	/**
194	Get ESRT FwType according to ImageTypeId
195
196	@param[in] ImageTypeId ImageTypeId of an FMP capsule.
197
198	@return ESRT FwType
199	**/
200	UINT32
201	GetEsrtFwType (
202	IN EFI_GUID *ImageTypeId
203	)
204	{
205	EFI_STATUS Status;
206	EFI_SYSTEM_RESOURCE_TABLE *Esrt;
207	EFI_SYSTEM_RESOURCE_ENTRY *EsrtEntry;
208	UINTN Index;
209
210	//
211	// Check ESRT
212	//
213	Status = EfiGetSystemConfigurationTable(&gEfiSystemResourceTableGuid, (VOID **)&Esrt);
214	if (!EFI_ERROR(Status)) {
215	ASSERT(Esrt != NULL);
216	EsrtEntry = (VOID *)(Esrt + 1);
217	for (Index = 0; Index < Esrt->FwResourceCount; Index++, EsrtEntry++) {
218	if (CompareGuid(&EsrtEntry->FwClass, ImageTypeId)) {
219	return EsrtEntry->FwType;
220	}
221	}
222	}
223
224	return ESRT_FW_TYPE_UNKNOWN;
225	}
226
227	/**
228	Validate if it is valid capsule header
229
230	This function assumes the caller provided correct CapsuleHeader pointer
231	and CapsuleSize.
232
233	This function validates the fields in EFI_CAPSULE_HEADER.
234
235	@param[in] CapsuleHeader Points to a capsule header.
236	@param[in] CapsuleSize Size of the whole capsule image.
237
238	**/
239	BOOLEAN
240	IsValidCapsuleHeader (
241	IN EFI_CAPSULE_HEADER *CapsuleHeader,
242	IN UINT64 CapsuleSize
243	)
244	{
245	if (CapsuleSize < sizeof (EFI_CAPSULE_HEADER)) {
246	return FALSE;
247	}
248	if (CapsuleHeader->CapsuleImageSize != CapsuleSize) {
249	return FALSE;
250	}
251	if (CapsuleHeader->HeaderSize > CapsuleHeader->CapsuleImageSize) {
252	return FALSE;
253	}
254	if (CapsuleHeader->HeaderSize < sizeof (EFI_CAPSULE_HEADER)) {
255	return FALSE;
256	}
257
258	return TRUE;
259	}
260
261	/**
262	Return if this CapsuleGuid is a FMP capsule GUID or not.
263
264	@param[in] CapsuleGuid A pointer to EFI_GUID
265
266	@retval TRUE It is a FMP capsule GUID.
267	@retval FALSE It is not a FMP capsule GUID.
268	**/
269	BOOLEAN
270	IsFmpCapsuleGuid (
271	IN EFI_GUID *CapsuleGuid
272	)
273	{
274	if (CompareGuid(&gEfiFmpCapsuleGuid, CapsuleGuid)) {
275	return TRUE;
276	}
277
278	return FALSE;
279	}
280
281	/**
282	Append a capsule header on top of current image.
283	This function follows Windows UEFI Firmware Update Platform document.
284
285	@retval EFI_SUCCESS The capsule header is appended.
286	@retval EFI_UNSUPPORTED Input parameter is not valid.
287	@retval EFI_OUT_OF_RESOURCES No enough resource to append capsule header.
288	**/
289	EFI_STATUS
290	CreateNestedFmp (
291	VOID
292	)
293	{
294	CHAR16 *OutputCapsuleName;
295	VOID *CapsuleBuffer;
296	UINTN FileSize;
297	CHAR16 *CapsuleName;
298	UINT8 *FullCapsuleBuffer;
299	UINTN FullCapsuleBufferSize;
300	EFI_CAPSULE_HEADER *NestedCapsuleHeader;
301	EFI_GUID *ImageTypeId;
302	UINT32 FwType;
303	EFI_STATUS Status;
304
305	if (Argc != 5) {
306	Print(L"CapsuleApp: Incorrect parameter count.\n");
307	return EFI_UNSUPPORTED;
308	}
309
310	if (StrCmp(Argv[3], L"-O") != 0) {
311	Print(L"CapsuleApp: NO output capsule name.\n");
312	return EFI_UNSUPPORTED;
313	}
314	OutputCapsuleName = Argv[4];
315
316	CapsuleBuffer = NULL;
317	FileSize = 0;
318	FullCapsuleBuffer = NULL;
319
320	CapsuleName = Argv[2];
321	Status = ReadFileToBuffer(CapsuleName, &FileSize, &CapsuleBuffer);
322	if (EFI_ERROR(Status)) {
323	Print(L"CapsuleApp: Capsule image (%s) is not found.\n", CapsuleName);
324	goto Done;
325	}
326	if (!IsValidCapsuleHeader (CapsuleBuffer, FileSize)) {
327	Print(L"CapsuleApp: Capsule image (%s) is not a valid capsule.\n", CapsuleName);
328	Status = EFI_INVALID_PARAMETER;
329	goto Done;
330	}
331
332	if (!IsFmpCapsuleGuid (&((EFI_CAPSULE_HEADER *) CapsuleBuffer)->CapsuleGuid)) {
333	Print(L"CapsuleApp: Capsule image (%s) is not a FMP capsule.\n", CapsuleName);
334	Status = EFI_INVALID_PARAMETER;
335	goto Done;
336	}
337
338	ImageTypeId = GetCapsuleImageTypeId(CapsuleBuffer);
339	if (ImageTypeId == NULL) {
340	Print(L"CapsuleApp: Capsule ImageTypeId is not found.\n");
341	Status = EFI_INVALID_PARAMETER;
342	goto Done;
343	}
344	FwType = GetEsrtFwType(ImageTypeId);
345	if ((FwType != ESRT_FW_TYPE_SYSTEMFIRMWARE) && (FwType != ESRT_FW_TYPE_DEVICEFIRMWARE)) {
346	Print(L"CapsuleApp: Capsule FwType is invalid.\n");
347	Status = EFI_INVALID_PARAMETER;
348	goto Done;
349	}
350
351	FullCapsuleBufferSize = NESTED_CAPSULE_HEADER_SIZE + FileSize;
352	FullCapsuleBuffer = AllocatePool(FullCapsuleBufferSize);
353	if (FullCapsuleBuffer == NULL) {
354	Print(L"CapsuleApp: Capsule Buffer size (0x%x) too big.\n", FullCapsuleBufferSize);
355	Status = EFI_OUT_OF_RESOURCES;
356	goto Done;
357	}
358
359	NestedCapsuleHeader = (EFI_CAPSULE_HEADER *)FullCapsuleBuffer;
360	ZeroMem(NestedCapsuleHeader, NESTED_CAPSULE_HEADER_SIZE);
361	CopyGuid(&NestedCapsuleHeader->CapsuleGuid, ImageTypeId);
362	NestedCapsuleHeader->HeaderSize = NESTED_CAPSULE_HEADER_SIZE;
363	NestedCapsuleHeader->Flags = (FwType == ESRT_FW_TYPE_SYSTEMFIRMWARE) ? SYSTEM_FIRMWARE_FLAG : DEVICE_FIRMWARE_FLAG;
364	NestedCapsuleHeader->CapsuleImageSize = (UINT32)FullCapsuleBufferSize;
365
366	CopyMem((UINT8 *)NestedCapsuleHeader + NestedCapsuleHeader->HeaderSize, CapsuleBuffer, FileSize);
367
368	Status = WriteFileFromBuffer(OutputCapsuleName, FullCapsuleBufferSize, FullCapsuleBuffer);
369	Print(L"CapsuleApp: Write %s %r\n", OutputCapsuleName, Status);
370
371	Done:
372	if (CapsuleBuffer != NULL) {
373	FreePool(CapsuleBuffer);
374	}
375
376	if (FullCapsuleBuffer != NULL) {
377	FreePool(FullCapsuleBuffer);
378	}
379
380	return Status;
381	}
382
383
384	/**
385	Clear capsule status variable.
386
387	@retval EFI_SUCCESS The capsule status variable is cleared.
388	**/
389	EFI_STATUS
390	ClearCapsuleStatusVariable (
391	VOID
392	)
393	{
394	EFI_STATUS Status;
395	UINT32 Index;
396	CHAR16 CapsuleVarName[20];
397	CHAR16 *TempVarName;
398	BOOLEAN Found;
399
400	StrCpyS (CapsuleVarName, sizeof(CapsuleVarName)/sizeof(CapsuleVarName[0]), L"Capsule");
401	TempVarName = CapsuleVarName + StrLen (CapsuleVarName);
402	Index = 0;
403
404	Found = FALSE;
405	while (TRUE) {
406	UnicodeSPrint (TempVarName, 5 * sizeof(CHAR16), L"%04x", Index);
407
408	Status = gRT->SetVariable (
409	CapsuleVarName,
410	&gEfiCapsuleReportGuid,
411	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_RUNTIME_ACCESS \| EFI_VARIABLE_BOOTSERVICE_ACCESS,
412	0,
413	(VOID *)NULL
414	);
415	if (Status == EFI_NOT_FOUND) {
416	//
417	// There is no more capsule variables, quit
418	//
419	break;
420	}
421	Found = TRUE;
422
423	Print (L"Clear %s %r\n", CapsuleVarName, Status);
424
425	Index++;
426	if (Index > 0xFFFF) {
427	break;
428	}
429	}
430
431	if (!Found) {
432	Print (L"No any Capsule#### variable found\n");
433	}
434
435	return EFI_SUCCESS;
436	}
437
438	/**
439	Build Gather list for a list of capsule images.
440
441	@param[in] CapsuleBuffer An array of pointer to capsule images
442	@param[in] FileSize An array of UINTN to capsule images size
443	@param[in] CapsuleNum The count of capsule images
444	@param[out] BlockDescriptors The block descriptors for the capsule images
445
446	@retval EFI_SUCCESS The block descriptors for the capsule images are constructed.
447	**/
448	EFI_STATUS
449	BuildGatherList (
450	IN VOID **CapsuleBuffer,
451	IN UINTN *FileSize,
452	IN UINTN CapsuleNum,
453	OUT EFI_CAPSULE_BLOCK_DESCRIPTOR **BlockDescriptors
454	)
455	{
456	EFI_STATUS Status;
457	EFI_CAPSULE_BLOCK_DESCRIPTOR *BlockDescriptors1;
458	EFI_CAPSULE_BLOCK_DESCRIPTOR *BlockDescriptors2;
459	EFI_CAPSULE_BLOCK_DESCRIPTOR *BlockDescriptorPre;
460	EFI_CAPSULE_BLOCK_DESCRIPTOR *BlockDescriptorsHeader;
461	EFI_CAPSULE_BLOCK_DESCRIPTOR *TempBlockPtr;
462	UINT8 *TempDataPtr;
463	UINTN SizeLeft;
464	UINTN Size;
465	INT32 Count;
466	INT32 Number;
467	UINTN Index;
468
469	TempBlockPtr = NULL;
470	BlockDescriptors1 = NULL;
471	BlockDescriptors2 = NULL;
472	BlockDescriptorPre = NULL;
473	BlockDescriptorsHeader = NULL;
474
475	for (Index = 0; Index < CapsuleNum; Index++) {
476	//
477	// Allocate memory for the descriptors.
478	//
479	if (NumberOfDescriptors == 1) {
480	Count = 2;
481	} else {
482	Count = (INT32)(NumberOfDescriptors + 2) / 2;
483	}
484
485	Size = Count * sizeof (EFI_CAPSULE_BLOCK_DESCRIPTOR);
486	BlockDescriptors1 = AllocateRuntimeZeroPool (Size);
487	if (BlockDescriptors1 == NULL) {
488	Print (L"CapsuleApp: failed to allocate memory for descriptors\n");
489	Status = EFI_OUT_OF_RESOURCES;
490	goto ERREXIT;
491	} else {
492	Print (L"CapsuleApp: creating capsule descriptors at 0x%X\n", (UINTN) BlockDescriptors1);
493	Print (L"CapsuleApp: capsule data starts at 0x%X with size 0x%X\n", (UINTN) CapsuleBuffer[Index], FileSize[Index]);
494	}
495
496	//
497	// Record descriptor header
498	//
499	if (Index == 0) {
500	BlockDescriptorsHeader = BlockDescriptors1;
501	}
502
503	if (BlockDescriptorPre != NULL) {
504	BlockDescriptorPre->Union.ContinuationPointer = (UINTN) BlockDescriptors1;
505	BlockDescriptorPre->Length = 0;
506	}
507
508	//
509	// Fill them in
510	//
511	TempBlockPtr = BlockDescriptors1;
512	TempDataPtr = CapsuleBuffer[Index];
513	SizeLeft = FileSize[Index];
514	for (Number = 0; (Number < Count - 1) && (SizeLeft != 0); Number++) {
515	//
516	// Divide remaining data in half
517	//
518	if (NumberOfDescriptors != 1) {
519	if (SizeLeft == 1) {
520	Size = 1;
521	} else {
522	Size = SizeLeft / 2;
523	}
524	} else {
525	Size = SizeLeft;
526	}
527	TempBlockPtr->Union.DataBlock = (UINTN)TempDataPtr;
528	TempBlockPtr->Length = Size;
529	Print (L"CapsuleApp: capsule block/size 0x%X/0x%X\n", (UINTN) TempDataPtr, Size);
530	SizeLeft -= Size;
531	TempDataPtr += Size;
532	TempBlockPtr++;
533	}
534
535	//
536	// Allocate the second list, point the first block's last entry to point
537	// to this one, and fill this one in. Worst case is that the previous
538	// list only had one element that pointed here, so we need at least two
539	// elements -- one to point to all the data, another to terminate the list.
540	//
541	if ((NumberOfDescriptors != 1) && (SizeLeft != 0)) {
542	Count = (INT32)(NumberOfDescriptors + 2) - Count;
543	if (Count == 1) {
544	Count++;
545	}
546
547	Size = Count * sizeof (EFI_CAPSULE_BLOCK_DESCRIPTOR);
548	BlockDescriptors2 = AllocateRuntimeZeroPool (Size);
549	if (BlockDescriptors2 == NULL) {
550	Print (L"CapsuleApp: failed to allocate memory for descriptors\n");
551	Status = EFI_OUT_OF_RESOURCES;
552	goto ERREXIT;
553	}
554
555	//
556	// Point the first list's last element to point to this second list.
557	//
558	TempBlockPtr->Union.ContinuationPointer = (UINTN) BlockDescriptors2;
559
560	TempBlockPtr->Length = 0;
561	TempBlockPtr = BlockDescriptors2;
562	for (Number = 0; Number < Count - 1; Number++) {
563	//
564	// If second-to-last one, then dump rest to this element
565	//
566	if (Number == (Count - 2)) {
567	Size = SizeLeft;
568	} else {
569	//
570	// Divide remaining data in half
571	//
572	if (SizeLeft == 1) {
573	Size = 1;
574	} else {
575	Size = SizeLeft / 2;
576	}
577	}
578
579	TempBlockPtr->Union.DataBlock = (UINTN)TempDataPtr;
580	TempBlockPtr->Length = Size;
581	Print (L"CapsuleApp: capsule block/size 0x%X/0x%X\n", (UINTN) TempDataPtr, Size);
582	SizeLeft -= Size;
583	TempDataPtr += Size;
584	TempBlockPtr++;
585	if (SizeLeft == 0) {
586	break;
587	}
588	}
589	}
590
591	BlockDescriptorPre = TempBlockPtr;
592	BlockDescriptors1 = NULL;
593	}
594
595	//
596	// Null-terminate.
597	//
598	if (TempBlockPtr != NULL) {
599	TempBlockPtr->Union.ContinuationPointer = (UINTN)NULL;
600	TempBlockPtr->Length = 0;
601	*BlockDescriptors = BlockDescriptorsHeader;
602	}
603
604	return EFI_SUCCESS;
605
606	ERREXIT:
607	if (BlockDescriptors1 != NULL) {
608	FreePool(BlockDescriptors1);
609	}
610
611	if (BlockDescriptors2 != NULL) {
612	FreePool(BlockDescriptors2);
613	}
614
615	return Status;
616	}
617
618	/**
619	Clear the Gather list for a list of capsule images.
620
621	@param[in] BlockDescriptors The block descriptors for the capsule images
622	@param[in] CapsuleNum The count of capsule images
623	**/
624	VOID
625	CleanGatherList (
626	IN EFI_CAPSULE_BLOCK_DESCRIPTOR *BlockDescriptors,
627	IN UINTN CapsuleNum
628	)
629	{
630	EFI_CAPSULE_BLOCK_DESCRIPTOR *TempBlockPtr;
631	EFI_CAPSULE_BLOCK_DESCRIPTOR *TempBlockPtr1;
632	EFI_CAPSULE_BLOCK_DESCRIPTOR *TempBlockPtr2;
633	UINTN Index;
634
635	if (BlockDescriptors != NULL) {
636	TempBlockPtr1 = BlockDescriptors;
637	while (1){
638	TempBlockPtr = TempBlockPtr1;
639	for (Index = 0; Index < CapsuleNum; Index++) {
640	if (TempBlockPtr[Index].Length == 0) {
641	break;
642	}
643	}
644
645	if (TempBlockPtr[Index].Union.ContinuationPointer == (UINTN)NULL) {
646	break;
647	}
648
649	TempBlockPtr2 = (VOID *) ((UINTN) TempBlockPtr[Index].Union.ContinuationPointer);
650	FreePool(TempBlockPtr1);
651	TempBlockPtr1 = TempBlockPtr2;
652	}
653	}
654	}
655
656	/**
657	Print APP usage.
658	**/
659	VOID
660	PrintUsage (
661	VOID
662	)
663	{
664	Print(L"CapsuleApp: usage\n");
665	Print(L" CapsuleApp <Capsule...> [-NR] [-OD [FSx]]\n");
666	Print(L" CapsuleApp -S\n");
667	Print(L" CapsuleApp -C\n");
668	Print(L" CapsuleApp -P\n");
669	Print(L" CapsuleApp -E\n");
670	Print(L" CapsuleApp -L\n");
671	Print(L" CapsuleApp -L INFO\n");
672	Print(L" CapsuleApp -F\n");
673	Print(L" CapsuleApp -G <BMP> -O <Capsule>\n");
674	Print(L" CapsuleApp -N <Capsule> -O <NestedCapsule>\n");
675	Print(L" CapsuleApp -D <Capsule>\n");
676	Print(L" CapsuleApp -P GET <ImageTypeId> <Index> -O <FileName>\n");
677	Print(L"Parameter:\n");
678	Print(L" -NR: No reset will be triggered for the capsule\n");
679	Print(L" with CAPSULE_FLAGS_PERSIST_ACROSS_RESET and without CAPSULE_FLAGS_INITIATE_RESET.\n");
680	Print(L" -OD: Delivery of Capsules via file on Mass Storage device.\n");
681	Print(L" -S: Dump capsule report variable (EFI_CAPSULE_REPORT_GUID),\n");
682	Print(L" which is defined in UEFI specification.\n");
683	Print(L" -C: Clear capsule report variable (EFI_CAPSULE_REPORT_GUID),\n");
684	Print(L" which is defined in UEFI specification.\n");
685	Print(L" -P: Dump UEFI FMP protocol info, or get image with specified\n");
686	Print(L" ImageTypeId and Index (decimal format) to a file if 'GET'\n");
687	Print(L" option is used.\n");
688	Print(L" -E: Dump UEFI ESRT table info.\n");
689	Print(L" -L: Dump provisioned capsule image information.\n");
690	Print(L" -F: Dump all EFI System Partition.\n");
691	Print(L" -G: Convert a BMP file to be an UX capsule,\n");
692	Print(L" according to Windows Firmware Update document\n");
693	Print(L" -N: Append a Capsule Header to an existing FMP capsule image\n");
694	Print(L" with its ImageTypeId supported by the system,\n");
695	Print(L" according to Windows Firmware Update document\n");
696	Print(L" -O: Output new Capsule file name\n");
697	Print(L" -D: Dump Capsule image header information, image payload\n");
698	Print(L" information if it is an UX capsule and FMP header\n");
699	Print(L" information if it is a FMP capsule.\n");
700	}
701
702	/**
703	Update Capsule image.
704
705	@param[in] ImageHandle The image handle.
706	@param[in] SystemTable The system table.
707
708	@retval EFI_SUCCESS Command completed successfully.
709	@retval EFI_UNSUPPORTED Command usage unsupported.
710	@retval EFI_INVALID_PARAMETER Command usage invalid.
711	@retval EFI_NOT_FOUND The input file can't be found.
712	**/
713	EFI_STATUS
714	EFIAPI
715	UefiMain (
716	IN EFI_HANDLE ImageHandle,
717	IN EFI_SYSTEM_TABLE *SystemTable
718	)
719	{
720	EFI_STATUS Status;
721	RETURN_STATUS RStatus;
722	UINTN CapsuleBufferSize[MAX_CAPSULE_NUM];
723	VOID *CapsuleBuffer[MAX_CAPSULE_NUM];
724	EFI_CAPSULE_BLOCK_DESCRIPTOR *BlockDescriptors;
725	EFI_CAPSULE_HEADER *CapsuleHeaderArray[MAX_CAPSULE_NUM + 1];
726	UINT64 MaxCapsuleSize;
727	EFI_RESET_TYPE ResetType;
728	BOOLEAN NeedReset;
729	BOOLEAN NoReset;
730	BOOLEAN CapsuleOnDisk;
731	CHAR16 *CapsuleName;
732	CHAR16 *CapsuleNames[MAX_CAPSULE_NUM];
733	CHAR16 *MapFsStr;
734	UINTN CapsuleNum;
735	UINTN Index;
736	UINTN ParaOdIndex;
737	UINTN ParaNrIndex;
738	EFI_GUID ImageTypeId;
739	UINTN ImageIndex;
740
741	BlockDescriptors = NULL;
742	MapFsStr = NULL;
743	CapsuleNum = 0;
744
745	Status = GetArg();
746	if (EFI_ERROR(Status)) {
747	Print(L"Please use UEFI SHELL to run this application!\n", Status);
748	return Status;
749	}
750	if (Argc < 2) {
751	PrintUsage();
752	return EFI_UNSUPPORTED;
753	}
754	if (StrCmp(Argv[1], L"-D") == 0) {
755	if (Argc != 3) {
756	Print(L"CapsuleApp: Incorrect parameter count.\n");
757	return EFI_UNSUPPORTED;
758	}
759	Status = DumpCapsule(Argv[2]);
760	return Status;
761	}
762	if (StrCmp(Argv[1], L"-G") == 0) {
763	Status = CreateBmpFmp();
764	return Status;
765	}
766	if (StrCmp(Argv[1], L"-N") == 0) {
767	Status = CreateNestedFmp();
768	return Status;
769	}
770	if (StrCmp(Argv[1], L"-S") == 0) {
771	Status = DumpCapsuleStatusVariable();
772	return EFI_SUCCESS;
773	}
774	if (StrCmp(Argv[1], L"-C") == 0) {
775	Status = ClearCapsuleStatusVariable();
776	return Status;
777	}
778	if (StrCmp(Argv[1], L"-P") == 0) {
779	if (Argc == 2) {
780	DumpFmpData();
781	}
782	if (Argc >= 3) {
783	if (StrCmp(Argv[2], L"GET") != 0) {
784	Print(L"CapsuleApp: Unrecognized option(%s).\n", Argv[2]);
785	return EFI_UNSUPPORTED;
786	} else {
787	if (Argc != 7) {
788	Print(L"CapsuleApp: Incorrect parameter count.\n");
789	return EFI_UNSUPPORTED;
790	}
791
792	//
793	// FMP->GetImage()
794	//
795	RStatus = StrToGuid (Argv[3], &ImageTypeId);
796	if (RETURN_ERROR (RStatus) \|\| (Argv[3][GUID_STRING_LENGTH] != L'\0')) {
797	Print (L"Invalid ImageTypeId - %s\n", Argv[3]);
798	return EFI_INVALID_PARAMETER;
799	}
800	ImageIndex = StrDecimalToUintn(Argv[4]);
801	if (StrCmp(Argv[5], L"-O") != 0) {
802	Print(L"CapsuleApp: NO output file name.\n");
803	return EFI_UNSUPPORTED;
804	}
805	DumpFmpImage(&ImageTypeId, ImageIndex, Argv[6]);
806	}
807	}
808	return EFI_SUCCESS;
809	}
810
811	if (StrCmp(Argv[1], L"-E") == 0) {
812	DumpEsrtData();
813	return EFI_SUCCESS;
814	}
815
816	if (StrCmp(Argv[1], L"-L") == 0) {
817	if (Argc >= 3 && StrCmp(Argv[2], L"INFO") == 0) {
818	DumpProvisionedCapsule(TRUE);
819	} else {
820	DumpProvisionedCapsule(FALSE);
821	}
822	return EFI_SUCCESS;
823	}
824
825	if (StrCmp(Argv[1], L"-F") == 0) {
826	DumpAllEfiSysPartition();
827	return EFI_SUCCESS;
828	}
829
830	if (Argv[1][0] == L'-') {
831	Print(L"CapsuleApp: Unrecognized option(%s).\n", Argv[1]);
832	return EFI_UNSUPPORTED;
833	}
834
835	CapsuleFirstIndex = 1;
836	NoReset = FALSE;
837	CapsuleOnDisk = FALSE;
838	ParaOdIndex = 0;
839	ParaNrIndex = 0;
840
841	for (Index = 1; Index < Argc; Index++) {
842	if (StrCmp(Argv[Index], L"-OD") == 0) {
843	ParaOdIndex = Index;
844	CapsuleOnDisk = TRUE;
845	} else if (StrCmp(Argv[Index], L"-NR") == 0) {
846	ParaNrIndex = Index;
847	NoReset = TRUE;
848	}
849	}
850
851	if (ParaOdIndex > ParaNrIndex) {
852	if (ParaNrIndex != 0) {
853	CapsuleLastIndex = ParaNrIndex - 1;
854	} else {
855	CapsuleLastIndex = ParaOdIndex - 1;
856	}
857
858	if (ParaOdIndex == Argc -1) {
859	MapFsStr = NULL;
860	} else if (ParaOdIndex == Argc - 2) {
861	MapFsStr = Argv[Argc-1];
862	} else {
863	Print (L"CapsuleApp: Cannot specify more than one FS mapping!\n");
864	Status = EFI_INVALID_PARAMETER;
865	goto Done;
866	}
867	} else if (ParaOdIndex < ParaNrIndex) {
868	if (ParaOdIndex != 0) {
869	CapsuleLastIndex = ParaOdIndex - 1;
870	if (ParaOdIndex == ParaNrIndex - 1) {
871	MapFsStr = NULL;
872	} else if (ParaOdIndex == ParaNrIndex - 2) {
873	MapFsStr = Argv[ParaOdIndex + 1];
874	} else {
875	Print (L"CapsuleApp: Cannot specify more than one FS mapping!\n");
876	Status = EFI_INVALID_PARAMETER;
877	goto Done;
878	}
879	} else {
880	CapsuleLastIndex = ParaNrIndex - 1;
881	}
882	} else {
883	CapsuleLastIndex = Argc - 1;
884	}
885
886	CapsuleNum = CapsuleLastIndex - CapsuleFirstIndex + 1;
887
888	if (CapsuleFirstIndex > CapsuleLastIndex) {
889	Print(L"CapsuleApp: NO capsule image.\n");
890	return EFI_UNSUPPORTED;
891	}
892	if (CapsuleNum > MAX_CAPSULE_NUM) {
893	Print(L"CapsuleApp: Too many capsule images.\n");
894	return EFI_UNSUPPORTED;
895	}
896
897	ZeroMem(&CapsuleBuffer, sizeof(CapsuleBuffer));
898	ZeroMem(&CapsuleBufferSize, sizeof(CapsuleBufferSize));
899	BlockDescriptors = NULL;
900
901	for (Index = 0; Index < CapsuleNum; Index++) {
902	CapsuleName = Argv[CapsuleFirstIndex + Index];
903	Status = ReadFileToBuffer(CapsuleName, &CapsuleBufferSize[Index], &CapsuleBuffer[Index]);
904	if (EFI_ERROR(Status)) {
905	Print(L"CapsuleApp: capsule image (%s) is not found.\n", CapsuleName);
906	goto Done;
907	}
908	if (!IsValidCapsuleHeader (CapsuleBuffer[Index], CapsuleBufferSize[Index])) {
909	Print(L"CapsuleApp: Capsule image (%s) is not a valid capsule.\n", CapsuleName);
910	return EFI_INVALID_PARAMETER;
911	}
912	CapsuleNames[Index] = CapsuleName;
913	}
914
915	//
916	// Every capsule use 2 descriptor 1 for data 1 for end
917	//
918	Status = BuildGatherList(CapsuleBuffer, CapsuleBufferSize, CapsuleNum, &BlockDescriptors);
919	if (EFI_ERROR(Status)) {
920	goto Done;
921	}
922
923	//
924	// Call the runtime service capsule.
925	//
926	NeedReset = FALSE;
927	for (Index = 0; Index < CapsuleNum; Index++) {
928	CapsuleHeaderArray[Index] = (EFI_CAPSULE_HEADER *) CapsuleBuffer[Index];
929	if ((CapsuleHeaderArray[Index]->Flags & CAPSULE_FLAGS_PERSIST_ACROSS_RESET) != 0) {
930	NeedReset = TRUE;
931	}
932	}
933	CapsuleHeaderArray[CapsuleNum] = NULL;
934
935	//
936	// Inquire platform capability of UpdateCapsule.
937	//
938	Status = gRT->QueryCapsuleCapabilities (CapsuleHeaderArray, CapsuleNum, &MaxCapsuleSize, &ResetType);
939	if (EFI_ERROR(Status)) {
940	Print (L"CapsuleApp: failed to query capsule capability - %r\n", Status);
941	goto Done;
942	}
943
944	for (Index = 0; Index < CapsuleNum; Index++) {
945	if (CapsuleBufferSize[Index] > MaxCapsuleSize) {
946	Print (L"CapsuleApp: capsule is too large to update, %ld is allowed\n", MaxCapsuleSize);
947	Status = EFI_UNSUPPORTED;
948	goto Done;
949	}
950	}
951
952	//
953	// Check whether is capsule on disk.
954	//
955	if (CapsuleOnDisk) {
956	Status = ProcessCapsuleOnDisk (CapsuleBuffer, CapsuleBufferSize, CapsuleNames, MapFsStr, CapsuleNum);
957	if (Status != EFI_SUCCESS) {
958	Print (L"CapsuleApp: failed to update capsule - %r\n", Status);
959	goto Done;
960	} else {
961	if (!NoReset) {
962	gRT->ResetSystem (ResetType, EFI_SUCCESS, 0, NULL);
963	} else {
964	goto Done;
965	}
966	}
967	}
968
969	//
970	// Check whether the input capsule image has the flag of persist across system reset.
971	//
972	if (NeedReset) {
973	Status = gRT->UpdateCapsule(CapsuleHeaderArray,CapsuleNum,(UINTN) BlockDescriptors);
974	if (Status != EFI_SUCCESS) {
975	Print (L"CapsuleApp: failed to update capsule - %r\n", Status);
976	goto Done;
977	}
978	//
979	// For capsule with CAPSULE_FLAGS_PERSIST_ACROSS_RESET + CAPSULE_FLAGS_INITIATE_RESET,
980	// a system reset should have been triggered by gRT->UpdateCapsule() calling above.
981	//
982	// For capsule with CAPSULE_FLAGS_PERSIST_ACROSS_RESET and without CAPSULE_FLAGS_INITIATE_RESET,
983	// check if -NR (no-reset) has been specified or not.
984	//
985	if (!NoReset) {
986	//
987	// For capsule who has reset flag and no -NR (no-reset) has been specified, after calling UpdateCapsule service,
988	// trigger a system reset to process capsule persist across a system reset.
989	//
990	gRT->ResetSystem (ResetType, EFI_SUCCESS, 0, NULL);
991	}
992	} else {
993	//
994	// For capsule who has no reset flag, only call UpdateCapsule Service without a
995	// system reset. The service will process the capsule immediately.
996	//
997	Status = gRT->UpdateCapsule (CapsuleHeaderArray,CapsuleNum,(UINTN) BlockDescriptors);
998	if (Status != EFI_SUCCESS) {
999	Print (L"CapsuleApp: failed to update capsule - %r\n", Status);
1000	}
1001	}
1002
1003	Status = EFI_SUCCESS;
1004
1005	Done:
1006	for (Index = 0; Index < CapsuleNum; Index++) {
1007	if (CapsuleBuffer[Index] != NULL) {
1008	FreePool (CapsuleBuffer[Index]);
1009	}
1010	}
1011
1012	CleanGatherList(BlockDescriptors, CapsuleNum);
1013
1014	return Status;
1015	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Application/CapsuleApp/CapsuleApp.c@ 89977

以其他格式下載: