VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb3/DebugCommunicationLibUsb3Dxe.c@ 77662

最後變更 在這個檔案從77662是 77662,由 vboxsync 提交於 6 年 前

EFI: First step in UDK2018 merge. Does not build yet.
  • 屬性 svn:eol-style 設為 native
檔案大小: 14.4 KB
行 
1/** @file
2 Debug Port Library implementation based on usb3 debug port.
3
4 Copyright (c) 2014 - 2018, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php.
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13**/
14
15#include <Base.h>
16#include <PiDxe.h>
17#include <Library/UefiBootServicesTableLib.h>
18#include <Library/HobLib.h>
19#include <Protocol/PciIo.h>
20#include <Protocol/IoMmu.h>
21#include <Protocol/DxeSmmReadyToLock.h>
22#include "DebugCommunicationLibUsb3Internal.h"
23
24GUID gUsb3DbgGuid = USB3_DBG_GUID;
25
26USB3_DEBUG_PORT_HANDLE mUsb3Instance = {USB3DBG_UNINITIALIZED};
27EFI_PHYSICAL_ADDRESS mUsb3InstanceAddr = 0;
28EFI_PHYSICAL_ADDRESS *mUsb3InstanceAddrPtr = NULL;
29EFI_PCI_IO_PROTOCOL *mUsb3PciIo = NULL;
30
31/**
32 Creates a named event that can be signaled.
33
34 This function creates an event using NotifyTpl, NoifyFunction.
35 If Name is NULL, then ASSERT().
36 If NotifyTpl is not a legal TPL value, then ASSERT().
37 If NotifyFunction is NULL, then ASSERT().
38
39 @param Name Supplies the GUID name of the event.
40 @param NotifyTpl Supplies the task priority level of the event notifications.
41 @param NotifyFunction Supplies the function to notify when the event is signaled.
42 @param Event A pointer to the event created.
43
44 @retval EFI_SUCCESS A named event was created.
45 @retval EFI_OUT_OF_RESOURCES There are not enough resource to create the named event.
46
47**/
48EFI_STATUS
49EFIAPI
50Usb3NamedEventListen (
51 IN CONST EFI_GUID *Name,
52 IN EFI_TPL NotifyTpl,
53 IN EFI_EVENT_NOTIFY NotifyFunction,
54 IN EFI_EVENT *Event
55 )
56{
57 EFI_STATUS Status;
58 VOID *RegistrationLocal;
59
60 ASSERT (Name != NULL);
61 ASSERT (NotifyFunction != NULL);
62 ASSERT (NotifyTpl <= TPL_HIGH_LEVEL);
63
64 //
65 // Create event
66 //
67 Status = gBS->CreateEvent (
68 EVT_NOTIFY_SIGNAL,
69 NotifyTpl,
70 NotifyFunction,
71 NULL,
72 Event
73 );
74 ASSERT_EFI_ERROR (Status);
75
76 //
77 // Register for an installation of protocol interface
78 //
79 Status = gBS->RegisterProtocolNotify (
80 (EFI_GUID *) Name,
81 *Event,
82 &RegistrationLocal
83 );
84 ASSERT_EFI_ERROR (Status);
85
86 return Status;
87}
88
89/**
90 USB3 map one DMA buffer.
91
92 @param PciIo Pointer to PciIo for USB3 debug port.
93 @param Address DMA buffer address to be mapped.
94 @param NumberOfBytes Number of bytes to be mapped.
95
96**/
97VOID
98Usb3MapOneDmaBuffer (
99 IN EFI_PCI_IO_PROTOCOL *PciIo,
100 IN EFI_PHYSICAL_ADDRESS Address,
101 IN UINTN NumberOfBytes
102 )
103{
104 EFI_STATUS Status;
105 VOID *HostAddress;
106 EFI_PHYSICAL_ADDRESS DeviceAddress;
107 VOID *Mapping;
108
109 HostAddress = (VOID *) (UINTN) Address;
110 Status = PciIo->Map (
111 PciIo,
112 EfiPciIoOperationBusMasterCommonBuffer,
113 HostAddress,
114 &NumberOfBytes,
115 &DeviceAddress,
116 &Mapping
117 );
118 ASSERT_EFI_ERROR (Status);
119 ASSERT (DeviceAddress == ((EFI_PHYSICAL_ADDRESS) (UINTN) HostAddress));
120}
121
122/**
123 USB3 map DMA buffers.
124
125 @param Instance Pointer to USB3 debug port instance.
126 @param PciIo Pointer to PciIo for USB3 debug port.
127
128**/
129VOID
130Usb3MapDmaBuffers (
131 IN USB3_DEBUG_PORT_HANDLE *Instance,
132 IN EFI_PCI_IO_PROTOCOL *PciIo
133 )
134{
135 Usb3MapOneDmaBuffer (
136 PciIo,
137 Instance->UrbIn.Data,
138 XHCI_DEBUG_DEVICE_MAX_PACKET_SIZE * 2 + USB3_DEBUG_PORT_WRITE_MAX_PACKET_SIZE
139 );
140
141 Usb3MapOneDmaBuffer (
142 PciIo,
143 Instance->TransferRingIn.RingSeg0,
144 sizeof (TRB_TEMPLATE) * TR_RING_TRB_NUMBER
145 );
146
147 Usb3MapOneDmaBuffer (
148 PciIo,
149 Instance->TransferRingOut.RingSeg0,
150 sizeof (TRB_TEMPLATE) * TR_RING_TRB_NUMBER
151 );
152
153 Usb3MapOneDmaBuffer (
154 PciIo,
155 Instance->EventRing.EventRingSeg0,
156 sizeof (TRB_TEMPLATE) * EVENT_RING_TRB_NUMBER
157 );
158
159 Usb3MapOneDmaBuffer (
160 PciIo,
161 Instance->EventRing.ERSTBase,
162 sizeof (EVENT_RING_SEG_TABLE_ENTRY) * ERST_NUMBER
163 );
164
165 Usb3MapOneDmaBuffer (
166 PciIo,
167 Instance->DebugCapabilityContext,
168 sizeof (XHC_DC_CONTEXT)
169 );
170
171 Usb3MapOneDmaBuffer (
172 PciIo,
173 ((XHC_DC_CONTEXT *) (UINTN) Instance->DebugCapabilityContext)->DbcInfoContext.String0DescAddress,
174 STRING0_DESC_LEN + MANU_DESC_LEN + PRODUCT_DESC_LEN + SERIAL_DESC_LEN
175 );
176}
177
178/**
179 Invoke a notification event
180
181 @param[in] Event Event whose notification function is being invoked.
182 @param[in] Context The pointer to the notification function's context,
183 which is implementation-dependent.
184
185**/
186VOID
187EFIAPI
188Usb3DxeSmmReadyToLockNotify (
189 IN EFI_EVENT Event,
190 IN VOID *Context
191 )
192{
193 USB3_DEBUG_PORT_HANDLE *Instance;
194
195 DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));
196
197 Instance = GetUsb3DebugPortInstance ();
198 ASSERT (Instance != NULL);
199
200 Instance->InNotify = TRUE;
201
202 //
203 // For the case that the USB3 debug port instance and DMA buffers are
204 // from PEI HOB with IOMMU enabled.
205 // Reinitialize USB3 debug port with granted DXE DMA buffer accessible
206 // by SMM environment.
207 //
208 InitializeUsbDebugHardware (Instance);
209
210 //
211 // Wait some time for host to be ready after re-initialization.
212 //
213 MicroSecondDelay (1000000);
214
215 Instance->InNotify = FALSE;
216 gBS->CloseEvent (Event);
217}
218
219/**
220 USB3 get IOMMU protocol.
221
222 @return Pointer to IOMMU protocol.
223
224**/
225EDKII_IOMMU_PROTOCOL *
226Usb3GetIoMmu (
227 VOID
228 )
229{
230 EFI_STATUS Status;
231 EDKII_IOMMU_PROTOCOL *IoMmu;
232
233 IoMmu = NULL;
234 Status = gBS->LocateProtocol (
235 &gEdkiiIoMmuProtocolGuid,
236 NULL,
237 (VOID **) &IoMmu
238 );
239 if (!EFI_ERROR (Status) && (IoMmu != NULL)) {
240 return IoMmu;
241 }
242
243 return NULL;
244}
245
246/**
247 Invoke a notification event
248
249 @param[in] Event Event whose notification function is being invoked.
250 @param[in] Context The pointer to the notification function's context,
251 which is implementation-dependent.
252
253**/
254VOID
255EFIAPI
256Usb3PciIoNotify (
257 IN EFI_EVENT Event,
258 IN VOID *Context
259 )
260{
261 EFI_STATUS Status;
262 UINTN PciIoHandleCount;
263 EFI_HANDLE *PciIoHandleBuffer;
264 UINTN Index;
265 EFI_PCI_IO_PROTOCOL *PciIo;
266 UINTN PciSegment;
267 UINTN PciBusNumber;
268 UINTN PciDeviceNumber;
269 UINTN PciFunctionNumber;
270 UINT32 PciAddress;
271 USB3_DEBUG_PORT_HANDLE *Instance;
272 EFI_EVENT SmmReadyToLockEvent;
273
274 Status = gBS->LocateHandleBuffer (
275 ByProtocol,
276 &gEfiPciIoProtocolGuid,
277 NULL,
278 &PciIoHandleCount,
279 &PciIoHandleBuffer
280 );
281 if (!EFI_ERROR (Status) &&
282 (PciIoHandleBuffer != NULL) &&
283 (PciIoHandleCount != 0)) {
284 for (Index = 0; Index < PciIoHandleCount; Index++) {
285 Status = gBS->HandleProtocol (
286 PciIoHandleBuffer[Index],
287 &gEfiPciIoProtocolGuid,
288 (VOID **) &PciIo
289 );
290 ASSERT_EFI_ERROR (Status);
291 Status = PciIo->GetLocation (PciIo, &PciSegment, &PciBusNumber, &PciDeviceNumber, &PciFunctionNumber);
292 ASSERT_EFI_ERROR (Status);
293 PciAddress = (UINT32) ((PciBusNumber << 20) | (PciDeviceNumber << 15) | (PciFunctionNumber << 12));
294 if (PciAddress == PcdGet32(PcdUsbXhciPciAddress)) {
295 //
296 // Found the PciIo for USB3 debug port.
297 //
298 DEBUG ((DEBUG_INFO, "%a()\n", __FUNCTION__));
299 if (Usb3GetIoMmu () != NULL) {
300 Instance = GetUsb3DebugPortInstance ();
301 ASSERT (Instance != NULL);
302 if (Instance->Ready) {
303 Instance->InNotify = TRUE;
304 Usb3MapDmaBuffers (Instance, PciIo);
305 Instance->InNotify = FALSE;
306
307 if (Instance->FromHob) {
308 mUsb3PciIo = PciIo;
309 Usb3NamedEventListen (
310 &gEfiDxeSmmReadyToLockProtocolGuid,
311 TPL_NOTIFY,
312 Usb3DxeSmmReadyToLockNotify,
313 &SmmReadyToLockEvent
314 );
315 }
316 }
317 }
318 gBS->CloseEvent (Event);
319 break;
320 }
321 }
322
323 gBS->FreePool (PciIoHandleBuffer);
324 }
325}
326
327/**
328 Return USB3 debug instance address pointer.
329
330**/
331EFI_PHYSICAL_ADDRESS *
332GetUsb3DebugPortInstanceAddrPtr (
333 VOID
334 )
335{
336 if (mUsb3InstanceAddrPtr == NULL) {
337 //
338 // Use the local variables temporarily.
339 //
340 mUsb3InstanceAddr = (EFI_PHYSICAL_ADDRESS) (UINTN) &mUsb3Instance;
341 mUsb3InstanceAddrPtr = &mUsb3InstanceAddr;
342 }
343 return mUsb3InstanceAddrPtr;
344}
345
346/**
347 Allocates pages that are suitable for an OperationBusMasterCommonBuffer or
348 OperationBusMasterCommonBuffer64 mapping.
349
350 @param PciIo Pointer to PciIo for USB3 debug port.
351 @param Pages The number of pages to allocate.
352 @param Address A pointer to store the base system memory address of the
353 allocated range.
354
355 @retval EFI_SUCCESS The requested memory pages were allocated.
356 @retval EFI_UNSUPPORTED Attributes is unsupported. The only legal attribute bits are
357 MEMORY_WRITE_COMBINE and MEMORY_CACHED.
358 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
359 @retval EFI_OUT_OF_RESOURCES The memory pages could not be allocated.
360
361**/
362EFI_STATUS
363Usb3AllocateDmaBuffer (
364 IN EFI_PCI_IO_PROTOCOL *PciIo,
365 IN UINTN Pages,
366 OUT VOID **Address
367 )
368{
369 EFI_STATUS Status;
370
371 *Address = NULL;
372 Status = PciIo->AllocateBuffer (
373 PciIo,
374 AllocateAnyPages,
375 EfiRuntimeServicesData,
376 Pages,
377 Address,
378 0
379 );
380 if (!EFI_ERROR (Status)) {
381 Usb3MapOneDmaBuffer (
382 PciIo,
383 (EFI_PHYSICAL_ADDRESS) (UINTN) *Address,
384 EFI_PAGES_TO_SIZE (Pages)
385 );
386 }
387 return Status;
388}
389
390/**
391 Allocate aligned memory for XHC's usage.
392
393 @param BufferSize The size, in bytes, of the Buffer.
394
395 @return A pointer to the allocated buffer or NULL if allocation fails.
396
397**/
398VOID*
399AllocateAlignBuffer (
400 IN UINTN BufferSize
401 )
402{
403 EFI_PHYSICAL_ADDRESS TmpAddr;
404 EFI_STATUS Status;
405 VOID *Buf;
406
407 Buf = NULL;
408
409 if (gBS != NULL) {
410 if (mUsb3PciIo != NULL) {
411 Usb3AllocateDmaBuffer (
412 mUsb3PciIo,
413 EFI_SIZE_TO_PAGES (BufferSize),
414 &Buf
415 );
416 } else {
417 TmpAddr = 0xFFFFFFFF;
418 Status = gBS->AllocatePages (
419 AllocateMaxAddress,
420 EfiACPIMemoryNVS,
421 EFI_SIZE_TO_PAGES (BufferSize),
422 &TmpAddr
423 );
424 if (!EFI_ERROR (Status)) {
425 Buf = (VOID *) (UINTN) TmpAddr;
426 }
427 }
428 }
429
430 return Buf;
431}
432
433/**
434 The constructor function initialize USB3 debug port.
435
436 @param ImageHandle The firmware allocated handle for the EFI image.
437 @param SystemTable A pointer to the EFI System Table.
438
439 @retval EFI_SUCCESS The constructor always returns EFI_SUCCESS.
440
441**/
442EFI_STATUS
443EFIAPI
444DebugCommunicationUsb3DxeConstructor (
445 IN EFI_HANDLE ImageHandle,
446 IN EFI_SYSTEM_TABLE *SystemTable
447 )
448{
449 EFI_PHYSICAL_ADDRESS *AddrPtr;
450 USB3_DEBUG_PORT_HANDLE *Instance;
451 EFI_PHYSICAL_ADDRESS Address;
452 EFI_STATUS Status;
453 EFI_EVENT Event;
454
455 Status = EfiGetSystemConfigurationTable (&gUsb3DbgGuid, (VOID **) &AddrPtr);
456 if (EFI_ERROR (Status)) {
457 //
458 // Instead of using local variables, install system configuration table for
459 // the local instance and the buffer to save instance address pointer.
460 //
461 Address = SIZE_4GB;
462 Status = gBS->AllocatePages (
463 AllocateMaxAddress,
464 EfiACPIMemoryNVS,
465 EFI_SIZE_TO_PAGES (sizeof (EFI_PHYSICAL_ADDRESS) + sizeof (USB3_DEBUG_PORT_HANDLE)),
466 &Address
467 );
468 if (EFI_ERROR (Status)) {
469 return Status;
470 }
471
472 AddrPtr = (EFI_PHYSICAL_ADDRESS *) (UINTN) Address;
473 ZeroMem (AddrPtr, sizeof (EFI_PHYSICAL_ADDRESS) + sizeof (USB3_DEBUG_PORT_HANDLE));
474 Instance = (USB3_DEBUG_PORT_HANDLE *) (AddrPtr + 1);
475 CopyMem (Instance, &mUsb3Instance, sizeof (USB3_DEBUG_PORT_HANDLE));
476 *AddrPtr = (EFI_PHYSICAL_ADDRESS) (UINTN) Instance;
477
478 Status = gBS->InstallConfigurationTable (&gUsb3DbgGuid, AddrPtr);
479 if (EFI_ERROR (Status)) {
480 return Status;
481 }
482 }
483
484 if (mUsb3InstanceAddrPtr != NULL) {
485 *AddrPtr = *mUsb3InstanceAddrPtr;
486 }
487 mUsb3InstanceAddrPtr = AddrPtr;
488
489 Instance = GetUsb3DebugPortInstance ();
490 ASSERT (Instance != NULL);
491
492 if (Instance->PciIoEvent == 0) {
493 Status = Usb3NamedEventListen (
494 &gEfiPciIoProtocolGuid,
495 TPL_NOTIFY,
496 Usb3PciIoNotify,
497 &Event
498 );
499 if (!EFI_ERROR (Status)) {
500 Instance->PciIoEvent = (EFI_PHYSICAL_ADDRESS) (UINTN) Event;
501 }
502 }
503
504 return EFI_SUCCESS;
505}
506
507/**
508 The destructor function.
509
510 @param ImageHandle The firmware allocated handle for the EFI image.
511 @param SystemTable A pointer to the EFI System Table.
512
513 @retval EFI_SUCCESS The destructor always returns EFI_SUCCESS.
514
515**/
516EFI_STATUS
517EFIAPI
518DebugCommunicationUsb3DxeDestructor (
519 IN EFI_HANDLE ImageHandle,
520 IN EFI_SYSTEM_TABLE *SystemTable
521 )
522{
523 USB3_DEBUG_PORT_HANDLE *Instance;
524
525 Instance = GetUsb3DebugPortInstance ();
526 ASSERT (Instance != NULL);
527
528 if (Instance->PciIoEvent != 0) {
529 //
530 // Close the event created.
531 //
532 gBS->CloseEvent ((EFI_EVENT) (UINTN) Instance->PciIoEvent);
533 Instance->PciIoEvent = 0;
534 }
535 return EFI_SUCCESS;
536}
537
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette