GraphicsOutput.c@ 85788

Last change on this file since 85788 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: 24.3 KB

Line
1	/** @file
2	Implementation for a generic GOP driver.
3
4	Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
5	SPDX-License-Identifier: BSD-2-Clause-Patent
6
7
8	**/
9
10	#include "GraphicsOutput.h"
11	CONST ACPI_ADR_DEVICE_PATH mGraphicsOutputAdrNode = {
12	{
13	ACPI_DEVICE_PATH,
14	ACPI_ADR_DP,
15	{ sizeof (ACPI_ADR_DEVICE_PATH), 0 },
16	},
17	ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 0, 0)
18	};
19
20	EFI_PEI_GRAPHICS_DEVICE_INFO_HOB mDefaultGraphicsDeviceInfo = {
21	MAX_UINT16, MAX_UINT16, MAX_UINT16, MAX_UINT16, MAX_UINT8, MAX_UINT8
22	};
23
24	//
25	// The driver should only start on one graphics controller.
26	// So a global flag is used to remember that the driver is already started.
27	//
28	BOOLEAN mDriverStarted = FALSE;
29
30	/**
31	Returns information for an available graphics mode that the graphics device
32	and the set of active video output devices supports.
33
34	@param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
35	@param ModeNumber The mode number to return information on.
36	@param SizeOfInfo A pointer to the size, in bytes, of the Info buffer.
37	@param Info A pointer to callee allocated buffer that returns information about ModeNumber.
38
39	@retval EFI_SUCCESS Valid mode information was returned.
40	@retval EFI_DEVICE_ERROR A hardware error occurred trying to retrieve the video mode.
41	@retval EFI_INVALID_PARAMETER ModeNumber is not valid.
42
43	**/
44	EFI_STATUS
45	EFIAPI
46	GraphicsOutputQueryMode (
47	IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
48	IN UINT32 ModeNumber,
49	OUT UINTN *SizeOfInfo,
50	OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info
51	)
52	{
53	if (This == NULL \|\| Info == NULL \|\| SizeOfInfo == NULL \|\| ModeNumber >= This->Mode->MaxMode) {
54	return EFI_INVALID_PARAMETER;
55	}
56
57	*SizeOfInfo = This->Mode->SizeOfInfo;
58	Info = AllocateCopyPool (SizeOfInfo, This->Mode->Info);
59	return EFI_SUCCESS;
60	}
61
62	/**
63	Set the video device into the specified mode and clears the visible portions of
64	the output display to black.
65
66	@param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
67	@param ModeNumber Abstraction that defines the current video mode.
68
69	@retval EFI_SUCCESS The graphics mode specified by ModeNumber was selected.
70	@retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
71	@retval EFI_UNSUPPORTED ModeNumber is not supported by this device.
72
73	**/
74	EFI_STATUS
75	EFIAPI
76	GraphicsOutputSetMode (
77	IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
78	IN UINT32 ModeNumber
79	)
80	{
81	RETURN_STATUS Status;
82	EFI_GRAPHICS_OUTPUT_BLT_PIXEL Black;
83	GRAPHICS_OUTPUT_PRIVATE_DATA *Private;
84
85	if (ModeNumber >= This->Mode->MaxMode) {
86	return EFI_UNSUPPORTED;
87	}
88
89	Private = GRAPHICS_OUTPUT_PRIVATE_FROM_THIS (This);
90
91	Black.Blue = 0;
92	Black.Green = 0;
93	Black.Red = 0;
94	Black.Reserved = 0;
95
96	Status = FrameBufferBlt (
97	Private->FrameBufferBltLibConfigure,
98	&Black,
99	EfiBltVideoFill,
100	0, 0,
101	0, 0,
102	This->Mode->Info->HorizontalResolution,
103	This->Mode->Info->VerticalResolution,
104	0
105	);
106	return RETURN_ERROR (Status) ? EFI_DEVICE_ERROR : EFI_SUCCESS;
107	}
108
109	/**
110	Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer.
111
112	@param This Protocol instance pointer.
113	@param BltBuffer The data to transfer to the graphics screen.
114	Size is at least WidthHeightsizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL).
115	@param BltOperation The operation to perform when copying BltBuffer on to the graphics screen.
116	@param SourceX The X coordinate of source for the BltOperation.
117	@param SourceY The Y coordinate of source for the BltOperation.
118	@param DestinationX The X coordinate of destination for the BltOperation.
119	@param DestinationY The Y coordinate of destination for the BltOperation.
120	@param Width The width of a rectangle in the blt rectangle in pixels.
121	@param Height The height of a rectangle in the blt rectangle in pixels.
122	@param Delta Not used for EfiBltVideoFill or the EfiBltVideoToVideo operation.
123	If a Delta of zero is used, the entire BltBuffer is being operated on.
124	If a subrectangle of the BltBuffer is being used then Delta
125	represents the number of bytes in a row of the BltBuffer.
126
127	@retval EFI_SUCCESS BltBuffer was drawn to the graphics screen.
128	@retval EFI_INVALID_PARAMETER BltOperation is not valid.
129	@retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
130
131	**/
132	EFI_STATUS
133	EFIAPI
134	GraphicsOutputBlt (
135	IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
136	IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
137	IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
138	IN UINTN SourceX,
139	IN UINTN SourceY,
140	IN UINTN DestinationX,
141	IN UINTN DestinationY,
142	IN UINTN Width,
143	IN UINTN Height,
144	IN UINTN Delta OPTIONAL
145	)
146	{
147	RETURN_STATUS Status;
148	EFI_TPL Tpl;
149	GRAPHICS_OUTPUT_PRIVATE_DATA *Private;
150
151	Private = GRAPHICS_OUTPUT_PRIVATE_FROM_THIS (This);
152	//
153	// We have to raise to TPL_NOTIFY, so we make an atomic write to the frame buffer.
154	// We would not want a timer based event (Cursor, ...) to come in while we are
155	// doing this operation.
156	//
157	Tpl = gBS->RaiseTPL (TPL_NOTIFY);
158	Status = FrameBufferBlt (
159	Private->FrameBufferBltLibConfigure,
160	BltBuffer,
161	BltOperation,
162	SourceX, SourceY,
163	DestinationX, DestinationY, Width, Height,
164	Delta
165	);
166	gBS->RestoreTPL (Tpl);
167
168	return RETURN_ERROR (Status) ? EFI_INVALID_PARAMETER : EFI_SUCCESS;
169	}
170
171	CONST GRAPHICS_OUTPUT_PRIVATE_DATA mGraphicsOutputInstanceTemplate = {
172	GRAPHICS_OUTPUT_PRIVATE_DATA_SIGNATURE, // Signature
173	NULL, // GraphicsOutputHandle
174	{
175	GraphicsOutputQueryMode,
176	GraphicsOutputSetMode,
177	GraphicsOutputBlt,
178	NULL // Mode
179	},
180	{
181	1, // MaxMode
182	0, // Mode
183	NULL, // Info
184	sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION), // SizeOfInfo
185	0, // FrameBufferBase
186	0 // FrameBufferSize
187	},
188	NULL, // DevicePath
189	NULL, // PciIo
190	0, // PciAttributes
191	NULL, // FrameBufferBltLibConfigure
192	0 // FrameBufferBltLibConfigureSize
193	};
194
195	/**
196	Test whether the Controller can be managed by the driver.
197
198	@param This Driver Binding protocol instance pointer.
199	@param Controller The PCI controller.
200	@param RemainingDevicePath Optional parameter use to pick a specific child
201	device to start.
202
203	@retval EFI_SUCCESS The driver can manage the video device.
204	@retval other The driver cannot manage the video device.
205	**/
206	EFI_STATUS
207	EFIAPI
208	GraphicsOutputDriverBindingSupported (
209	IN EFI_DRIVER_BINDING_PROTOCOL *This,
210	IN EFI_HANDLE Controller,
211	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
212	)
213	{
214	EFI_STATUS Status;
215	EFI_PCI_IO_PROTOCOL *PciIo;
216	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
217
218	//
219	// Since there is only one GraphicsInfo HOB, the driver only manages one video device.
220	//
221	if (mDriverStarted) {
222	return EFI_ALREADY_STARTED;
223	}
224
225	//
226	// Test the PCI I/O Protocol
227	//
228	Status = gBS->OpenProtocol (
229	Controller,
230	&gEfiPciIoProtocolGuid,
231	(VOID **) &PciIo,
232	This->DriverBindingHandle,
233	Controller,
234	EFI_OPEN_PROTOCOL_BY_DRIVER
235	);
236	if (Status == EFI_ALREADY_STARTED) {
237	Status = EFI_SUCCESS;
238	}
239	if (EFI_ERROR (Status)) {
240	return Status;
241	}
242	gBS->CloseProtocol (
243	Controller,
244	&gEfiPciIoProtocolGuid,
245	This->DriverBindingHandle,
246	Controller
247	);
248
249	//
250	// Test the DevicePath protocol
251	//
252	Status = gBS->OpenProtocol (
253	Controller,
254	&gEfiDevicePathProtocolGuid,
255	(VOID **) &DevicePath,
256	This->DriverBindingHandle,
257	Controller,
258	EFI_OPEN_PROTOCOL_BY_DRIVER
259	);
260	if (Status == EFI_ALREADY_STARTED) {
261	Status = EFI_SUCCESS;
262	}
263	if (EFI_ERROR (Status)) {
264	return Status;
265	}
266	gBS->CloseProtocol (
267	Controller,
268	&gEfiDevicePathProtocolGuid,
269	This->DriverBindingHandle,
270	Controller
271	);
272
273	if ((RemainingDevicePath == NULL) \|\|
274	IsDevicePathEnd (RemainingDevicePath) \|\|
275	CompareMem (RemainingDevicePath, &mGraphicsOutputAdrNode, sizeof (mGraphicsOutputAdrNode)) == 0) {
276	return EFI_SUCCESS;
277	} else {
278	return EFI_INVALID_PARAMETER;
279	}
280	}
281
282	/**
283	Start the video controller.
284
285	@param This Driver Binding protocol instance pointer.
286	@param ControllerHandle The PCI controller.
287	@param RemainingDevicePath Optional parameter use to pick a specific child
288	device to start.
289
290	@retval EFI_SUCCESS The driver starts to manage the video device.
291	@retval other The driver cannot manage the video device.
292	**/
293	EFI_STATUS
294	EFIAPI
295	GraphicsOutputDriverBindingStart (
296	IN EFI_DRIVER_BINDING_PROTOCOL *This,
297	IN EFI_HANDLE Controller,
298	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
299	)
300	{
301	EFI_STATUS Status;
302	RETURN_STATUS ReturnStatus;
303	GRAPHICS_OUTPUT_PRIVATE_DATA *Private;
304	EFI_PCI_IO_PROTOCOL *PciIo;
305	EFI_DEVICE_PATH *PciDevicePath;
306	PCI_TYPE00 Pci;
307	UINT8 Index;
308	EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Resources;
309	VOID *HobStart;
310	EFI_PEI_GRAPHICS_INFO_HOB *GraphicsInfo;
311	EFI_PEI_GRAPHICS_DEVICE_INFO_HOB *DeviceInfo;
312	EFI_PHYSICAL_ADDRESS FrameBufferBase;
313
314	FrameBufferBase = 0;
315
316	HobStart = GetFirstGuidHob (&gEfiGraphicsInfoHobGuid);
317	ASSERT ((HobStart != NULL) && (GET_GUID_HOB_DATA_SIZE (HobStart) == sizeof (EFI_PEI_GRAPHICS_INFO_HOB)));
318	GraphicsInfo = (EFI_PEI_GRAPHICS_INFO_HOB *) (GET_GUID_HOB_DATA (HobStart));
319
320	HobStart = GetFirstGuidHob (&gEfiGraphicsDeviceInfoHobGuid);
321	if ((HobStart == NULL) \|\| (GET_GUID_HOB_DATA_SIZE (HobStart) < sizeof (*DeviceInfo))) {
322	//
323	// Use default device infomation when the device info HOB doesn't exist
324	//
325	DeviceInfo = &mDefaultGraphicsDeviceInfo;
326	DEBUG ((DEBUG_INFO, "[%a]: GraphicsDeviceInfo HOB doesn't exist!\n", gEfiCallerBaseName));
327	} else {
328	DeviceInfo = (EFI_PEI_GRAPHICS_DEVICE_INFO_HOB *) (GET_GUID_HOB_DATA (HobStart));
329	DEBUG ((DEBUG_INFO, "[%a]: GraphicsDeviceInfo HOB:\n"
330	" VendorId = %04x, DeviceId = %04x,\n"
331	" RevisionId = %02x, BarIndex = %x,\n"
332	" SubsystemVendorId = %04x, SubsystemId = %04x\n",
333	gEfiCallerBaseName,
334	DeviceInfo->VendorId, DeviceInfo->DeviceId,
335	DeviceInfo->RevisionId, DeviceInfo->BarIndex,
336	DeviceInfo->SubsystemVendorId, DeviceInfo->SubsystemId));
337	}
338
339	//
340	// Open the PCI I/O Protocol
341	//
342	Status = gBS->OpenProtocol (
343	Controller,
344	&gEfiPciIoProtocolGuid,
345	(VOID **) &PciIo,
346	This->DriverBindingHandle,
347	Controller,
348	EFI_OPEN_PROTOCOL_BY_DRIVER
349	);
350	if (Status == EFI_ALREADY_STARTED) {
351	Status = EFI_SUCCESS;
352	}
353	ASSERT_EFI_ERROR (Status);
354
355	Status = gBS->OpenProtocol (
356	Controller,
357	&gEfiDevicePathProtocolGuid,
358	(VOID **) &PciDevicePath,
359	This->DriverBindingHandle,
360	Controller,
361	EFI_OPEN_PROTOCOL_BY_DRIVER
362	);
363	if (Status == EFI_ALREADY_STARTED) {
364	Status = EFI_SUCCESS;
365	}
366	ASSERT_EFI_ERROR (Status);
367
368	//
369	// Read the PCI Class Code from the PCI Device
370	//
371	Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);
372	if (!EFI_ERROR (Status)) {
373	if (!IS_PCI_DISPLAY (&Pci) \|\| (
374	((DeviceInfo->VendorId != MAX_UINT16) && (DeviceInfo->VendorId != Pci.Hdr.VendorId)) \|\|
375	((DeviceInfo->DeviceId != MAX_UINT16) && (DeviceInfo->DeviceId != Pci.Hdr.DeviceId)) \|\|
376	((DeviceInfo->RevisionId != MAX_UINT8) && (DeviceInfo->RevisionId != Pci.Hdr.RevisionID)) \|\|
377	((DeviceInfo->SubsystemVendorId != MAX_UINT16) && (DeviceInfo->SubsystemVendorId != Pci.Device.SubsystemVendorID)) \|\|
378	((DeviceInfo->SubsystemId != MAX_UINT16) && (DeviceInfo->SubsystemId != Pci.Device.SubsystemID))
379	)
380	) {
381	//
382	// It's not a video device, or device infomation doesn't match.
383	//
384	Status = EFI_UNSUPPORTED;
385	} else {
386	//
387	// If it's a video device and device information matches, use the BarIndex
388	// from device information, or any BAR if BarIndex is not specified
389	// whose size >= the frame buffer size from GraphicsInfo HOB.
390	// Store the new frame buffer base.
391	//
392	for (Index = 0; Index < MAX_PCI_BAR; Index++) {
393	if ((DeviceInfo->BarIndex != MAX_UINT8) && (DeviceInfo->BarIndex != Index)) {
394	continue;
395	}
396	Status = PciIo->GetBarAttributes (PciIo, Index, NULL, (VOID**) &Resources);
397	if (!EFI_ERROR (Status)) {
398	DEBUG ((DEBUG_INFO, "[%a]: BAR[%d]: Base = %lx, Length = %lx\n",
399	gEfiCallerBaseName, Index, Resources->AddrRangeMin, Resources->AddrLen));
400	if ((Resources->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) &&
401	(Resources->Len == (UINT16) (sizeof (EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR) - 3)) &&
402	(Resources->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM) &&
403	(Resources->AddrLen >= GraphicsInfo->FrameBufferSize)
404	) {
405	if (FrameBufferBase == 0) {
406	FrameBufferBase = Resources->AddrRangeMin;
407	}
408	if (DeviceInfo->BarIndex == MAX_UINT8) {
409	if (Resources->AddrRangeMin == GraphicsInfo->FrameBufferBase) {
410	FrameBufferBase = Resources->AddrRangeMin;
411	break;
412	}
413	} else {
414	break;
415	}
416	}
417	}
418	}
419	if (Index == MAX_PCI_BAR) {
420	Status = EFI_UNSUPPORTED;
421	} else {
422	DEBUG ((DEBUG_INFO, "[%a]: ... matched!\n", gEfiCallerBaseName));
423	}
424	}
425	}
426
427	if (EFI_ERROR (Status)) {
428	goto CloseProtocols;
429	}
430
431	if ((RemainingDevicePath != NULL) && IsDevicePathEnd (RemainingDevicePath)) {
432	return EFI_SUCCESS;
433	}
434
435	Private = AllocateCopyPool (sizeof (mGraphicsOutputInstanceTemplate), &mGraphicsOutputInstanceTemplate);
436	if (Private == NULL) {
437	Status = EFI_OUT_OF_RESOURCES;
438	goto CloseProtocols;
439	}
440
441	Private->GraphicsOutputMode.FrameBufferBase = FrameBufferBase;
442	Private->GraphicsOutputMode.FrameBufferSize = GraphicsInfo->FrameBufferSize;
443	Private->GraphicsOutputMode.Info = &GraphicsInfo->GraphicsMode;
444
445	//
446	// Fix up Mode pointer in GraphicsOutput
447	//
448	Private->GraphicsOutput.Mode = &Private->GraphicsOutputMode;
449
450	//
451	// Set attributes
452	//
453	Status = PciIo->Attributes (
454	PciIo,
455	EfiPciIoAttributeOperationGet,
456	0,
457	&Private->PciAttributes
458	);
459	if (!EFI_ERROR (Status)) {
460	Status = PciIo->Attributes (
461	PciIo,
462	EfiPciIoAttributeOperationEnable,
463	EFI_PCI_DEVICE_ENABLE,
464	NULL
465	);
466	}
467
468	if (EFI_ERROR (Status)) {
469	goto FreeMemory;
470	}
471
472	//
473	// Create the FrameBufferBltLib configuration.
474	//
475	ReturnStatus = FrameBufferBltConfigure (
476	(VOID *) (UINTN) Private->GraphicsOutput.Mode->FrameBufferBase,
477	Private->GraphicsOutput.Mode->Info,
478	Private->FrameBufferBltLibConfigure,
479	&Private->FrameBufferBltLibConfigureSize
480	);
481	if (ReturnStatus == RETURN_BUFFER_TOO_SMALL) {
482	Private->FrameBufferBltLibConfigure = AllocatePool (Private->FrameBufferBltLibConfigureSize);
483	if (Private->FrameBufferBltLibConfigure != NULL) {
484	ReturnStatus = FrameBufferBltConfigure (
485	(VOID *) (UINTN) Private->GraphicsOutput.Mode->FrameBufferBase,
486	Private->GraphicsOutput.Mode->Info,
487	Private->FrameBufferBltLibConfigure,
488	&Private->FrameBufferBltLibConfigureSize
489	);
490	}
491	}
492	if (RETURN_ERROR (ReturnStatus)) {
493	Status = EFI_OUT_OF_RESOURCES;
494	goto RestorePciAttributes;
495	}
496
497	Private->DevicePath = AppendDevicePathNode (PciDevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &mGraphicsOutputAdrNode);
498	if (Private->DevicePath == NULL) {
499	Status = EFI_OUT_OF_RESOURCES;
500	goto RestorePciAttributes;
501	}
502
503	Status = gBS->InstallMultipleProtocolInterfaces (
504	&Private->GraphicsOutputHandle,
505	&gEfiGraphicsOutputProtocolGuid, &Private->GraphicsOutput,
506	&gEfiDevicePathProtocolGuid, Private->DevicePath,
507	NULL
508	);
509
510	if (!EFI_ERROR (Status)) {
511	Status = gBS->OpenProtocol (
512	Controller,
513	&gEfiPciIoProtocolGuid,
514	(VOID **) &Private->PciIo,
515	This->DriverBindingHandle,
516	Private->GraphicsOutputHandle,
517	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
518	);
519	if (!EFI_ERROR (Status)) {
520	mDriverStarted = TRUE;
521	} else {
522	gBS->UninstallMultipleProtocolInterfaces (
523	Private->GraphicsOutputHandle,
524	&gEfiGraphicsOutputProtocolGuid, &Private->GraphicsOutput,
525	&gEfiDevicePathProtocolGuid, Private->DevicePath,
526	NULL
527	);
528	}
529	}
530
531	RestorePciAttributes:
532	if (EFI_ERROR (Status)) {
533	//
534	// Restore original PCI attributes
535	//
536	PciIo->Attributes (
537	PciIo,
538	EfiPciIoAttributeOperationSet,
539	Private->PciAttributes,
540	NULL
541	);
542	}
543
544	FreeMemory:
545	if (EFI_ERROR (Status)) {
546	if (Private != NULL) {
547	if (Private->DevicePath != NULL) {
548	FreePool (Private->DevicePath);
549	}
550	if (Private->FrameBufferBltLibConfigure != NULL) {
551	FreePool (Private->FrameBufferBltLibConfigure);
552	}
553	FreePool (Private);
554	}
555	}
556
557	CloseProtocols:
558	if (EFI_ERROR (Status)) {
559	//
560	// Close the PCI I/O Protocol
561	//
562	gBS->CloseProtocol (
563	Controller,
564	&gEfiDevicePathProtocolGuid,
565	This->DriverBindingHandle,
566	Controller
567	);
568
569	//
570	// Close the PCI I/O Protocol
571	//
572	gBS->CloseProtocol (
573	Controller,
574	&gEfiPciIoProtocolGuid,
575	This->DriverBindingHandle,
576	Controller
577	);
578	}
579	return Status;
580	}
581
582	/**
583	Stop the video controller.
584
585	@param This Driver Binding protocol instance pointer.
586	@param Controller The PCI controller.
587	@param NumberOfChildren The number of child device handles in ChildHandleBuffer.
588	@param ChildHandleBuffer An array of child handles to be freed. May be NULL
589	if NumberOfChildren is 0.
590
591	@retval EFI_SUCCESS The device was stopped.
592	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
593	**/
594	EFI_STATUS
595	EFIAPI
596	GraphicsOutputDriverBindingStop (
597	IN EFI_DRIVER_BINDING_PROTOCOL *This,
598	IN EFI_HANDLE Controller,
599	IN UINTN NumberOfChildren,
600	IN EFI_HANDLE *ChildHandleBuffer
601	)
602	{
603	EFI_STATUS Status;
604	EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop;
605	GRAPHICS_OUTPUT_PRIVATE_DATA *Private;
606
607	if (NumberOfChildren == 0) {
608
609	//
610	// Close the PCI I/O Protocol
611	//
612	Status = gBS->CloseProtocol (
613	Controller,
614	&gEfiPciIoProtocolGuid,
615	This->DriverBindingHandle,
616	Controller
617	);
618	ASSERT_EFI_ERROR (Status);
619
620	Status = gBS->CloseProtocol (
621	Controller,
622	&gEfiDevicePathProtocolGuid,
623	This->DriverBindingHandle,
624	Controller
625	);
626	ASSERT_EFI_ERROR (Status);
627	return EFI_SUCCESS;
628	}
629
630	ASSERT (NumberOfChildren == 1);
631	Status = gBS->OpenProtocol (
632	ChildHandleBuffer[0],
633	&gEfiGraphicsOutputProtocolGuid,
634	(VOID **) &Gop,
635	This->DriverBindingHandle,
636	ChildHandleBuffer[0],
637	EFI_OPEN_PROTOCOL_GET_PROTOCOL
638	);
639	if (EFI_ERROR (Status)) {
640	return Status;
641	}
642
643	Private = GRAPHICS_OUTPUT_PRIVATE_FROM_THIS (Gop);
644
645	Status = gBS->CloseProtocol (
646	Controller,
647	&gEfiPciIoProtocolGuid,
648	This->DriverBindingHandle,
649	Private->GraphicsOutputHandle
650	);
651	ASSERT_EFI_ERROR (Status);
652	//
653	// Remove the GOP protocol interface from the system
654	//
655	Status = gBS->UninstallMultipleProtocolInterfaces (
656	Private->GraphicsOutputHandle,
657	&gEfiGraphicsOutputProtocolGuid, &Private->GraphicsOutput,
658	&gEfiDevicePathProtocolGuid, Private->DevicePath,
659	NULL
660	);
661	if (!EFI_ERROR (Status)) {
662	//
663	// Restore original PCI attributes
664	//
665	Status = Private->PciIo->Attributes (
666	Private->PciIo,
667	EfiPciIoAttributeOperationSet,
668	Private->PciAttributes,
669	NULL
670	);
671	ASSERT_EFI_ERROR (Status);
672
673	FreePool (Private->DevicePath);
674	FreePool (Private->FrameBufferBltLibConfigure);
675	mDriverStarted = FALSE;
676	} else {
677	Status = gBS->OpenProtocol (
678	Controller,
679	&gEfiPciIoProtocolGuid,
680	(VOID **) &Private->PciIo,
681	This->DriverBindingHandle,
682	Private->GraphicsOutputHandle,
683	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
684	);
685	ASSERT_EFI_ERROR (Status);
686	}
687	return Status;
688	}
689
690	EFI_DRIVER_BINDING_PROTOCOL mGraphicsOutputDriverBinding = {
691	GraphicsOutputDriverBindingSupported,
692	GraphicsOutputDriverBindingStart,
693	GraphicsOutputDriverBindingStop,
694	0x10,
695	NULL,
696	NULL
697	};
698
699	/**
700	The Entry Point for GraphicsOutput driver.
701
702	It installs DriverBinding, ComponentName and ComponentName2 protocol if there is
703	GraphicsInfo HOB passed from Graphics PEIM.
704
705	@param[in] ImageHandle The firmware allocated handle for the EFI image.
706	@param[in] SystemTable A pointer to the EFI System Table.
707
708	@retval EFI_SUCCESS The entry point is executed successfully.
709	@retval other Some error occurs when executing this entry point.
710
711	**/
712	EFI_STATUS
713	EFIAPI
714	InitializeGraphicsOutput (
715	IN EFI_HANDLE ImageHandle,
716	IN EFI_SYSTEM_TABLE *SystemTable
717	)
718	{
719	EFI_STATUS Status;
720	VOID *HobStart;
721
722	HobStart = GetFirstGuidHob (&gEfiGraphicsInfoHobGuid);
723
724	if ((HobStart == NULL) \|\| (GET_GUID_HOB_DATA_SIZE (HobStart) < sizeof (EFI_PEI_GRAPHICS_INFO_HOB))) {
725	return EFI_NOT_FOUND;
726	}
727
728	Status = EfiLibInstallDriverBindingComponentName2 (
729	ImageHandle,
730	SystemTable,
731	&mGraphicsOutputDriverBinding,
732	ImageHandle,
733	&mGraphicsOutputComponentName,
734	&mGraphicsOutputComponentName2
735	);
736	ASSERT_EFI_ERROR (Status);
737
738	return Status;
739	}

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

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/UefiPayloadPkg/GraphicsOutputDxe/GraphicsOutput.c@ 85788

Download in other formats: